Help us improve by taking our short survey: https://www.hdfgroup.org/website-survey/

| HDF5 Last Updated on 2025-11-11 The HDF5 Field Guide

- Main Page
- Getting started
- User Guide
- Reference Manual
- Cookbook
- Technical Notes
- RFCs
- Specifications
- Glossary
- Full-Text Search
- About

Loading...
Searching...
No Matches
HDF5 Virtual Object Layer (VOL) Connector Author Guide

Navigate back: Main / Technical Notes

# Introduction

The Virtual Object Layer (VOL) is an abstraction layer in the HDF5 library which intercepts all API calls that could potentially access objects in an HDF5 container and forwards those calls to object drivers referred to as VOL connectors. The architecture of this feature is described in the HDF5 Virtual Object Layer (VOL) and VOL Architecture and Internals Documentation and will not be duplicated here.

This guide is for people who are interested in developing their own VOL connector for the HDF5 library. It is assumed that the reader has good knowledge of the VOL architecture obtained by reading the VOL architectural design document.

# Creating a New Connector

## Overview

Creating a new VOL connector can be a complicated process. You will need to map your storage system to the HDF5 data model through the lens of the VOL and this may involve some impedance mismatch that you will have to work around. The good news is that the HDF5 library has been re-engineered to handle arbitrary, connector-specific data structures via the VOL callbacks, so no knowledge of the library internals is necessary to write a VOL connector.

Writing a VOL connector requires these things:

- Decide on library vs plugin vs internal.
- Set up your build/test files (CMake, Autotools, etc.).
- Fill in some boilerplate information in yourH5VLclasststruct.
- Decide how you will perform any necessary initialization needed by your storage system.
- Map Storage to HDF5 File Objects
- Create implementations for the callbacks you need to support.
- Test the connector.

Each of the steps listed above is described in more detail in this section of the document.

The "model then implement" steps can be performed iteratively. You might begin by only supporting files, datasets, and groups and only allowing basic operations on them. In some cases, this may be all that is needed. As your needs grow, you can repeat those steps and increase the connector's HDF5 API coverage at a pace that makes sense for your users.

Also, note that this document only covers writing VOL connectors using the C programming language. It is often possible to write connectors in other programming languages (e.g.; Python) via the language's C interop facilities, but that topic is out of scope for this document.

## The HDF5 1.12.x VOL Interface Is DEPRECATED

Important changes were made to the VOL interface for HDF5 1.13.0 and, due to binary compatibility issues, these cannot be merged to HDF5 1.12.x. For this reason, VOL connector development should be shifted to target 1.13.0 as no further development of the VOL interface will take place on the 1.12.x branch. Unlike the other development branches of the library, there is no hdf5_1_13 branch - all HDF5 1.13.0 development is taking place in the develop branch of the HDF5 repository and 1.13.x branches will split off from that.

Note also that HDF5 1.13.0 is considered an unstable branch, and the API and file format are subject to change ("unstable" means "not yet finalized", not "buggy"). The VOL feature is under active development and, although it is nearing its final form, may change further before the stable HDF5 1.14.0 release targeted for 2022.

## VOL-Related HDF5 Header Files

Use of the VOL, including topics such as registration and loading VOL plugins, is described in the HDF5 Virtual Object Layer (VOL).

Public header Files you will need to be familiar with include:

H5VLpublic.h | Public VOL header.
H5VLconnector.h | Main header for connector authors. Contains definitions for the main VOL struct and callbacks, enum values, etc.
H5VLconnector_passthru.h | Helper routines for passthrough connector authors.
H5VLnative.h | Native VOL connector header. May be useful if your connector will attempt to implement native HDF5 API calls that are handled via the optional callbacks.
H5PLextern.h | Needed if your connector will be built as a plugin.

Many VOL connectors are listed on The HDF Group's VOL plugin registration page, located at: Registered VOL Connectors. Not all of these VOL connectors are supported by The HDF Group and the level of completeness varies, but the connectors found there can serve as examples of working implementations

## Library vs Plugin vs Internal

When building a VOL connector, you have several options:

#### Library

The connector can be built as a normal shared or static library. Software that uses your connector will have to link to it just like any other library. This can be convenient since you don't have to deal with plugin paths and searching for the connector at runtime, but it also means that software which uses your connector will have to be built and linked against it.

#### Plugin

You can also build your connector as a dynamically loaded plugin. The mechanism for this is the same mechanism used to dynamically load HDF5 filter plugins. This can allow use of your connector via the VOL environment variable, without modifying the application, but requires your plugin to be discoverable at runtime. See the HDF5 Virtual Object Layer (VOL) for more information about using HDF5 plugins.

To build your connector as a plugin, you will have to include H5PLextern.h (a public header distributed with the library) and implement the H5PLget_plugin_type H5PLget_plugin_info calls, both of which are trivial to code up. It also often requires your connector to be built with certain compile/link options. The VOL connector template does all of these things.

The HDF5 library's plugin loading code will call H5PLget_plugin_type to determine the type of plugin(e.g.; filter, VOL) and H5PLget_plugin_info to get the class struct, which allows the library to query the plugin for its name and value to see if it has found a requested plugin. When a match is found, the library will use the class struct to register the connector and map its callbacks.

For the HDF5 library to be able to load an external plugin dynamically, the plugin developer has to define two public routines with the following name and signature:

H5PL_type_t H5PLget_plugin_type(void);
const void *H5PLget_plugin_info(void);
H5PLget_plugin_type
H5PL_type_t H5PLget_plugin_type(void)
H5PLget_plugin_info
const void * H5PLget_plugin_info(void)
H5PL_type_t
H5PL_type_t
Definition H5PLpublic.h:33

To show how easy this is to accomplish, here is the complete implementation of those functions in the template VOL connector:

H5PL_type_t H5PLget_plugin_type(void) { return H5PL_TYPE_VOL; }
const void *H5PLget_plugin_info(void) { return &template_class_g; }
H5PL_TYPE_VOL
@ H5PL_TYPE_VOL
Definition H5PLpublic.h:36

H5PLget_plugin_type should return the library type which should always be H5PL_TYPE_VOL. H5PLget_plugin_info should return a pointer to the plugin structure defining the VOL plugin with all the callbacks. For example, consider an external plugin defined as:

static const H5VL_class_t H5VL_foo_g = {
2, // version
12345, // value
"foo", // name
...
}
H5VL_class_t
Definition H5VLconnector.h:1020

The plugin would implement the two routines as:

H5PL_type_t H5PLget_plugin_type(void)
{return H5PL_TYPE_VOL;}
const void *H5PLget_plugin_info(void)
{return &H5VL_foo_g;}

#### Internal

Your VOL connector can also be constructed as a part of the HDF5 library. This works in the same way as the stdio and multi virtual file drivers (VFDs) and does not require knowledge of HDF5 internals or use of non-public API calls. You simply have to add your connector's files to the Makefile.am and/or CMakeLists.txt files in the source distribution's src directory. This requires maintaining a private build of the library, though, and is not recommended.

## Build Files / VOL Template

We have created a template terminal VOL connector that includes both Autotools and CMake build files. The constructed VOL connector includes no real functionality, but can be registered and loaded as a plugin.

The VOL template can be found here: VOL template

The purpose of this template is to quickly get you to the point where you can begin filling in the callback functions and writing tests. You can copy this code to your own repository to serve as the basis for your new connector.

A template passthrough VOL is also available. This will be discussed in the section on passthrough connectors.

## H5VL_class_t Boilerplate

Several fields in the H5VLclasststruct will need to be filled in.

In HDF5 1.13.0, the version field will be 2, indicating the connector targets version 2 of the H5VL_class_t struct. Version 1 of the struct was never formally released and only available in the develop branch of the HDF5 git repository. Version 0 is used in the deprecated HDF5 1.12.x branch.

Every connector needs a name and value. The library will use these when loading and registering the connector (as described in the HDF5 Virtual Object Layer (VOL)), so they should be unique in your ecosystem.

VOL connector values are integers, with a maximum value of 65535. Values from 0 to 255 are reserved for internal use by The HDF Group. The native VOL connector has a value of 0. Values of 256 to 511 are for connector testing and should not be found in the wild. Values of 512 to 65535 are for external connectors.

As is the case with HDF5 filters, The HDF Group can assign you an official VOL connector value. Please contact help@hdfgroup.org for help with this. We currently do not register connector names, though the name you've chosen will appear on the registered VOL connectors page.

As noted above, registered VOL connectors will be listed at: Registered VOL Connectors

A new conn_version field has been added to the class struct for 1.13. This field is currently not used by the library so its use is determined by the connector author. Best practices for this field will be determined in the near future and this part of the guide will be updated.

The cap_flags field is used to determine the capabilities of the VOL connector. At this time, the use of this field is limited to indicating thread-safety, asynchronous capabilities, and ability to produce native HDF5 files. Supported flags can be found in H5VLconnector.h.

// Capability flags for connector
#define H5VL_CAP_FLAG_NONE 0 // No special connector capabilities
#define H5VL_CAP_FLAG_THREADSAFE 0x01 // Connector is threadsafe
#define H5VL_CAP_FLAG_ASYNC 0x02 // Connector performs operations asynchronously
#define H5VL_CAP_FLAG_NATIVE_FILES 0x04 // Connector produces native file format

## Initialization and Shutdown

You'll need to decide how to perform any initialization and shutdown tasks that are required by your connector. There are initialize and terminate callbacks in the H5VL_class_t struct to handle this. They are invoked when the connector is registered and unregistered, respectively. The initialize callback can take a VOL initialization property list, so any properties you need for initialization can be applied to it. The HDF5 library currently makes no use of the vipl so there are no default vipl properties.

If this is unsuitable, you may have to create custom connector-specific API calls to handle initialization and termination. It may also be useful to perform operations in a custom API call used to set the VOL connector in the fapl.

The initialization and terminate callbacks:

herr_t (*initialize)(hid_t vipl_id); // Connector initialization callback
herr_t (*terminate)(void); // Connector termination callback
hid_t
int64_t hid_t
Definition H5Ipublic.h:60
herr_t
int herr_t
Definition H5public.h:252

## Map Storage to HDF5 File Objects

The most difficult part of designing a new VOL connector is determining how to support HDF5 file objects and operations using your storage system. There isn't much specific advice to give here, as each connector will have unique needs, but a forthcoming "tutorial" connector will set up a simple connector and demonstrate this process.

## Fill In VOL Callbacks

For each file object you support in your connector (including the file itself), you will need to create a data struct to hold whatever file object metadata that are needed by your connector. For example, a data structure for a VOL connector based on text files might have a file struct that contains a file pointer for the text file, buffers used for caching data, etc. Pointers to these data structures are where your connector's state is stored and are returned to the HDF5 library from the create/open/etc. callbacks such as dataset create.

Once you have your data structures, you'll need to create your own implementations of the callback functions and map them via your H5VL_class_t struct.

## Handling Optional Operations

Handling optional operations has changed significantly in HDF5 1.13.0. In the past, optional operations were specified using an integer opt_type parameter. This proved to be a problem with pass-through connectors, though, as it was possible to have opt_type clash if two connectors used the same opt_type values.

The new scheme allows a connector to register an optional operation with the library and receive a dynamically-allocated opt_type value for the operation.

The following API calls can be used to manage the optional operations:

herr_t H5VLregister_opt_operation(H5VL_subclass_t subcls, const char *op_name, int *op_val);
herr_t H5VLfind_opt_operation(H5VL_subclass_t subcls, const char *op_name, int *op_val);
herr_t H5VLunregister_opt_operation(H5VL_subclass_t subcls, const char *op_name)
H5VLregister_opt_operation
herr_t H5VLregister_opt_operation(H5VL_subclass_t subcls, const char *op_name, int *op_val)
H5VLfind_opt_operation
herr_t H5VLfind_opt_operation(H5VL_subclass_t subcls, const char *op_name, int *op_val)
H5VLunregister_opt_operation
herr_t H5VLunregister_opt_operation(H5VL_subclass_t subcls, const char *op_name)
H5VL_subclass_t
H5VL_subclass_t
Definition H5VLpublic.h:183

The register call is used to register an operation for a subclass (file, etc.) and the opt_type parameter that the library assigned to the operation will be returned via the opt_val parameter. This value can then be passed to one of the subclass-specific API calls (listed below). If you need to find an existing optional call's assigned opt_type value by name, you can use the find call.

One recommended way to handle optional calls is to register all the optional calls at startup, saving the values in connector state, then use these cached values in your optional calls. The assigned values should be unregistered using the unregister call when the connector shuts down.

Subclass-specific optional calls:

herr_t H5VLattr_optional_op(const char *app_file, const char *app_func, unsigned app_line,
hid_t attr_id, H5VL_optional_args_t *args, hid_t dxpl_id, hid_t es_id);
herr_t H5VLdataset_optional_op(const char *app_file, const char *app_func, unsigned app_line,
hid_t dset_id, H5VL_optional_args_t *args, hid_t dxpl_id, hid_t es_id);
herr_t H5VLdatatype_optional_op(const char *app_file, const char *app_func, unsigned app_line,
hid_t type_id, H5VL_optional_args_t *args, hid_t dxpl_id, hid_tes_id);
herr_t H5VLfile_optional_op(const char *app_file, const char *app_func, unsigned app_line,
hid_t file_id, H5VL_optional_args_t *args, hid_t dxpl_id, hid_t es_id);
herr_t H5VLgroup_optional_op(const char *app_file, const char *app_func, unsigned app_line,
hid_t group_id, H5VL_optional_args_t *args, hid_t dxpl_id, hid_t es_id);
herr_t H5VLlink_optional_op(const char *app_file, const char *app_func, unsigned app_line,
hid_t loc_id, const char *name, hid_t lapl_id, H5VL_optional_args_t *args,
hid_t dxpl_id, hid_t es_id);
herr_t H5VLobject_optional_op(const char *app_file, const char *app_func, unsigned app_line,
hid_t loc_id, const char *name, hid_t lapl_id,
H5VL_optional_args_t *args, hid_t dxpl_id, hid_t es_id);
herr_t H5VLrequest_optional_op(void *req, hid_t connector_id, H5VL_optional_args_t *args);
H5VLobject_optional_op
#define H5VLobject_optional_op(...)
Definition H5VLconnector.h:1142
H5VLdataset_optional_op
#define H5VLdataset_optional_op(...)
Definition H5VLconnector.h:1137
H5VLdatatype_optional_op
#define H5VLdatatype_optional_op(...)
Definition H5VLconnector.h:1138
H5VLfile_optional_op
#define H5VLfile_optional_op(...)
Definition H5VLconnector.h:1139
H5VLattr_optional_op
#define H5VLattr_optional_op(...)
Definition H5VLconnector.h:1136
H5VLgroup_optional_op
#define H5VLgroup_optional_op(...)
Definition H5VLconnector.h:1140
H5VLlink_optional_op
#define H5VLlink_optional_op(...)
Definition H5VLconnector.h:1141
H5VLrequest_optional_op
herr_t H5VLrequest_optional_op(void *req, hid_t connector_id, H5VL_optional_args_t *args)
H5VL_optional_args_t
Definition H5VLconnector.h:94

## Testing Your Connector

At the time of writing, some of the HDF5 library tests have been abstracted out of the library with their native-file-format-only sections removed and added to a VOL test suite available here: vol-tests

This is an evolving set of tests, so see the documentation in that repository for instructions as to its use. You may want to clone and modify and/or extend these tests for use with your own connector.

In the future, we plan to modify the HDF5 test suite that ships with the library to use a future VOL capabilities flags scheme to selectively run tests that a particular connector supports. As this is a large task, it may be some time before that work is complete.

## Passthrough Connectors

Coming Soon

Note: Passthrough VOL connectors should avoid doing anything with the file in the open and create callbacks except opening it. If connectors need to do anything else they should use the post open callback (H5VL_NATIVE_FILE_POST_OPEN op_type for the file "optional" callback), making sure to perform operations on the file only after passing the post open call down to the terminal connector. The post open callback is made for both file open and file create calls.

## Asynchronous Operations

Coming Soon

# VOL Connector Interface Reference

Each VOL connector should be of type H5VL_class_t:

VOL connector class, H5VLpublic.h typedef struct H5VL_class_t { /* Overall connector fields & callbacks */ unsigned version; H5VL_class_value_t value; const char *name; unsigned conn_version; uint64_t cap_flags; herr_t (*initialize)(hid_t vipl_id); herr_t (*terminate)(void); /* VOL framework */ H5VL_info_class_t info_cls; H5VL_wrap_class_t wrap_cls; /* Data Model */ H5VL_attr_class_t attr_cls; H5VL_dataset_class_t dataset_cls; H5VL_datatype_class_t datatype_cls; H5VL_file_class_t file_cls; H5VL_group_class_t group_cls; H5VL_link_class_t link_cls; H5VL_object_class_t object_cls; /* Infrastructure / Services */ H5VL_introspect_class_t introspect_cls; H5VL_request_class_t request_cls; H5VL_blob_class_t blob_cls; H5VL_token_class_t token_cls; /* Catch-all */ herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req); } H5VL_class_t;

The version field is the version of the H5VL_class_t struct. This is identical to how the version field is used in the H5Z_class2_t struct for filters.

The value field is a unique integer identifier that should be between 512 and 65535 for external, non-library connectors.

The name field is a string that uniquely identifies the VOL connector name.

The conn_version is the connector version. This is currently not used by the library.

The cap_flags holds bitwise capability/feature flags that determine which operations and capabilities are supported by a the VOL connector. These fields were enumerated in the previous section.

The initialize field is a function pointer to a routine that a connector implements to set up or initialize access to the connector. Implementing this function by the connector is not required since some connectors do not require any set up to start accessing the connector. In that case, the value of the function pointer should be set to NULL. Connector specific variables that are required to be passed from users should be passed through the VOL initialize property list. Generic properties can be added to this property class for user-defined connectors that cannot modify the HDF5 library to add internal properties. For more information consult the property list reference manual pages.

The terminate field is a function pointer to a routine that a connector implements to terminate or finalize access to the connector. Implementing this function by the connector is not required since some connectors do not require any termination phase to the connector. In that case, the value of the function pointer should be set to NULL.

The rest of the fields in the H5VL_class_t struct are "subclasses" that define all the VOL function callbacks that are mapped to from the HDF5 API layer. Those subclasses are categorized into three categories, VOL Framework, Data Model, and Infrastructure / Services.

VOL Framework classes provide functionality for working with the VOL connectors themselves (e.g., working with connector strings) and with wrapping and unwrapping objects for passthrough connectors.

Data Model classes are those that provide functionality for accessing an HDF5 container and objects in that container as defined by the HDF5 data model.

Infrastructure / Service classes are those that provide services for users that are not related to the data model specifically. Asynchronous operations, for example, are a service that most connectors can implement, so we add a class for it in the VOL structure.

If a service becomes generic enough and common among many connectors, a class for it should be added to the VOL structure. However, many connectors can/will provide services that are not shared by other connectors. A good way to support these services is through an optional callback in the VOL structure which can be a hook from the API to the connector that provides those services, passing any necessary arguments needed without the HDF5 library having to worry about supporting that service. A similar API operation to allow users to use that service will be added. This API call would be similar to an "ioctl" call where any kind of operation can be supported and passed down to the connector that has enough knowledge from the user to interpret the type of the operation. All classes and their defined callbacks will be detailed in the following sub-sections.

To handle that large set of API routines, each class in the Data Model category has three generic callbacks, get, specific, and optional to handle the three set of API operations outline above respectively. To handle the varying parameters that can be passed to the callback, each callback will take a struct parameter that includes an enum get/specific or integer optional field indicating the operation and a union of the possible parameters get/specific or void pointer to the parameters optional.

The optional args struct used for all optional operations:

// Struct for all 'optional' callbacks
typedef struct H5VL_optional_args_t {
int op_type; // Operation to perform
void *args; // Pointer to operation's argument struct
} H5VL_optional_args_t;
H5VL_optional_args_t::op_type
int op_type
Definition H5VLconnector.h:95
H5VL_optional_args_t::args
void * args
Definition H5VLconnector.h:96

The opt_type member is the value assigned by the library when the optional operation was registered (or defined in the case of the native VOL connector) and the args member is a pointer to the optional operation's parameters (usually passed in as a struct).

Note that this differs from the HDF5 1.12.x scheme, which used va_lists.

The optional callback is a free for all callback where anything from the API layer is passed in directly. This callback is used to support connector specific operations in the API that other connectors should or would not know about. More information about types and the arguments for each type will be detailed in the corresponding class arguments.

## Mapping the API to the Callbacks

The callback interface defined for the VOL has to be general enough to handle all the HDF5 API operations that would access the file. Furthermore, it has to capture future additions to the HDF5 library with little to no changes to the callback interface. Changing the interface often whenever new features are added would be discouraging to connector developers since that would mean reworking their VOL connector structure. To remedy this issue, every callback will contain two parameters:

- A data transfer property list (DXPL) which allows that API to put some properties on for the connectors to retrieve if they have to for particular operations, without having to add arguments to the VOL callback function.
- A pointer to a request (void **req) to handle asynchronous operations if the HDF5 library adds support for them in future releases. hat pointer is set by the VOL connector to a request object it creates to manage progress on that asynchronous operation. If the req is NULL, that means that the API operation is blocking and so the connector would not execute the operation asynchronously. If the connector does not support asynchronous operations, it needs not to worry about this field and leaves it unset.

In order to keep the number of the VOL object classes and callbacks concise and readable, it was decided not to have a one-to-one mapping between API operation and callbacks. The parameter names and types will be detailed when describing each callback in their respective sections.

The HDF5 library provides several routines to access an object in the container. For example, to open an attribute on a group object, the user could use H5Aopen and pass the group identifier directly where the attribute needs to be opened. Alternatively, the user could use H5Aopen_by_name or H5Aopen_by_idx to open the attribute, which provides a more flexible way of locating the attribute, whether by a starting object location and a path or an index type and traversal order. All those types of accesses usually map to one VOL callback with a parameter that indicates the access type. In the example of opening an attribute, the three API open routine will map to the same VOL open callback but with a different location parameter. The same applies to all types of routines that have multiple types of accesses. The location parameter is a structure defined in:

Structure to hold parameters for object locations, H5VLconnector.h

//
// Structure to hold parameters for object locations.
// either: BY_SELF, BY_NAME, BY_IDX, BY_TOKEN
typedef struct H5VL_loc_params_t {
H5I_type_t obj_type; // The object type of the location object
H5VL_loc_type_t type; // The location type
union { // parameters of the location
H5VL_loc_by_token_t loc_by_token;
H5VL_loc_by_name_t loc_by_name;
H5VL_loc_by_idx_t loc_by_idx;
}loc_data;
} H5VL_loc_params_t
//
// Types for different ways that objects are located in an
// HDF5 container.
typedef enum H5VL_loc_type_t {
// starting location is the target object
H5VL_OBJECT_BY_SELF,
// location defined by object and path in H5VL_loc_by_name_t
H5VL_OBJECT_BY_NAME,
// location defined by object, path, and index in H5VL_loc_by_idx_t
H5VL_OBJECT_BY_IDX,
// location defined by token (e.g. physical address) in H5VL_loc_by_token_t
H5VL_OBJECT_BY_TOKEN,
} H5VL_loc_type_t;
typedef struct H5VL_loc_by_name {
const char *name; // The path relative to the starting location
hid_t lapl_id; // The link access property list
}H5VL_loc_by_name_t;
typedef struct H5VL_loc_by_idx {
const char *name; // The path relative to the starting location
H5_index_t idx_type; // Type of index
H5_iter_order_t order; // Index traversal order
hsize_t n; // Position in index
hid_t lapl_id; // The link access property list
}H5VL_loc_by_idx_t;
typedef struct H5VL_loc_by_token {
void *token; // arbitrary token (physical address of location in native VOL)
}H5VL_loc_by_token_t;
H5I_type_t
H5I_type_t
Definition H5Ipublic.h:34
H5VL_loc_type_t
H5VL_loc_type_t
Definition H5VLconnector.h:50
H5VL_OBJECT_BY_NAME
@ H5VL_OBJECT_BY_NAME
Definition H5VLconnector.h:52
H5VL_OBJECT_BY_TOKEN
@ H5VL_OBJECT_BY_TOKEN
Definition H5VLconnector.h:54
H5VL_OBJECT_BY_IDX
@ H5VL_OBJECT_BY_IDX
Definition H5VLconnector.h:53
H5VL_OBJECT_BY_SELF
@ H5VL_OBJECT_BY_SELF
Definition H5VLconnector.h:51
H5_iter_order_t
H5_iter_order_t
Definition H5public.h:379
hsize_t
uint64_t hsize_t
Definition H5public.h:304
H5_index_t
H5_index_t
Definition H5public.h:402
H5VL_loc_by_idx_t
Definition H5VLconnector.h:62
H5VL_loc_by_name_t
Definition H5VLconnector.h:57
H5VL_loc_by_token_t
Definition H5VLconnector.h:70
H5VL_loc_params_t
Definition H5VLconnector.h:83
H5VL_loc_params_t::loc_by_idx
H5VL_loc_by_idx_t loc_by_idx
Definition H5VLconnector.h:89
H5VL_loc_params_t::loc_data
union H5VL_loc_params_t::@253232363157051151176002046324213315140375116335 loc_data
H5VL_loc_params_t::obj_type
H5I_type_t obj_type
Definition H5VLconnector.h:84
H5VL_loc_params_t::type
H5VL_loc_type_t type
Definition H5VLconnector.h:85
H5VL_loc_params_t::loc_by_token
H5VL_loc_by_token_t loc_by_token
Definition H5VLconnector.h:87
H5VL_loc_params_t::loc_by_name
H5VL_loc_by_name_t loc_by_name
Definition H5VLconnector.h:88

## Connector Information Callbacks

This section's callbacks involve the connector-specific information that will be associated with the VOL in the fapl via H5Pset_fapl_<name> et al. This data is copied into the fapl so the library needs these functions to manage this in a way that prevents resource leaks.

The to_str and from_str callbacks are used to convert the connector-specific data to and from a configuration string. There is no official way to construct VOL configuration strings, so the format used (JSON, XML, getopt-style processing, etc.) is up to the connector author. These connector configuration strings can be used to set up a VOL connector via mechanisms like command-line parameters and environment variables.

Info class for connector information routines, H5VLconnector.h

// VOL connector info fields & callbacks
typedef struct H5VL_info_class_t {
size_t size; // Size of the VOL info
void *(*copy)(const void *info); // Callback to create a copy of the VOL info
herr_t (*cmp)(int *cmp_value, const void *info1, const void *info2); // Callback to compare VOL info
herr_t (*free)(void *info); // Callback to release a VOL info
herr_t (*to_str)(const void *info, char **str); // Callback to serialize connector's info into a string
herr_t (*from_str)(const char *str, void **info); // Callback to deserialize a string into connector's info
} H5VL_info_class_t;
H5VL_info_class_t
Definition H5VLconnector.h:845
H5VL_info_class_t::from_str
herr_t(* from_str)(const char *str, void **info)
Definition H5VLconnector.h:851
H5VL_info_class_t::size
size_t size
Definition H5VLconnector.h:846
H5VL_info_class_t::to_str
herr_t(* to_str)(const void *info, char **str)
Definition H5VLconnector.h:850
H5VL_info_class_t::free
herr_t(* free)(void *info)
Definition H5VLconnector.h:849
H5VL_info_class_t::cmp
herr_t(* cmp)(int *cmp_value, const void *info1, const void *info2)
Definition H5VLconnector.h:848

### info: size

The size field indicates the size required to store any special information that the connector needs.

If the connector requires no special information, set this field to zero.

Signature:
size_t size;

### info: copy

The copy callback is invoked when the connector is selected for use with H5Pset_fapl_<name>, the connector-specific set call, etc. Where possible, the information should be deep copied in such a way that the original data can be freed.

Signature:
void * (*copy)(const void *info);
Arguments:
info (IN): The connector-specific info to copy.

### info: cmp

The cmp callback is used to determine if two connector-specific data structs are identical and helps the library manage connector resources.

Signature:
herr_t (*cmp)(int *cmp_value, const void *info1, const void *info2);
Arguments:
cmp_value (OUT): A strcmp-like compare value. info1 (IN): The 1st connector-specific info to copy. info2 (IN): The 2nd connector-specific info to copy.

### info: free

The free callback is used to clean up the connector-specific information that was copied when set in the fapl via the copy callback.

Signature:
herr_t (*free)(void *info);
Arguments:
info (IN): The connector-specific info to free.

### info: to_str

The to_str callback converts a connector-specific information structure to a connector-specific configuration string. It is the opposite of the from_str callback.

Signature:
herr_t (*to_str)(const void *info, char **str);
Arguments:
info (IN): The connector-specific info to convert to a configuration string. str (OUT): The constructed configuration string.

### info: from_str

The from_str callback converts a connector-specific configuration string to a connector-specific information structure. It is the opposite of the to_str callback.

Signature:
herr_t (*from_str)(const char *str, void **info);
Arguments:
str (IN): The connector-specific configuration string. info (OUT): The connector-specific info generated from the configuration string.

## Object Wrap Callbacks

The object wrap callbacks are used by passthrough connectors to wrap/unwrap objects and contexts when passing them up and down the VOL chain. Each passthrough VOL must define an object wrapping structure and a wrap context. The object wrapping structure should contain the information necessary to recursively unwrap the object - at a minimum, this is the object provided from and the ID of the next connector in the stack. The wrap context should contain the information necessary to recursively wrap the object - at a minimum, this is the ID and the wrap context of the next VOL connector in the stack.

Each callback should use H5VL<callback> to recursively invoke the same callback in all lower passthrough VOl connectors.

Wrap class for object wrapping routines, H5VLconnector.h

typedef struct H5VL_wrap_class_t {
void *(*get_object)(const void *obj); // Callback to retrieve underlying object
herr_t (*get_wrap_ctx)(const void *obj, void **wrap_ctx); // Callback to retrieve the object wrapping context for the connector
void *(*wrap_object)(void *obj, H5I_type_t obj_type, void *wrap_ctx); // Callback to wrap a library object
void *(*unwrap_object)(void *obj); // Callback to unwrap a library object
herr_t (*free_wrap_ctx)(void *wrap_ctx); // Callback to release the object wrapping context for the connector
} H5VL_wrap_class_t;
H5VL_wrap_class_t
Definition H5VLconnector.h:858
H5VL_wrap_class_t::free_wrap_ctx
herr_t(* free_wrap_ctx)(void *wrap_ctx)
Definition H5VLconnector.h:866
H5VL_wrap_class_t::get_wrap_ctx
herr_t(* get_wrap_ctx)(const void *obj, void **wrap_ctx)
Definition H5VLconnector.h:860

### wrap: get_object

Retrieves the underlying object from a wrapped object. Should return a pointer to the underlying object belonging to the terminal VOL connector.

This will generally be done by unwrapping this VOL's object wrapping structure, before recursively calling H5VLget_object to invoke the get_object callback for all lower VOL connectors which define it. H5VLget_object requires the object returned by the next VOL and the next VOL's ID. Both of these fields should be stored by the VOL somehow, generally on the wrapped object structure.

This callback should not cleanup or modify the provided object wrapping structure.

Signature:
void * (*get_object)(const void *obj);
Arguments:
obj (IN): The object to be unwrapped.

### wrap: get_wrap_ctx

Get a VOL connector's object wrapping context.

The context should be returned in dynamically allocated memory under *wrap_ctx. Any resources this callback allocates should be freed within free_wrap_ctx.

Signature:
herr_t (*get_wrap_ctx)(const void *obj, void **wrap_ctx);
Arguments:
obj (IN): Object wrapped by this VOL connector, for which we need a context. wrap_ctx (OUT): Context.

### wrap: wrap_object

Asks a connector to wrap an underlying object. This callback should use H5VLwrap_object to recursively have the object wrapped by all lower VOL connectors before performing its own wrapping.

The wrapped object should provide the information necessary for unwrap_object to recursively unwrap it - at a minimum, the object provided from and the ID of the next VOL connector.

Signature:
void * (*wrap_object)(void *obj, H5I_type_t obj_type, void *wrap_ctx);
Arguments:
obj (IN): The object to be wrapped. obj_type (IN): Object type (see H5Ipublic.h). wrap_ctx (IN): Context.

### wrap: unwrap_object

Unwrap an object from connector. Any resources allocated during wrap_object should be released and cleaned up here.

This callback should clean up this VOL's object wrapping structure before recursively invoking H5VLunwrap_object.

Signature:
void * (*unwrap_object)(void *obj);
Arguments:
obj (IN): Object to be unwrapped.

### wrap: free_wrap_ctx

Release a VOL connector's object wrapping context. This should free any resources allocated during get_wrap_ctx, and recursively invoke H5VLfree_wrap_ctx to execute the free callback for the lower VOL connectors in the stack.

Signature:
herr_t (*free_wrap_ctx)(void *wrap_ctx);
Arguments:
wrap_ctx (IN): Context to be freed.

## The Attribute Function Callbacks

The attribute API routines (Attributes (H5A)) allow HDF5 users to create and manage HDF5 attributes. All the Attributes (H5A) API routines that modify the HDF5 container map to one of the attribute callback routines in this class that the connector needs to implement.

Structure for attribute callback routines, H5VLconnector.h

typedef struct H5VL_attr_class_t {
void *(*create)(void *obj, const H5VL_loc_params_t *loc_params, const char *attr_name, hid_t type_id,
hid_t space_id, hid_t acpl_id, hid_t aapl_id, hid_t dxpl_id, void **req);
void *(*open)(void *obj, const H5VL_loc_params_t *loc_params, const char *attr_name, hid_t aapl_id,
hid_t dxpl_id, void **req);
herr_t (*read)(void *attr, hid_t mem_type_id, void *buf, hid_t dxpl_id, void **req);
herr_t (*write)(void *attr, hid_t mem_type_id, const void *buf, hid_t dxpl_id, void **req);
herr_t (*get)(void *obj, H5VL_attr_get_args_t *args, hid_t dxpl_id, void **req);
herr_t (*specific)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_attr_specific_args_t *args,
hid_t dxpl_id, void **req);
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
herr_t (*close)(void *attr, hid_t dxpl_id, void **req);
} H5VL_attr_class_t;
H5VL_attr_class_t
Definition H5VLconnector.h:871
H5VL_attr_class_t::write
herr_t(* write)(void *attr, hid_t mem_type_id, const void *buf, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:877
H5VL_attr_class_t::optional
herr_t(* optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:881
H5VL_attr_class_t::read
herr_t(* read)(void *attr, hid_t mem_type_id, void *buf, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:876
H5VL_attr_class_t::specific
herr_t(* specific)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_attr_specific_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:879
H5VL_attr_class_t::close
herr_t(* close)(void *attr, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:882
H5VL_attr_class_t::get
herr_t(* get)(void *obj, H5VL_attr_get_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:878
H5VL_attr_get_args_t
Definition H5VLconnector.h:125
H5VL_attr_specific_args_t
Definition H5VLconnector.h:184

### attr: create

The create callback in the attribute class creates an attribute object in the container of the location object and returns a pointer to the attribute structure containing information to access the attribute in future calls.

Signature:
void *(*create)(void *obj, H5VL_loc_params_t *loc_params, const char *attr_name, hid_t type_id, hid_t space_id, hid_t acpl_id, hid_t aapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the attribute needs to be created or where the look-up of the target object needs to start. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks". attr_name (IN): The name of the attribute to be created. type_id (IN): The datatype of the attribute. space_id (IN): The dataspace of the attribute. acpl_id (IN): The attribute creation property list. aapl_id (IN): The attribute access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### attr: open

The open callback in the attribute class opens an attribute object in the container of the location object and returns a pointer to the attribute structure containing information to access the attribute in future calls.

Signature:
void *(*open)(void *obj, H5VL_loc_params_t *loc_params, const char *attr_name, hid_t aapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the attribute needs to be opened or where the look-up of the target object needs to start. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks". attr_name (IN): The name of the attribute to be opened. aapl_id (IN): The attribute access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### attr: read

The read callback in the attribute class reads data from the attribute object and returns an herr_t indicating success or failure.

Signature:
herr_t (*read)(void *attr, hid_t mem_type_id, void *buf, hid_t dxpl_id, void **req);
Arguments:
attr (IN): Pointer to the attribute object. mem_type_id (IN): The memory datatype of the attribute. buf (OUT): Data buffer to be read into. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### attr: write

The write callback in the attribute class writes data to the attribute object and returns an herr_t indicating success or failure.

Signature:
herr_t (*write)(void *attr, hid_t mem_type_id, const void *buf, hid_t dxpl_id, void **req);
Arguments:
attr (IN): Pointer to the attribute object. mem_type_id (IN): The memory datatype of the attribute. buf (IN): Data buffer to be written. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### attr: get

The get callback in the attribute class retrieves information about the attribute as specified in the get_type parameter. It returns an herr_t indicating success or failure

Signature:
herr_t (*get)(void *obj, H5VL_attr_get_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): An attribute or location object where information needs to be retrieved from. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for attribute 'get' operations */
typedef enum H5VL_attr_get_t {
H5VL_ATTR_GET_ACPL, /* creation property list */
H5VL_ATTR_GET_INFO, /* info */
H5VL_ATTR_GET_NAME, /* access property list */
H5VL_ATTR_GET_SPACE, /* dataspace */
H5VL_ATTR_GET_STORAGE_SIZE, /* storage size */
H5VL_ATTR_GET_TYPE /* datatype */
} H5VL_attr_get_t;
/* Parameters for attribute 'get_name' operation */
typedef struct H5VL_attr_get_name_args_t {
H5VL_loc_params_t loc_params; /* Location parameters for object access */
size_t buf_size; /* Size of attribute name buffer */
char *buf; /* Buffer for attribute name (OUT) */
size_t *attr_name_len; /* Actual length of attribute name (OUT) */
} H5VL_attr_get_name_args_t;
/* Parameters for attribute 'get_info' operation */
typedef struct H5VL_attr_get_info_args_t {
H5VL_loc_params_t loc_params; /* Location parameters for object access */
const char *attr_name; /* Attribute name (for get_info_by_name) */
H5A_info_t *ainfo; /* Attribute info (OUT) */
} H5VL_attr_get_info_args_t;
/* Parameters for attribute 'get' operations */
typedef struct H5VL_attr_get_args_t {
H5VL_attr_get_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_ATTR_GET_ACPL */
struct {
hid_t acpl_id; /* Attribute creation property list ID (OUT) */
} get_acpl;
/* H5VL_ATTR_GET_INFO */
H5VL_attr_get_info_args_t get_info; /* Attribute info */
/* H5VL_ATTR_GET_NAME */
H5VL_attr_get_name_args_t get_name; /* Attribute name */
/* H5VL_ATTR_GET_SPACE */
struct {
hid_t space_id; /* Dataspace ID (OUT) */
} get_space;
/* H5VL_ATTR_GET_STORAGE_SIZE */
struct {
hsize_t *data_size; /* Size of attribute in file (OUT) */
} get_storage_size;
/* H5VL_ATTR_GET_TYPE */
struct {
hid_t type_id; /* Datatype ID (OUT) */
} get_type;
} args;
} H5VL_attr_get_args_t;
H5VL_attr_get_t
H5VL_attr_get_t
Definition H5VLconnector.h:100
H5VL_ATTR_GET_TYPE
@ H5VL_ATTR_GET_TYPE
Definition H5VLconnector.h:106
H5VL_ATTR_GET_INFO
@ H5VL_ATTR_GET_INFO
Definition H5VLconnector.h:102
H5VL_ATTR_GET_SPACE
@ H5VL_ATTR_GET_SPACE
Definition H5VLconnector.h:104
H5VL_ATTR_GET_ACPL
@ H5VL_ATTR_GET_ACPL
Definition H5VLconnector.h:101
H5VL_ATTR_GET_NAME
@ H5VL_ATTR_GET_NAME
Definition H5VLconnector.h:103
H5VL_ATTR_GET_STORAGE_SIZE
@ H5VL_ATTR_GET_STORAGE_SIZE
Definition H5VLconnector.h:105
H5VL_attr_get_args_t::space_id
hid_t space_id
Definition H5VLconnector.h:143
H5VL_attr_get_args_t::op_type
H5VL_attr_get_t op_type
Definition H5VLconnector.h:126
H5VL_attr_get_args_t::args
union H5VL_attr_get_args_t::@100374311024317025337351276333353044314342114073 args
H5VL_attr_get_args_t::get_info
H5VL_attr_get_info_args_t get_info
Definition H5VLconnector.h:136
H5VL_attr_get_args_t::get_acpl
struct H5VL_attr_get_args_t::@100374311024317025337351276333353044314342114073::@067117016065005351362166264200113355036273274360 get_acpl
H5VL_attr_get_args_t::data_size
hsize_t * data_size
Definition H5VLconnector.h:148
H5VL_attr_get_args_t::get_space
struct H5VL_attr_get_args_t::@100374311024317025337351276333353044314342114073::@357061065323037200370270036054224265260002204330 get_space
H5VL_attr_get_args_t::get_storage_size
struct H5VL_attr_get_args_t::@100374311024317025337351276333353044314342114073::@205161204202333344262357165125212102227046163263 get_storage_size
H5VL_attr_get_args_t::type_id
hid_t type_id
Definition H5VLconnector.h:153
H5VL_attr_get_args_t::get_type
struct H5VL_attr_get_args_t::@100374311024317025337351276333353044314342114073::@320252006150362271205374033246275343017306055340 get_type
H5VL_attr_get_args_t::acpl_id
hid_t acpl_id
Definition H5VLconnector.h:132
H5VL_attr_get_args_t::get_name
H5VL_attr_get_name_args_t get_name
Definition H5VLconnector.h:139
H5VL_attr_get_info_args_t
Definition H5VLconnector.h:118
H5VL_attr_get_info_args_t::ainfo
H5A_info_t * ainfo
Definition H5VLconnector.h:121
H5VL_attr_get_info_args_t::loc_params
H5VL_loc_params_t loc_params
Definition H5VLconnector.h:119
H5VL_attr_get_info_args_t::attr_name
const char * attr_name
Definition H5VLconnector.h:120
H5VL_attr_get_name_args_t
Definition H5VLconnector.h:110
H5VL_attr_get_name_args_t::buf
char * buf
Definition H5VLconnector.h:113
H5VL_attr_get_name_args_t::loc_params
H5VL_loc_params_t loc_params
Definition H5VLconnector.h:111
H5VL_attr_get_name_args_t::buf_size
size_t buf_size
Definition H5VLconnector.h:112
H5VL_attr_get_name_args_t::attr_name_len
size_t * attr_name_len
Definition H5VLconnector.h:114

### attr: specific

The specific callback in the attribute class implements specific operations on HDF5 attributes as specified in the specific_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*specific)(void *obj, H5VL_loc_params_t *loc_params, H5VL_attr_specific_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The location object where the operation needs to happen. loc_params (IN): A pointer to the location parameters as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for attribute 'specific' operation */
typedef enum H5VL_attr_specific_t {
H5VL_ATTR_DELETE, /* H5Adelete(_by_name) */
H5VL_ATTR_DELETE_BY_IDX, /* H5Adelete_by_idx */
H5VL_ATTR_EXISTS, /* H5Aexists(_by_name) */
H5VL_ATTR_ITER, /* H5Aiterate(_by_name) */
H5VL_ATTR_RENAME /* H5Arename(_by_name) */
} H5VL_attr_specific_t;
/* Parameters for attribute 'iterate' operation */
typedef struct H5VL_attr_iterate_args_t {
H5_index_t idx_type; /* Type of index to iterate over */
H5_iter_order_t order; /* Order of index iteration */
hsize_t *idx; /* Start/stop iteration index (IN/OUT) */
H5A_operator2_t op; /* Iteration callback function */
void *op_data; /* Iteration callback context */
} H5VL_attr_iterate_args_t;
/* Parameters for attribute 'delete_by_idx' operation */
typedef struct H5VL_attr_delete_by_idx_args_t {
H5_index_t idx_type; /* Type of index to iterate over */
H5_iter_order_t order; /* Order of index iteration */
hsize_t n; /* Iteration index */
} H5VL_attr_delete_by_idx_args_t;
/* Parameters for attribute 'specific' operations */
typedef struct H5VL_attr_specific_args_t {
H5VL_attr_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_ATTR_DELETE */
struct {
const char *name; /* Name of attribute to delete */
} del;
/* H5VL_ATTR_DELETE_BY_IDX */
H5VL_attr_delete_by_idx_args_t delete_by_idx;
/* H5VL_ATTR_EXISTS */
struct {
const char *name; /* Name of attribute to check */
bool *exists; /* Whether attribute exists (OUT) */
} exists;
/* H5VL_ATTR_ITER */
H5VL_attr_iterate_args_t iterate;
/* H5VL_ATTR_RENAME */
struct {
const char *old_name; /* Name of attribute to rename */
const char *new_name; /* New attribute name */
} rename;
} args;
} H5VL_attr_specific_args_t;
H5A_operator2_t
herr_t(* H5A_operator2_t)(hid_t location_id, const char *attr_name, const H5A_info_t *ainfo, void *op_data)
Definition H5Apublic.h:60
H5VL_attr_specific_t
H5VL_attr_specific_t
Definition H5VLconnector.h:159
H5VL_ATTR_EXISTS
@ H5VL_ATTR_EXISTS
Definition H5VLconnector.h:162
H5VL_ATTR_RENAME
@ H5VL_ATTR_RENAME
Definition H5VLconnector.h:164
H5VL_ATTR_ITER
@ H5VL_ATTR_ITER
Definition H5VLconnector.h:163
H5VL_ATTR_DELETE_BY_IDX
@ H5VL_ATTR_DELETE_BY_IDX
Definition H5VLconnector.h:161
H5VL_ATTR_DELETE
@ H5VL_ATTR_DELETE
Definition H5VLconnector.h:160
H5VL_attr_delete_by_idx_args_t
Definition H5VLconnector.h:177
H5VL_attr_delete_by_idx_args_t::idx_type
H5_index_t idx_type
Definition H5VLconnector.h:178
H5VL_attr_delete_by_idx_args_t::n
hsize_t n
Definition H5VLconnector.h:180
H5VL_attr_delete_by_idx_args_t::order
H5_iter_order_t order
Definition H5VLconnector.h:179
H5VL_attr_iterate_args_t
Definition H5VLconnector.h:168
H5VL_attr_iterate_args_t::idx_type
H5_index_t idx_type
Definition H5VLconnector.h:169
H5VL_attr_iterate_args_t::idx
hsize_t * idx
Definition H5VLconnector.h:171
H5VL_attr_iterate_args_t::op_data
void * op_data
Definition H5VLconnector.h:173
H5VL_attr_iterate_args_t::order
H5_iter_order_t order
Definition H5VLconnector.h:170
H5VL_attr_iterate_args_t::op
H5A_operator2_t op
Definition H5VLconnector.h:172
H5VL_attr_specific_args_t::old_name
const char * old_name
Definition H5VLconnector.h:208
H5VL_attr_specific_args_t::rename
struct H5VL_attr_specific_args_t::@070074341170002175041205164317267231205371227331::@242112206330127346145113136041276270171361145231 rename
H5VL_attr_specific_args_t::del
struct H5VL_attr_specific_args_t::@070074341170002175041205164317267231205371227331::@300131260047166104256273140142342331177171136246 del
H5VL_attr_specific_args_t::delete_by_idx
H5VL_attr_delete_by_idx_args_t delete_by_idx
Definition H5VLconnector.h:195
H5VL_attr_specific_args_t::name
const char * name
Definition H5VLconnector.h:191
H5VL_attr_specific_args_t::exists
bool * exists
Definition H5VLconnector.h:200
H5VL_attr_specific_args_t::iterate
H5VL_attr_iterate_args_t iterate
Definition H5VLconnector.h:204
H5VL_attr_specific_args_t::new_name
const char * new_name
Definition H5VLconnector.h:209
H5VL_attr_specific_args_t::op_type
H5VL_attr_specific_t op_type
Definition H5VLconnector.h:185
H5VL_attr_specific_args_t::args
union H5VL_attr_specific_args_t::@070074341170002175041205164317267231205371227331 args

### attr: optional

The optional callback in the attribute class implements connector specific operations on an HDF5 attribute. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where the operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

### attr: close

The close callback in the attribute class terminates access to the attribute object and free all resources it was consuming, and returns an herr_t indicating success or failure.

Signature:
herr_t (*close)(void *attr, hid_t dxpl_id, void **req);
Arguments:
attr (IN): Pointer to the attribute object. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

## Dataset Callbacks

The dataset API routines (Datasets (H5D)) allow HDF5 users to create and manage HDF5 datasets. All the Datasets (H5D) API routines that modify the HDF5 container map to one of the dataset callback routines in this class that the connector needs to implement.

Structure for dataset callback routines, H5VLconnector.h

typedef struct H5VL_dataset_class_t {
void *(*create)(void *obj, const H5VL_loc_params_t *loc_params, const char *name, hid_t lcpl_id,
hid_t type_id, hid_t space_id, hid_t dcpl_id, hid_t dapl_id, hid_t dxpl_id, void **req);
void *(*open)(void *obj, const H5VL_loc_params_t *loc_params, const char *name, hid_t dapl_id,
hid_t dxpl_id, void **req);
herr_t (*read)(size_t count, void *dset[], hid_t mem_type_id[], hid_t mem_space_id[],
hid_t file_space_id[], hid_t dxpl_id, void *buf[], void **req);
herr_t (*write)(size_t count, void *dset[], hid_t mem_type_id[], hid_t mem_space_id[],
hid_t file_space_id[], hid_t dxpl_id, const void *buf[], void **req);
herr_t (*get)(void *obj, H5VL_dataset_get_args_t *args, hid_t dxpl_id, void **req);
herr_t (*specific)(void *obj, H5VL_dataset_specific_args_t *args, hid_t dxpl_id, void **req);
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
herr_t (*close)(void *dset, hid_t dxpl_id, void **req);
} H5VL_dataset_class_t;
H5VL_dataset_class_t
Definition H5VLconnector.h:886
H5VL_dataset_class_t::optional
herr_t(* optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:897
H5VL_dataset_class_t::close
herr_t(* close)(void *dset, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:898
H5VL_dataset_class_t::read
herr_t(* read)(size_t count, void *dset[], hid_t mem_type_id[], hid_t mem_space_id[], hid_t file_space_id[], hid_t dxpl_id, void *buf[], void **req)
Definition H5VLconnector.h:891
H5VL_dataset_class_t::write
herr_t(* write)(size_t count, void *dset[], hid_t mem_type_id[], hid_t mem_space_id[], hid_t file_space_id[], hid_t dxpl_id, const void *buf[], void **req)
Definition H5VLconnector.h:893
H5VL_dataset_class_t::get
herr_t(* get)(void *obj, H5VL_dataset_get_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:895
H5VL_dataset_class_t::specific
herr_t(* specific)(void *obj, H5VL_dataset_specific_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:896
H5VL_dataset_get_args_t
Definition H5VLconnector.h:228
H5VL_dataset_specific_args_t
Definition H5VLconnector.h:273

### dataset: create

The create callback in the dataset class creates a dataset object in the container of the location object and returns a pointer to the dataset structure containing information to access the dataset in future calls.

Signature:
void *(*create)(void *obj, H5VL_loc_params_t *loc_params, const char *name, hid_t lcpl_id,hid_t type_id, hid_t space_id, hid_t dcpl_id, hid_t dapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the dataset needs to be created or where the look-up of the target object needs to start. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_SELF in this callback. name (IN): The name of the dataset to be created. lcpl_id (IN): The link creation property list. type_id (IN): The datatype of the dataset. space_id (IN): The dataspace of the dataset. dcpl_id (IN): The dataset creation property list. dapl_id (IN): The dataset access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### dataset: open

The open callback in the dataset class opens a dataset object in the container of the location object and returns a pointer to the dataset structure containing information to access the dataset in future calls.

Signature:
void *(*open)(void *obj, H5VL_loc_params_t *loc_params, const char *name, hid_t dapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the dataset needs to be opened or where the look-up of the target object needs to start. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_SELF in this callback. name (IN): The name of the dataset to be opened. dapl_id (IN): The dataset access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### dataset: read

The read callback in the dataset class reads data from the dataset object and returns an herr_t indicating success or failure.

Signature:
herr_t (*read)(void *dset, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t dxpl_id, void *buf, void **req);
Arguments:
dset (IN): Pointer to the dataset object. mem_type_id (IN): The memory datatype of the data. mem_space_id (IN): The memory dataspace selection. file_space_id (IN): The file dataspace selection. dxpl_id (IN): The data transfer property list. buf (OUT): Data buffer to be read into. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### dataset: write

The write callback in the dataset class writes data to the dataset object and returns an herr_t indicating success or failure.

Signature:
herr_t (*write)(void *dset, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t dxpl_id, const void *buf, void **req);
Arguments:
dset (IN): Pointer to the dataset object. mem_type_id (IN): The memory datatype of the data. mem_space_id (IN): The memory dataspace selection. file_space_id (IN): The file dataspace selection. dxpl_id (IN): The data transfer property list. buf (IN): Data buffer to be written from. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### dataset: get

The get callback in the dataset class retrieves information about the dataset as specified in the get_type parameter.It returns an herr_t indicating success or failure.

Signature:
herr_t (*get)(void *dset, H5VL_dataset_get_args_t *args, hid_t dxpl_id, void **req);
Arguments:
dset (IN): The dataset object where information needs to be retrieved from. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for dataset 'get' operation */
typedef enum H5VL_dataset_get_t {
H5VL_DATASET_GET_DAPL, /* access property list */
H5VL_DATASET_GET_DCPL, /* creation property list */
H5VL_DATASET_GET_SPACE, /* dataspace */
H5VL_DATASET_GET_SPACE_STATUS, /* space status */
H5VL_DATASET_GET_STORAGE_SIZE, /* storage size */
H5VL_DATASET_GET_TYPE /* datatype */
} H5VL_dataset_get_t;
/* Parameters for dataset 'get' operations */
typedef struct H5VL_dataset_get_args_t {
H5VL_dataset_get_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_DATASET_GET_DAPL */
struct {
hid_t dapl_id; /* Dataset access property list ID (OUT) */
} get_dapl;
/* H5VL_DATASET_GET_DCPL */
struct {
hid_t dcpl_id; /* Dataset creation property list ID (OUT) */
} get_dcpl;
/* H5VL_DATASET_GET_SPACE */
struct {
hid_t space_id; /* Dataspace ID (OUT) */
} get_space;
/* H5VL_DATASET_GET_SPACE_STATUS */
struct {
H5D_space_status_t *status; /* Storage space allocation status (OUT) */
} get_space_status;
/* H5VL_DATASET_GET_STORAGE_SIZE */
struct {
hsize_t *storage_size; /* Size of dataset's storage (OUT) */
} get_storage_size;
/* H5VL_DATASET_GET_TYPE */
struct {
hid_t type_id; /* Datatype ID (OUT) */
} get_type;
} args;
} H5VL_dataset_get_args_t;
H5D_space_status_t
H5D_space_status_t
Definition H5Dpublic.h:85
H5VL_dataset_get_t
H5VL_dataset_get_t
Definition H5VLconnector.h:218
H5VL_DATASET_GET_DAPL
@ H5VL_DATASET_GET_DAPL
Definition H5VLconnector.h:219
H5VL_DATASET_GET_SPACE
@ H5VL_DATASET_GET_SPACE
Definition H5VLconnector.h:221
H5VL_DATASET_GET_DCPL
@ H5VL_DATASET_GET_DCPL
Definition H5VLconnector.h:220
H5VL_DATASET_GET_STORAGE_SIZE
@ H5VL_DATASET_GET_STORAGE_SIZE
Definition H5VLconnector.h:223
H5VL_DATASET_GET_SPACE_STATUS
@ H5VL_DATASET_GET_SPACE_STATUS
Definition H5VLconnector.h:222
H5VL_DATASET_GET_TYPE
@ H5VL_DATASET_GET_TYPE
Definition H5VLconnector.h:224
H5VL_dataset_get_args_t::space_id
hid_t space_id
Definition H5VLconnector.h:245
H5VL_dataset_get_args_t::dcpl_id
hid_t dcpl_id
Definition H5VLconnector.h:240
H5VL_dataset_get_args_t::dapl_id
hid_t dapl_id
Definition H5VLconnector.h:235
H5VL_dataset_get_args_t::type_id
hid_t type_id
Definition H5VLconnector.h:260
H5VL_dataset_get_args_t::get_space
struct H5VL_dataset_get_args_t::@153335320133131360224107013164003240247000113372::@142367040332177125165115141324134254346032133036 get_space
H5VL_dataset_get_args_t::storage_size
hsize_t * storage_size
Definition H5VLconnector.h:255
H5VL_dataset_get_args_t::args
union H5VL_dataset_get_args_t::@153335320133131360224107013164003240247000113372 args
H5VL_dataset_get_args_t::get_type
struct H5VL_dataset_get_args_t::@153335320133131360224107013164003240247000113372::@215223264265060230271205035143324317305335164164 get_type
H5VL_dataset_get_args_t::op_type
H5VL_dataset_get_t op_type
Definition H5VLconnector.h:229
H5VL_dataset_get_args_t::get_space_status
struct H5VL_dataset_get_args_t::@153335320133131360224107013164003240247000113372::@150161063041315312027236166101260373221011343125 get_space_status
H5VL_dataset_get_args_t::get_storage_size
struct H5VL_dataset_get_args_t::@153335320133131360224107013164003240247000113372::@375173337001243367224131244063251014115163115356 get_storage_size
H5VL_dataset_get_args_t::status
H5D_space_status_t * status
Definition H5VLconnector.h:250
H5VL_dataset_get_args_t::get_dcpl
struct H5VL_dataset_get_args_t::@153335320133131360224107013164003240247000113372::@052016134364123326013203016121105255350053011171 get_dcpl
H5VL_dataset_get_args_t::get_dapl
struct H5VL_dataset_get_args_t::@153335320133131360224107013164003240247000113372::@172060242312276330050052122045006035177105204004 get_dapl

### dataset: specific

The specific callback in the dataset class implements specific operations on HDF5 datasets as specified in the specific_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*specific)(void *obj, H5VL_file_specific_args_t *args, hid_t dxpl_id, void **req); H5VL_file_specific_args_t Definition H5VLconnector.h:457
Arguments:
obj (IN): The dset where the operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for dataset 'specific' operation */
typedef enum H5VL_dataset_specific_t {
H5VL_DATASET_SET_EXTENT, /* H5Dset_extent */
H5VL_DATASET_FLUSH, /* H5Dflush */
H5VL_DATASET_REFRESH /* H5Drefresh */
} H5VL_dataset_specific_t;
/* Parameters for dataset 'specific' operations */
typedef struct H5VL_dataset_specific_args_t {
H5VL_dataset_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_DATASET_SET_EXTENT */
struct {
const hsize_t *size; /* New dataspace extent */
} set_extent;
/* H5VL_DATASET_FLUSH */
struct {
hid_t dset_id; /* Dataset ID (IN) */
} flush;
/* H5VL_DATASET_REFRESH */
struct {
hid_t dset_id; /* Dataset ID (IN) */
} refresh;
} args;
} H5VL_dataset_specific_args_t;
H5VL_dataset_specific_t
H5VL_dataset_specific_t
Definition H5VLconnector.h:266
H5VL_DATASET_FLUSH
@ H5VL_DATASET_FLUSH
Definition H5VLconnector.h:268
H5VL_DATASET_SET_EXTENT
@ H5VL_DATASET_SET_EXTENT
Definition H5VLconnector.h:267
H5VL_DATASET_REFRESH
@ H5VL_DATASET_REFRESH
Definition H5VLconnector.h:269
H5VL_dataset_specific_args_t::size
const hsize_t * size
Definition H5VLconnector.h:280
H5VL_dataset_specific_args_t::flush
struct H5VL_dataset_specific_args_t::@150243122340346021165032204017122066350337114043::@313222234057102123160361125346075030344144265243 flush
H5VL_dataset_specific_args_t::args
union H5VL_dataset_specific_args_t::@150243122340346021165032204017122066350337114043 args
H5VL_dataset_specific_args_t::op_type
H5VL_dataset_specific_t op_type
Definition H5VLconnector.h:274
H5VL_dataset_specific_args_t::set_extent
struct H5VL_dataset_specific_args_t::@150243122340346021165032204017122066350337114043::@254004050223001216016020361033237354012264007113 set_extent
H5VL_dataset_specific_args_t::dset_id
hid_t dset_id
Definition H5VLconnector.h:285
H5VL_dataset_specific_args_t::refresh
struct H5VL_dataset_specific_args_t::@150243122340346021165032204017122066350337114043::@327311204244102012344152307013001036032122233214 refresh

### dataset: optional

The optional callback in the dataset class implements connector specific operations on an HDF5 dataset. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where the operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

### dataset: close

The close callback in the dataset class terminates access to the dataset object and free all resources it was consuming and returns an herr_t indicating success or failure.

Signature:
herr_t (*close)(void *dset, hid_t dxpl_id, void **req);
Arguments:
dset (IN): Pointer to the dataset object. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

## Datatype Callbacks

The HDF5 datatype routines (Datatypes (H5T)) allow users to create and manage HDF5 datatypes. Those routines are divided into two categories. One that operates on all types of datatypes but do not modify the contents of the container (all in memory), and others that operate on named datatypes by accessing the container. When a user creates an HDF5 datatype, it is still an object in memory space (transient datatype) that has not been added to the HDF5 containers. Only when a user commits the HDF5 datatype, it becomes persistent in the container. Those are called named/committed datatypes. The transient H5T routines should work on named datatypes nevertheless.

All the Datatypes (H5T) API routines that modify the HDF5 container map to one of the named datatype callback routines in this class that the connector needs to implement.

Structure for datatype callback routines, H5VLconnector.h

typedef struct H5VL_datatype_class_t {
void *(*commit)(void *obj, const H5VL_loc_params_t *loc_params, const char *name, hid_t type_id,
hid_t lcpl_id, hid_t tcpl_id, hid_t tapl_id, hid_t dxpl_id, void **req);
void *(*open)(void *obj, const H5VL_loc_params_t *loc_params, const char *name, hid_t tapl_id,
hid_t dxpl_id, void **req);
herr_t (*get)(void *obj, H5VL_datatype_get_args_t *args, hid_t dxpl_id, void **req);
herr_t (*specific)(void *obj, H5VL_datatype_specific_args_t *args, hid_t dxpl_id, void **req);
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
herr_t (*close)(void *dt, hid_t dxpl_id, void **req);
} H5VL_datatype_class_t;
H5VL_datatype_class_t
Definition H5VLconnector.h:902
H5VL_datatype_class_t::specific
herr_t(* specific)(void *obj, H5VL_datatype_specific_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:908
H5VL_datatype_class_t::optional
herr_t(* optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:909
H5VL_datatype_class_t::close
herr_t(* close)(void *dt, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:910
H5VL_datatype_class_t::get
herr_t(* get)(void *obj, H5VL_datatype_get_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:907
H5VL_datatype_get_args_t
Definition H5VLconnector.h:306
H5VL_datatype_specific_args_t
Definition H5VLconnector.h:336

### datatype: commit

The commit callback in the named datatype class creates a datatype object in the container of the location object and returns a pointer to the datatype structure containing information to access the datatype in future calls.

Signature:
void *(*commit)(void *obj, H5VL_loc_params_t *loc_params, const char *name, hid_t type_id, hid_t lcpl_id, hid_t tcpl_id, hid_t tapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the datatype needs to be committed or where the look-up of the target object needs to start. loc_params (IN): Pointer to location parameters as explained in "Mapping the API to the Callbacks". In this call, the location type is always H5VL_OBJECT_BY_SELF. name (IN): The name of the datatype to be created. typeid (IN): The transient datatype identifier to be committed. lcpl_id (IN): The link creation property list. tcpl_id (IN): The datatype creation property list. tapl_id (IN): The datatype access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### datatype: open

The open callback in the named datatype class opens a previously committed datatype object in the container of the location object and returns a pointer to the datatype structure containing information to access the datatype in future calls.

Signature:
void *(*open) (void *obj, H5VL_loc_params_t *loc_params, const char * name, hid_t tapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the datatype needs to be opened or where the look-up of the target object needs to start. loc_params (IN): Pointer to location parameters as explained in "Mapping the API to the Callbacks". In this call, the location type is always H5VL_OBJECT_BY_SELF. name (IN): The name of the datatype to be opened. tapl_id (IN): The datatype access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### datatype: get

The get callback in the named datatype class retrieves information about the named datatype as specified in thegettypeparameter.It returns an herr_t indicating success or failure.

Signature:
herr_t (*get) (void *obj, H5VL_datatype_get_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The named datatype to retrieve information from. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for datatype 'get' operation */
typedef enum H5VL_datatype_get_t {
H5VL_DATATYPE_GET_BINARY_SIZE, /* Get size of serialized form of transient type */
H5VL_DATATYPE_GET_BINARY, /* Get serialized form of transient type */
H5VL_DATATYPE_GET_TCPL /* Datatype creation property list */
} H5VL_datatype_get_t;
/* Parameters for datatype 'get' operations */
typedef struct H5VL_datatype_get_args_t {
H5VL_datatype_get_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_DATATYPE_GET_BINARY_SIZE */
struct {
size_t *size; /* Size of serialized form of datatype (OUT) */
} get_binary_size;
/* H5VL_DATATYPE_GET_BINARY */
struct {
void *buf; /* Buffer to store serialized form of datatype (OUT) */
size_t buf_size; /* Size of serialized datatype buffer */
} get_binary;
/* H5VL_DATATYPE_GET_TCPL */
struct {
hid_t tcpl_id; /* Named datatype creation property list ID (OUT) */
} get_tcpl;
} args;
} H5VL_datatype_get_args_t;
H5VL_datatype_get_t
H5VL_datatype_get_t
Definition H5VLconnector.h:299
H5VL_DATATYPE_GET_BINARY
@ H5VL_DATATYPE_GET_BINARY
Definition H5VLconnector.h:301
H5VL_DATATYPE_GET_BINARY_SIZE
@ H5VL_DATATYPE_GET_BINARY_SIZE
Definition H5VLconnector.h:300
H5VL_DATATYPE_GET_TCPL
@ H5VL_DATATYPE_GET_TCPL
Definition H5VLconnector.h:302
H5VL_datatype_get_args_t::get_binary
struct H5VL_datatype_get_args_t::@207210347060164211074314155130167207266250377233::@152302211012210131235064104317035100077231317006 get_binary
H5VL_datatype_get_args_t::args
union H5VL_datatype_get_args_t::@207210347060164211074314155130167207266250377233 args
H5VL_datatype_get_args_t::get_binary_size
struct H5VL_datatype_get_args_t::@207210347060164211074314155130167207266250377233::@115001002205056166276243270107354227350303360136 get_binary_size
H5VL_datatype_get_args_t::op_type
H5VL_datatype_get_t op_type
Definition H5VLconnector.h:307
H5VL_datatype_get_args_t::buf
void * buf
Definition H5VLconnector.h:318
H5VL_datatype_get_args_t::get_tcpl
struct H5VL_datatype_get_args_t::@207210347060164211074314155130167207266250377233::@025011226023117242373074017054171120314254313273 get_tcpl
H5VL_datatype_get_args_t::size
size_t * size
Definition H5VLconnector.h:313
H5VL_datatype_get_args_t::buf_size
size_t buf_size
Definition H5VLconnector.h:319
H5VL_datatype_get_args_t::tcpl_id
hid_t tcpl_id
Definition H5VLconnector.h:324

### datatype: specific

The specific callback in the datatype class implements specific operations on HDF5 named datatypes as specified in the specific_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*specific)(void *obj, H5VL_loc_params_t *loc_params, H5VL_object_specific_args_t *args, hid_t dxpl_id, void **req); H5VL_object_specific_args_t Definition H5VLconnector.h:734
Arguments:
obj (IN): The container or object where the operation needs to happen. loc_params (IN): Pointer to location parameters as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for datatype 'specific' operation */
typedef enum H5VL_datatype_specific_t {
H5VL_DATATYPE_FLUSH, /* H5Tflush */
H5VL_DATATYPE_REFRESH /* H5Trefresh */
} H5VL_datatype_specific_t;
/* Parameters for datatype 'specific' operations */
typedef struct H5VL_datatype_specific_args_t {
H5VL_datatype_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_DATATYPE_FLUSH */
struct {
hid_t type_id; /* Named datatype ID (IN) */
} flush;
/* H5VL_DATATYPE_REFRESH */
struct {
hid_t type_id; /* Named datatype ID (IN) */
} refresh;
} args;
} H5VL_datatype_specific_args_t;
H5VL_datatype_specific_t
H5VL_datatype_specific_t
Definition H5VLconnector.h:330
H5VL_DATATYPE_FLUSH
@ H5VL_DATATYPE_FLUSH
Definition H5VLconnector.h:331
H5VL_DATATYPE_REFRESH
@ H5VL_DATATYPE_REFRESH
Definition H5VLconnector.h:332
H5VL_datatype_specific_args_t::flush
struct H5VL_datatype_specific_args_t::@361346243207036156133373007120171322013226133141::@054333252246127145325026051037007256166006037342 flush
H5VL_datatype_specific_args_t::refresh
struct H5VL_datatype_specific_args_t::@361346243207036156133373007120171322013226133141::@042307067256103152134045014300035037305036157303 refresh
H5VL_datatype_specific_args_t::type_id
hid_t type_id
Definition H5VLconnector.h:343
H5VL_datatype_specific_args_t::op_type
H5VL_datatype_specific_t op_type
Definition H5VLconnector.h:337
H5VL_datatype_specific_args_t::args
union H5VL_datatype_specific_args_t::@361346243207036156133373007120171322013226133141 args

### datatype: optional

The optional callback in the datatype class implements connector specific operations on an HDF5 datatype. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where the operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

### datatype: close

The close callback in the named datatype class terminates access to the datatype object and free all resources it was consuming and returns an herr_t indicating success or failure.

Signature:
herr_t (*close) (void *dt, hid_t dxpl_id, void **req);
Arguments:
dt (IN): Pointer to the datatype object. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

## File Callbacks

The file API routines (Files (H5F)) allow HDF5 users to create and manage HDF5 containers. All the Files (H5F) API routines that modify the HDF5 container map to one of the file callback routines in his class that the connector needs to implement.

File class for file API routines, H5VLconnector.h

typedef struct H5VL_file_class_t {
void *(*create)(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id, hid_t dxpl_id,
void **req);
void *(*open)(const char *name, unsigned flags, hid_t fapl_id, hid_t dxpl_id, void **req);
herr_t (*get)(void *obj, H5VL_file_get_args_t *args, hid_t dxpl_id, void **req);
herr_t (*specific)(void *obj, H5VL_file_specific_args_t *args, hid_t dxpl_id, void **req);
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
herr_t (*close)(void *file, hid_t dxpl_id, void **req);
} H5VL_file_class_t;
H5VL_file_class_t
Definition H5VLconnector.h:914
H5VL_file_class_t::optional
herr_t(* optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:920
H5VL_file_class_t::specific
herr_t(* specific)(void *obj, H5VL_file_specific_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:919
H5VL_file_class_t::get
herr_t(* get)(void *obj, H5VL_file_get_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:918
H5VL_file_class_t::close
herr_t(* close)(void *file, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:921
H5VL_file_get_args_t
Definition H5VLconnector.h:395

### file: create

The create callback in the file class should create a container and returns a pointer to the file structure created by the connector containing information to access the container in future calls.

Signature:
void *(*create)(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id, hid_tdxpl_id, void **req);
Arguments:
name (IN): The name of the container to be created. flags (IN): The creation flags of the container. fcpl_id (IN): The file creation property list. fapl_id (IN): The file access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### file: open

The open callback in the file class should open a container and returns a pointer to the file structure created by the connector containing information to access the container in future calls.

Signature:
void *(*open)(const char *name, unsigned flags, hid_t fapl_id, hid_t dxpl_id, void **req);
Arguments:
name (IN): The name of the container to open. flags (IN): The open flags of the container. fapl_id (IN): The file access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### file: get

The get callback in the file class should retrieve information about the container as specified in the get_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*get)(void *obj, H5VL_file_get_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where information needs to be retrieved from. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Info for H5VL_FILE_GET_CONT_INFO */
typedef struct H5VL_file_cont_info_t {
unsigned version; /* version information (keep first) */
uint64_t feature_flags; /* Container feature flags */
/* (none currently defined) */
size_t token_size; /* Size of tokens */
size_t blob_id_size; /* Size of blob IDs */
} H5VL_file_cont_info_t;
/* Values for file 'get' operation */
typedef enum H5VL_file_get_t {
H5VL_FILE_GET_CONT_INFO, /* file get container info */
H5VL_FILE_GET_FAPL, /* file access property list */
H5VL_FILE_GET_FCPL, /* file creation property list */
H5VL_FILE_GET_FILENO, /* file number */
H5VL_FILE_GET_INTENT, /* file intent */
H5VL_FILE_GET_NAME, /* file name */
H5VL_FILE_GET_OBJ_COUNT, /* object count in file */
H5VL_FILE_GET_OBJ_IDS /* object ids in file */
} H5VL_file_get_t;
/* Parameters for file 'get_name' operation */
typedef struct H5VL_file_get_name_args_t {
H5I_type_t type; /* ID type of object pointer */
size_t buf_size; /* Size of file name buffer (IN) */
char *buf; /* Buffer for file name (OUT) */
size_t *file_name_len; /* Actual length of file name (OUT) */
} H5VL_file_get_name_args_t;
/* Parameters for file 'get_obj_ids' operation */
typedef struct H5VL_file_get_obj_ids_args_t {
unsigned types; /* Type of objects to count */
size_t max_objs; /* Size of array of object IDs */
hid_t *oid_list; /* Array of object IDs (OUT) */
size_t *count; /* # of objects (OUT) */
} H5VL_file_get_obj_ids_args_t;
/* Parameters for file 'get' operations */
typedef struct H5VL_file_get_args_t {
H5VL_file_get_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_FILE_GET_CONT_INFO */
struct {
H5VL_file_cont_info_t *info; /* Container info (OUT) */
} get_cont_info;
/* H5VL_FILE_GET_FAPL */
struct {
hid_t fapl_id; /* File access property list (OUT) */
} get_fapl;
/* H5VL_FILE_GET_FCPL */
struct {
hid_t fcpl_id; /* File creation property list (OUT) */
} get_fcpl;
/* H5VL_FILE_GET_FILENO */
struct {
unsigned long *fileno; /* File "number" (OUT) */
} get_fileno;
/* H5VL_FILE_GET_INTENT */
struct {
unsigned *flags; /* File open/create intent flags (OUT) */
} get_intent;
/* H5VL_FILE_GET_NAME */
H5VL_file_get_name_args_t get_name;
/* H5VL_FILE_GET_OBJ_COUNT */
struct {
unsigned types; /* Type of objects to count */
size_t *count; /* # of objects (OUT) */
} get_obj_count;
/* H5VL_FILE_GET_OBJ_IDS */
H5VL_file_get_obj_ids_args_t get_obj_ids;
} args;
} H5VL_file_get_args_t;
H5VL_file_get_t
H5VL_file_get_t
Definition H5VLconnector.h:367
H5VL_FILE_GET_FILENO
@ H5VL_FILE_GET_FILENO
Definition H5VLconnector.h:371
H5VL_FILE_GET_CONT_INFO
@ H5VL_FILE_GET_CONT_INFO
Definition H5VLconnector.h:368
H5VL_FILE_GET_OBJ_IDS
@ H5VL_FILE_GET_OBJ_IDS
Definition H5VLconnector.h:375
H5VL_FILE_GET_FCPL
@ H5VL_FILE_GET_FCPL
Definition H5VLconnector.h:370
H5VL_FILE_GET_OBJ_COUNT
@ H5VL_FILE_GET_OBJ_COUNT
Definition H5VLconnector.h:374
H5VL_FILE_GET_INTENT
@ H5VL_FILE_GET_INTENT
Definition H5VLconnector.h:372
H5VL_FILE_GET_FAPL
@ H5VL_FILE_GET_FAPL
Definition H5VLconnector.h:369
H5VL_FILE_GET_NAME
@ H5VL_FILE_GET_NAME
Definition H5VLconnector.h:373
H5VL_file_cont_info_t
Definition H5VLconnector.h:358
H5VL_file_cont_info_t::version
unsigned version
Definition H5VLconnector.h:359
H5VL_file_cont_info_t::token_size
size_t token_size
Definition H5VLconnector.h:362
H5VL_file_cont_info_t::blob_id_size
size_t blob_id_size
Definition H5VLconnector.h:363
H5VL_file_cont_info_t::feature_flags
uint64_t feature_flags
Definition H5VLconnector.h:360
H5VL_file_get_args_t::get_fileno
struct H5VL_file_get_args_t::@203377154345164170157356230200236207220160023044::@011017207361117153301026106354001156063133074155 get_fileno
H5VL_file_get_args_t::count
size_t * count
Definition H5VLconnector.h:431
H5VL_file_get_args_t::get_name
H5VL_file_get_name_args_t get_name
Definition H5VLconnector.h:426
H5VL_file_get_args_t::info
H5VL_file_cont_info_t * info
Definition H5VLconnector.h:402
H5VL_file_get_args_t::get_obj_ids
H5VL_file_get_obj_ids_args_t get_obj_ids
Definition H5VLconnector.h:435
H5VL_file_get_args_t::fileno
unsigned long * fileno
Definition H5VLconnector.h:417
H5VL_file_get_args_t::get_fcpl
struct H5VL_file_get_args_t::@203377154345164170157356230200236207220160023044::@371366035142176104100261363351304244132121336161 get_fcpl
H5VL_file_get_args_t::op_type
H5VL_file_get_t op_type
Definition H5VLconnector.h:396
H5VL_file_get_args_t::args
union H5VL_file_get_args_t::@203377154345164170157356230200236207220160023044 args
H5VL_file_get_args_t::get_obj_count
struct H5VL_file_get_args_t::@203377154345164170157356230200236207220160023044::@350007324313026124236322124026343335203256221017 get_obj_count
H5VL_file_get_args_t::types
unsigned types
Definition H5VLconnector.h:430
H5VL_file_get_args_t::fapl_id
hid_t fapl_id
Definition H5VLconnector.h:407
H5VL_file_get_args_t::get_cont_info
struct H5VL_file_get_args_t::@203377154345164170157356230200236207220160023044::@272344366037253052051135316007205355242246152072 get_cont_info
H5VL_file_get_args_t::fcpl_id
hid_t fcpl_id
Definition H5VLconnector.h:412
H5VL_file_get_args_t::get_intent
struct H5VL_file_get_args_t::@203377154345164170157356230200236207220160023044::@166254174334331062045171031105260156377232151045 get_intent
H5VL_file_get_args_t::get_fapl
struct H5VL_file_get_args_t::@203377154345164170157356230200236207220160023044::@302374204377335267332041254076156061272064277307 get_fapl
H5VL_file_get_args_t::flags
unsigned * flags
Definition H5VLconnector.h:422
H5VL_file_get_name_args_t
Definition H5VLconnector.h:379
H5VL_file_get_name_args_t::buf
char * buf
Definition H5VLconnector.h:382
H5VL_file_get_name_args_t::file_name_len
size_t * file_name_len
Definition H5VLconnector.h:383
H5VL_file_get_name_args_t::buf_size
size_t buf_size
Definition H5VLconnector.h:381
H5VL_file_get_name_args_t::type
H5I_type_t type
Definition H5VLconnector.h:380
H5VL_file_get_obj_ids_args_t
Definition H5VLconnector.h:387
H5VL_file_get_obj_ids_args_t::count
size_t * count
Definition H5VLconnector.h:391
H5VL_file_get_obj_ids_args_t::max_objs
size_t max_objs
Definition H5VLconnector.h:389
H5VL_file_get_obj_ids_args_t::oid_list
hid_t * oid_list
Definition H5VLconnector.h:390
H5VL_file_get_obj_ids_args_t::types
unsigned types
Definition H5VLconnector.h:388

### file: specific

The specific callback in the file class implements specific operations on HDF5 files as specified in the specific_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*specific)(void *obj, H5VL_file_specific_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where the operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for file 'specific' operation */
typedef enum H5VL_file_specific_t {
H5VL_FILE_FLUSH, /* Flush file */
H5VL_FILE_REOPEN, /* Reopen the file */
H5VL_FILE_IS_ACCESSIBLE, /* Check if a file is accessible */
H5VL_FILE_DELETE, /* Delete a file */
H5VL_FILE_IS_EQUAL /* Check if two files are the same */
} H5VL_file_specific_t;
/* Parameters for file 'specific' operations */
typedef struct H5VL_file_specific_args_t {
H5VL_file_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_FILE_FLUSH */
struct {
H5I_type_t obj_type; /* Type of object to use */
H5F_scope_t scope; /* Scope of flush operation */
} flush;
/* H5VL_FILE_REOPEN */
struct {
void **file; /* File object for new file (OUT) */
} reopen;
/* H5VL_FILE_IS_ACCESSIBLE */
struct {
const char *filename; /* Name of file to check */
hid_t fapl_id; /* File access property list to use */
bool *accessible; /* Whether file is accessible with FAPL settings (OUT) */
} is_accessible;
/* H5VL_FILE_DELETE */
struct {
const char *filename; /* Name of file to delete */
hid_t fapl_id; /* File access property list to use */
} del;
/* H5VL_FILE_IS_EQUAL */
struct {
void *obj2; /* Second file object to compare against */
bool *same_file; /* Whether files are the same (OUT) */
} is_equal;
} args;
} H5VL_file_specific_args_t;
H5F_scope_t
H5F_scope_t
Definition H5Fpublic.h:91
H5VL_file_specific_t
H5VL_file_specific_t
Definition H5VLconnector.h:440
H5VL_FILE_REOPEN
@ H5VL_FILE_REOPEN
Definition H5VLconnector.h:442
H5VL_FILE_IS_EQUAL
@ H5VL_FILE_IS_EQUAL
Definition H5VLconnector.h:453
H5VL_FILE_IS_ACCESSIBLE
@ H5VL_FILE_IS_ACCESSIBLE
Definition H5VLconnector.h:443
H5VL_FILE_DELETE
@ H5VL_FILE_DELETE
Definition H5VLconnector.h:452
H5VL_FILE_FLUSH
@ H5VL_FILE_FLUSH
Definition H5VLconnector.h:441
H5VL_file_specific_args_t::scope
H5F_scope_t scope
Definition H5VLconnector.h:465
H5VL_file_specific_args_t::args
union H5VL_file_specific_args_t::@350160162004057176146137034057166155372175301172 args
H5VL_file_specific_args_t::flush
struct H5VL_file_specific_args_t::@350160162004057176146137034057166155372175301172::@327322200242155116134336214002110102277040035111 flush
H5VL_file_specific_args_t::del
struct H5VL_file_specific_args_t::@350160162004057176146137034057166155372175301172::@237032256227232337104261147027366256142037327120 del
H5VL_file_specific_args_t::is_accessible
struct H5VL_file_specific_args_t::@350160162004057176146137034057166155372175301172::@255310331101015242163270154206156067274205204371 is_accessible
H5VL_file_specific_args_t::op_type
H5VL_file_specific_t op_type
Definition H5VLconnector.h:458
H5VL_file_specific_args_t::file
void ** file
Definition H5VLconnector.h:470
H5VL_file_specific_args_t::filename
const char * filename
Definition H5VLconnector.h:475
H5VL_file_specific_args_t::obj_type
H5I_type_t obj_type
Definition H5VLconnector.h:464
H5VL_file_specific_args_t::same_file
bool * same_file
Definition H5VLconnector.h:489
H5VL_file_specific_args_t::is_equal
struct H5VL_file_specific_args_t::@350160162004057176146137034057166155372175301172::@117306305054203360013355225117110173067160012360 is_equal
H5VL_file_specific_args_t::reopen
struct H5VL_file_specific_args_t::@350160162004057176146137034057166155372175301172::@212364236151240367366272372004105226027164363233 reopen
H5VL_file_specific_args_t::accessible
bool * accessible
Definition H5VLconnector.h:477
H5VL_file_specific_args_t::obj2
void * obj2
Definition H5VLconnector.h:488
H5VL_file_specific_args_t::fapl_id
hid_t fapl_id
Definition H5VLconnector.h:476

### file: optional

The optional callback in the file class implements connector specific operations on an HDF5 container. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where the operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

### file: close

The close callback in the file class should terminate access to the file object and free all resources it was consuming, and returns an herr_t indicating success or failure.

Signature:
herr_t (*close)(void *file, hid_t dxpl_id, void **req);
Arguments:
file (IN): Pointer to the file. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

## Group Callbacks

The group API routines (Groups (H5G)) allow HDF5 users to create and manage HDF5 groups. All the Groups (H5G) API routines that modify the HDF5 container map to one of the group callback routines in this class that the connector needs to implement.

Structure for group callback routines, H5VLconnector.h

typedef struct H5VL_group_class_t {
void *(*create)(void *obj, const H5VL_loc_params_t *loc_params, const char *name, hid_t lcpl_id,
hid_t gcpl_id, hid_t gapl_id, hid_t dxpl_id, void **req);
void *(*open)(void *obj, const H5VL_loc_params_t *loc_params, const char *name, hid_t gapl_id,
hid_t dxpl_id, void **req);
herr_t (*get)(void *obj, H5VL_group_get_args_t *args, hid_t dxpl_id, void **req);
herr_t (*specific)(void *obj, H5VL_group_specific_args_t *args, hid_t dxpl_id, void **req);
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
herr_t (*close)(void *grp, hid_t dxpl_id, void **req);
} H5VL_group_class_t;
H5VL_group_class_t
Definition H5VLconnector.h:925
H5VL_group_class_t::optional
herr_t(* optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:932
H5VL_group_class_t::get
herr_t(* get)(void *obj, H5VL_group_get_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:930
H5VL_group_class_t::specific
herr_t(* specific)(void *obj, H5VL_group_specific_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:931
H5VL_group_class_t::close
herr_t(* close)(void *grp, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:933
H5VL_group_get_args_t
Definition H5VLconnector.h:510
H5VL_group_specific_args_t
Definition H5VLconnector.h:541

### group: create

The create callback in the group class creates a group object in the container of the location object and returns a pointer to the group structure containing information to access the group in future calls.

Signature:
void *(*create)(void *obj, H5VL_loc_params_t *loc_params, const char *name, hid_t gcpl_id,hid_t gapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the group needs to be created or where the look-up of the target object needs to start. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_SELF in this callback. name (IN): The name of the group to be created. dcpl_id (IN): The group creation property list. It contains all the group creation properties in addition to the link creation property list of the create operation (an hid_t) that can be retrieved with the property H5VL_GRP_LCPL_ID. gapl_id (IN): The group access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### group: open

The open callback in the group class opens a group object in the container of the location object and returns a pointer to the group structure containing information to access the group in future calls.

Signature:
void *(*open)(void *obj, H5VL_loc_params_t *loc_params, const char *name, hid_t gapl_id, hid_t dxpl_id, void **req);
Arguments:
obj (IN): Pointer to an object where the group needs to be opened or where the look-up of the target object needs to start. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_SELF in this callback. name (IN): The name of the group to be opened. gapl_id (IN): The group access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### group: get

The get callback in the group class retrieves information about the group as specified in the get_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*get)(void *obj, H5VL_group_get_args_t *args, hid_t dxpl_id, void **req)
Arguments:
obj (IN): The group object where information needs to be retrieved from. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for group 'get' operation */
typedef enum H5VL_group_get_t {
H5VL_GROUP_GET_GCPL, /* group creation property list */
H5VL_GROUP_GET_INFO /* group info */
} H5VL_group_get_t;
/* Parameters for group 'get_info' operation */
typedef struct H5VL_group_get_info_args_t {
H5VL_loc_params_t loc_params; /* Location parameters for object access */
H5G_info_t *ginfo; /* Group info (OUT) */
} H5VL_group_get_info_args_t;
/* Parameters for group 'get' operations */
typedef struct H5VL_group_get_args_t {
H5VL_group_get_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_GROUP_GET_GCPL */
struct {
hid_t gcpl_id; /* Group creation property list (OUT) */
} get_gcpl;
/* H5VL_GROUP_GET_INFO */
H5VL_group_get_info_args_t get_info; /* Group info */
} args;
} H5VL_group_get_args_t;
H5VL_group_get_t
H5VL_group_get_t
Definition H5VLconnector.h:498
H5VL_GROUP_GET_INFO
@ H5VL_GROUP_GET_INFO
Definition H5VLconnector.h:500
H5VL_GROUP_GET_GCPL
@ H5VL_GROUP_GET_GCPL
Definition H5VLconnector.h:499
H5G_info_t
Definition H5Gpublic.h:55
H5VL_group_get_args_t::op_type
H5VL_group_get_t op_type
Definition H5VLconnector.h:511
H5VL_group_get_args_t::get_gcpl
struct H5VL_group_get_args_t::@333343267324240075252033371156074076272132061272::@302235135314326045061234204343245113127276164170 get_gcpl
H5VL_group_get_args_t::get_info
H5VL_group_get_info_args_t get_info
Definition H5VLconnector.h:521
H5VL_group_get_args_t::gcpl_id
hid_t gcpl_id
Definition H5VLconnector.h:517
H5VL_group_get_args_t::args
union H5VL_group_get_args_t::@333343267324240075252033371156074076272132061272 args
H5VL_group_get_info_args_t
Definition H5VLconnector.h:504
H5VL_group_get_info_args_t::loc_params
H5VL_loc_params_t loc_params
Definition H5VLconnector.h:505
H5VL_group_get_info_args_t::ginfo
H5G_info_t * ginfo
Definition H5VLconnector.h:506

### group: specific

The specific callback in the group class implements specific operations on HDF5 groups as specified in the specific_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*specific)(void *obj, H5VL_loc_params_t *loc_params, H5VL_object_specific_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where the operation needs to happen. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for group 'specific' operation */
typedef enum H5VL_group_specific_t {
H5VL_GROUP_MOUNT, /* Mount a file on a group */
H5VL_GROUP_UNMOUNT, /* Unmount a file on a group */
H5VL_GROUP_FLUSH, /* H5Gflush */
H5VL_GROUP_REFRESH /* H5Grefresh */
} H5VL_group_specific_t;
/* Parameters for group 'mount' operation */
typedef struct H5VL_group_spec_mount_args_t {
const char *name; /* Name of location to mount child file */
void *child_file; /* Pointer to child file object */
hid_t fmpl_id; /* File mount property list to use */
} H5VL_group_spec_mount_args_t;
/* Parameters for group 'specific' operations */
typedef struct H5VL_group_specific_args_t {
H5VL_group_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_GROUP_MOUNT */
H5VL_group_spec_mount_args_t mount;
/* H5VL_GROUP_UNMOUNT */
struct {
const char *name; /* Name of location to unmount child file */
} unmount;
/* H5VL_GROUP_FLUSH */
struct {
hid_t grp_id; /* Group ID (IN) */
} flush;
/* H5VL_GROUP_REFRESH */
struct {
hid_t grp_id; /* Group ID (IN) */
} refresh;
} args;
} H5VL_group_specific_args_t;
H5VL_group_specific_t
H5VL_group_specific_t
Definition H5VLconnector.h:526
H5VL_GROUP_MOUNT
@ H5VL_GROUP_MOUNT
Definition H5VLconnector.h:527
H5VL_GROUP_UNMOUNT
@ H5VL_GROUP_UNMOUNT
Definition H5VLconnector.h:528
H5VL_GROUP_FLUSH
@ H5VL_GROUP_FLUSH
Definition H5VLconnector.h:529
H5VL_GROUP_REFRESH
@ H5VL_GROUP_REFRESH
Definition H5VLconnector.h:530
H5VL_group_spec_mount_args_t
Definition H5VLconnector.h:534
H5VL_group_spec_mount_args_t::fmpl_id
hid_t fmpl_id
Definition H5VLconnector.h:537
H5VL_group_spec_mount_args_t::name
const char * name
Definition H5VLconnector.h:535
H5VL_group_spec_mount_args_t::child_file
void * child_file
Definition H5VLconnector.h:536
H5VL_group_specific_args_t::refresh
struct H5VL_group_specific_args_t::@026176172063377047355202013252036160164104345365::@206021050356213057175104277370273374135141122033 refresh
H5VL_group_specific_args_t::grp_id
hid_t grp_id
Definition H5VLconnector.h:556
H5VL_group_specific_args_t::args
union H5VL_group_specific_args_t::@026176172063377047355202013252036160164104345365 args
H5VL_group_specific_args_t::name
const char * name
Definition H5VLconnector.h:551
H5VL_group_specific_args_t::op_type
H5VL_group_specific_t op_type
Definition H5VLconnector.h:542
H5VL_group_specific_args_t::flush
struct H5VL_group_specific_args_t::@026176172063377047355202013252036160164104345365::@007167312366012020355171320053344247057270134032 flush
H5VL_group_specific_args_t::mount
H5VL_group_spec_mount_args_t mount
Definition H5VLconnector.h:547
H5VL_group_specific_args_t::unmount
struct H5VL_group_specific_args_t::@026176172063377047355202013252036160164104345365::@243165323064006060342017315063115262024255075061 unmount

### group: optional

The optional callback in the group class implements connector specific operations on an HDF5 group. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where the operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

### group: close

The close callback in the group class terminates access to the group object and frees all resources it was consuming, and returns an herr_t indicating success or failure.

Signature:
herr_t (*close)(void *group, hid_t dxpl_id, void **req);
Arguments:
group (IN): Pointer to the group object. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

## Link Callbacks

The link API routines (Links (H5L)) allow HDF5 users to create and manage HDF5 links. All the Links (H5L) API routines that modify the HDF5 container map to one of the link callback routines in this class that the connector needs to implement.

Structure for link callback routines, H5VLconnector.h

typedef struct H5VL_link_class_t {
herr_t (*create)(H5VL_link_create_args_t *args, void *obj, const H5VL_loc_params_t *loc_params,
hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req);
herr_t (*copy)(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj,
const H5VL_loc_params_t *loc_params2, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id,
void **req);
herr_t (*move)(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj,
const H5VL_loc_params_t *loc_params2, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id,
void **req);
herr_t (*get)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_link_get_args_t *args, hid_t dxpl_id,
void **req);
herr_t (*specific)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_link_specific_args_t *args,
hid_t dxpl_id, void **req);
herr_t (*optional)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_optional_args_t *args,
hid_t dxpl_id, void **req);
} H5VL_link_class_t;
H5VL_link_class_t
Definition H5VLconnector.h:937
H5VL_link_class_t::create
herr_t(* create)(H5VL_link_create_args_t *args, void *obj, const H5VL_loc_params_t *loc_params, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:938
H5VL_link_class_t::move
herr_t(* move)(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj, const H5VL_loc_params_t *loc_params2, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:943
H5VL_link_class_t::copy
herr_t(* copy)(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj, const H5VL_loc_params_t *loc_params2, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:940
H5VL_link_class_t::get
herr_t(* get)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_link_get_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:946
H5VL_link_class_t::optional
herr_t(* optional)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:950
H5VL_link_class_t::specific
herr_t(* specific)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_link_specific_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:948
H5VL_link_create_args_t
Definition H5VLconnector.h:577
H5VL_link_get_args_t
Definition H5VLconnector.h:610
H5VL_link_specific_args_t
Definition H5VLconnector.h:653

### link: create

The create callback in the group class creates a hard, soft, external, or user-defined link in the container. It returns an herr_t indicating success or failure.

Signature:
herr_t (*create)(H5VL_link_create_args_t *args, void *obj, H5VL_loc_params_t *loc_params, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req)
Arguments:
args (IN/OUT): A pointer to the arguments struct. obj (IN): Pointer to an object where the link needs to be created from. loc_params (IN): Pointer to the location parameters as explained in "Mapping the API to the Callbacks" for the source object. lcplid (IN): The link creation property list. It contains all the link creation properties in addition to other API parameters depending on the creation type, which will be detailed next. laplid (IN): The link access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Link create types for VOL */
typedef enum H5VL_link_create_t {
H5VL_LINK_CREATE_HARD,
H5VL_LINK_CREATE_SOFT,
H5VL_LINK_CREATE_UD
} H5VL_link_create_t;
/* Parameters for link 'create' operations */
typedef struct H5VL_link_create_args_t {
H5VL_link_create_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_LINK_CREATE_HARD */
struct {
void *curr_obj; /* Current object */
H5VL_loc_params_t curr_loc_params; /* Location parameters for current object */
} hard;
/* H5VL_LINK_CREATE_SOFT */
struct {
const char *target; /* Target of soft link */
} soft;
/* H5VL_LINK_CREATE_UD */
struct {
H5L_type_t type; /* Type of link to create */
const void *buf; /* Buffer that contains link info */
size_t buf_size; /* Size of link info buffer */
} ud;
} args;
} H5VL_link_create_args_t;
H5L_type_t
H5L_type_t
Link class types.
Definition H5Lpublic.h:57
H5VL_link_create_t
H5VL_link_create_t
Definition H5VLconnector.h:570
H5VL_LINK_CREATE_UD
@ H5VL_LINK_CREATE_UD
Definition H5VLconnector.h:573
H5VL_LINK_CREATE_HARD
@ H5VL_LINK_CREATE_HARD
Definition H5VLconnector.h:571
H5VL_LINK_CREATE_SOFT
@ H5VL_LINK_CREATE_SOFT
Definition H5VLconnector.h:572
H5VL_link_create_args_t::args
union H5VL_link_create_args_t::@321356074204147152175121241077171243350247053200 args
H5VL_link_create_args_t::ud
struct H5VL_link_create_args_t::@321356074204147152175121241077171243350247053200::@314124236256374357163044356053263324076135323354 ud
H5VL_link_create_args_t::buf
const void * buf
Definition H5VLconnector.h:596
H5VL_link_create_args_t::soft
struct H5VL_link_create_args_t::@321356074204147152175121241077171243350247053200::@251210230267352146022252041045073102105266377104 soft
H5VL_link_create_args_t::op_type
H5VL_link_create_t op_type
Definition H5VLconnector.h:578
H5VL_link_create_args_t::curr_loc_params
H5VL_loc_params_t curr_loc_params
Definition H5VLconnector.h:585
H5VL_link_create_args_t::type
H5L_type_t type
Definition H5VLconnector.h:595
H5VL_link_create_args_t::hard
struct H5VL_link_create_args_t::@321356074204147152175121241077171243350247053200::@354300332103006322052373025226005273105320261035 hard
H5VL_link_create_args_t::curr_obj
void * curr_obj
Definition H5VLconnector.h:584
H5VL_link_create_args_t::buf_size
size_t buf_size
Definition H5VLconnector.h:597
H5VL_link_create_args_t::target
const char * target
Definition H5VLconnector.h:590

### link: copy

The copy callback in the link class copies a link within the HDF5 container. It returns an herr_t indicating success or failure.

Signature:
herr_t (*copy)(void *src_obj, H5VL_loc_params_t *loc_params1, void *dst_obj, H5VL_loc_params_t *loc_params2, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req);
Arguments:
src_obj (IN): original/source object or file. loc_params1 (IN): Pointer to the location parameters for the source object as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_NAME in this callback. dst_obj (IN): destination object or file. loc_params2 (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_NAME in this callback. lcpl_id (IN): The link creation property list. lapl_id (IN): The link access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### link: move

The move callback in the link class moves a link within the HDF5 container. It returns an herr_t indicating success or failure.

Signature:
herr_t (*move)(void *src_obj, H5VL_loc_params_t *loc_params1, void *dst_obj, H5VL_loc_params_t *loc_params2, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req);
Arguments:
src_obj (IN): original/source object or file. loc_params1 (IN): Pointer to the location parameters for the source object as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_NAME in this callback. dst_obj (IN): destination object or file. loc_params2 (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_NAME in this callback. lcpl_id (IN): The link creation property list. lapl_id (IN): The link access property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### link: get

The get callback in the link class retrieves information about links as specified in the get_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*get)(void *obj, H5VL_loc_params_t *loc_params, H5VL_link_get_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The file or group object where information needs to be retrieved from. loc_params (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_NAME or H5VL_OBJECT_BY_IDX in this callback. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for link 'get' operation */
typedef enum H5VL_link_get_t {
H5VL_LINK_GET_INFO, /* link info */
H5VL_LINK_GET_NAME, /* link name */
H5VL_LINK_GET_VAL /* link value */
} H5VL_link_get_t;
/* Parameters for link 'get' operations */
typedef struct H5VL_link_get_args_t {
H5VL_link_get_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_LINK_GET_INFO */
struct {
H5L_info2_t *linfo; /* Pointer to link's info (OUT) */
} get_info;
/* H5VL_LINK_GET_NAME */
struct {
size_t name_size; /* Size of link name buffer (IN) */
char *name; /* Buffer for link name (OUT) */
size_t *name_len; /* Actual length of link name (OUT) */
} get_name;
/* H5VL_LINK_GET_VAL */
struct {
size_t buf_size; /* Size of link value buffer (IN) */
void *buf; /* Buffer for link value (OUT) */
} get_val;
} args;
} H5VL_link_get_args_t;
H5VL_link_get_t
H5VL_link_get_t
Definition H5VLconnector.h:603
H5VL_LINK_GET_NAME
@ H5VL_LINK_GET_NAME
Definition H5VLconnector.h:605
H5VL_LINK_GET_VAL
@ H5VL_LINK_GET_VAL
Definition H5VLconnector.h:606
H5VL_LINK_GET_INFO
@ H5VL_LINK_GET_INFO
Definition H5VLconnector.h:604
H5L_info2_t
Information struct for links.
Definition H5Lpublic.h:76
H5VL_link_get_args_t::get_info
struct H5VL_link_get_args_t::@113136144362365073150253333034375224042265021277::@172130307036072251121044315101050302133164055344 get_info
H5VL_link_get_args_t::linfo
H5L_info2_t * linfo
Definition H5VLconnector.h:617
H5VL_link_get_args_t::args
union H5VL_link_get_args_t::@113136144362365073150253333034375224042265021277 args
H5VL_link_get_args_t::get_val
struct H5VL_link_get_args_t::@113136144362365073150253333034375224042265021277::@367077225027341310162131021232113246327317267260 get_val
H5VL_link_get_args_t::name
char * name
Definition H5VLconnector.h:623
H5VL_link_get_args_t::buf
void * buf
Definition H5VLconnector.h:630
H5VL_link_get_args_t::name_size
size_t name_size
Definition H5VLconnector.h:622
H5VL_link_get_args_t::op_type
H5VL_link_get_t op_type
Definition H5VLconnector.h:611
H5VL_link_get_args_t::name_len
size_t * name_len
Definition H5VLconnector.h:624
H5VL_link_get_args_t::get_name
struct H5VL_link_get_args_t::@113136144362365073150253333034375224042265021277::@016144335352156373344013262017232174155161047105 get_name
H5VL_link_get_args_t::buf_size
size_t buf_size
Definition H5VLconnector.h:629

### link: specific

The specific callback in the link class implements specific operations on HDF5 links as specified in the specific_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*specific)(void *obj, H5VL_loc_params_t *loc_params, H5VL_link_specific_args_t *args, hid_t dxpl_id, void **req)
Arguments:
obj (IN): The location object where operation needs to happen. loc_params (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for link 'specific' operation */
typedef enum H5VL_link_specific_t {
H5VL_LINK_DELETE, /* H5Ldelete(_by_idx) */
H5VL_LINK_EXISTS, /* link existence */
H5VL_LINK_ITER /* H5Literate/visit(_by_name) */
} H5VL_link_specific_t;
/* Parameters for link 'iterate' operation */
typedef struct H5VL_link_iterate_args_t {
bool recursive; /* Whether iteration is recursive */
H5_index_t idx_type; /* Type of index to iterate over */
H5_iter_order_t order; /* Order of index iteration */
hsize_t *idx_p; /* Start/stop iteration index (OUT) */
H5L_iterate2_t op; /* Iteration callback function */
void *op_data; /* Iteration callback context */
} H5VL_link_iterate_args_t;
/* Parameters for link 'specific' operations */
typedef struct H5VL_link_specific_args_t {
H5VL_link_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_LINK_DELETE */
/* No args */
/* H5VL_LINK_EXISTS */
struct {
bool *exists; /* Whether link exists (OUT) */
} exists;
/* H5VL_LINK_ITER */
H5VL_link_iterate_args_t iterate;
} args;
} H5VL_link_specific_args_t;
H5L_iterate2_t
herr_t(* H5L_iterate2_t)(hid_t group, const char *name, const H5L_info2_t *info, void *op_data)
Prototype for H5Literate2(), H5Literate_by_name2() operator.
Definition H5Lpublic.h:94
H5VL_link_specific_t
H5VL_link_specific_t
Definition H5VLconnector.h:636
H5VL_LINK_ITER
@ H5VL_LINK_ITER
Definition H5VLconnector.h:639
H5VL_LINK_EXISTS
@ H5VL_LINK_EXISTS
Definition H5VLconnector.h:638
H5VL_LINK_DELETE
@ H5VL_LINK_DELETE
Definition H5VLconnector.h:637
H5VL_link_iterate_args_t
Definition H5VLconnector.h:643
H5VL_link_iterate_args_t::idx_type
H5_index_t idx_type
Definition H5VLconnector.h:645
H5VL_link_iterate_args_t::idx_p
hsize_t * idx_p
Definition H5VLconnector.h:647
H5VL_link_iterate_args_t::recursive
bool recursive
Definition H5VLconnector.h:644
H5VL_link_iterate_args_t::op_data
void * op_data
Definition H5VLconnector.h:649
H5VL_link_iterate_args_t::order
H5_iter_order_t order
Definition H5VLconnector.h:646
H5VL_link_iterate_args_t::op
H5L_iterate2_t op
Definition H5VLconnector.h:648
H5VL_link_specific_args_t::args
union H5VL_link_specific_args_t::@167370167024242237262131315173253325233171101142 args
H5VL_link_specific_args_t::op_type
H5VL_link_specific_t op_type
Definition H5VLconnector.h:654
H5VL_link_specific_args_t::exists
bool * exists
Definition H5VLconnector.h:663
H5VL_link_specific_args_t::iterate
H5VL_link_iterate_args_t iterate
Definition H5VLconnector.h:667

### link: optional

The optional callback in the link class implements connector specific operations on an HDF5 link. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where operation needs to happen. loc_params (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

## Object Callbacks

The object API routines (Objects (H5O)) allow HDF5 users to manage HDF5 group, dataset, and named datatype objects. All the Objects (H5O) API routines that modify the HDF5 container map to one of the object callback routines in this class that the connector needs to implement.

Structure for object callback routines, H5VLconnector.h

typedef struct H5VL_object_class_t {
void *(*open)(void *obj, const H5VL_loc_params_t *loc_params, H5I_type_t *opened_type, hid_t dxpl_id,
void **req);
herr_t (*copy)(void *src_obj, const H5VL_loc_params_t *loc_params1, const char *src_name, void *dst_obj,
const H5VL_loc_params_t *loc_params2, const char *dst_name, hid_t ocpypl_id, hid_t lcpl_id,
hid_t dxpl_id, void **req);
herr_t (*get)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_object_get_args_t *args, hid_t dxpl_id,
void **req);
herr_t (*specific)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_object_specific_args_t *args,
hid_t dxpl_id, void **req);
herr_t (*optional)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_optional_args_t *args,
hid_t dxpl_id, void **req);
} H5VL_object_class_t;
H5VL_object_class_t
Definition H5VLconnector.h:955
H5VL_object_class_t::get
herr_t(* get)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_object_get_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:961
H5VL_object_class_t::specific
herr_t(* specific)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_object_specific_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:963
H5VL_object_class_t::optional
herr_t(* optional)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:965
H5VL_object_class_t::copy
herr_t(* copy)(void *src_obj, const H5VL_loc_params_t *loc_params1, const char *src_name, void *dst_obj, const H5VL_loc_params_t *loc_params2, const char *dst_name, hid_t ocpypl_id, hid_t lcpl_id, hid_t dxpl_id, void **req)
Definition H5VLconnector.h:958
H5VL_object_get_args_t
Definition H5VLconnector.h:684

### object: open

The open callback in the object class opens the object in the container of the location object and returns a pointer to the object structure containing information to access the object in future calls.

Signature:
void *(*open)(void *obj, H5VL_loc_params_t *loc_params, H5I_type_t *opened_type, hid_t dxpl_id, void **req);
Arguments:
obj (IN): The container or object where operation needs to happen. loc_params (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". opened_type (OUT): Buffer to return the type of the object opened (H5I_GROUP or H5I_DATASET or H5I_DATATYPE). dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector. H5I_GROUP @ H5I_GROUP Definition H5Ipublic.h:38 H5I_DATASET @ H5I_DATASET Definition H5Ipublic.h:41 H5I_DATATYPE @ H5I_DATATYPE Definition H5Ipublic.h:39

### object: copy

The copy callback in the object class copies the object from the source object to the destination object. It returns an herr_t indicating success or failure.

Signature:
herr_t (*copy)(void *src_obj, H5VL_loc_params_t *loc_params1, const char *src_name, void *dst_obj, H5VL_loc_params_t *loc_params2, const char *dst_name, hid_t ocpypl_id, hid_t lcpl_id, hid_t dxpl_id, void **req)
Arguments:
src_obj (IN): Pointer to location of the source object to be copied. loc_params1 (IN): Pointer to the location parameters for the source object as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_SELF in this callback. src_name (IN): Name of the source object to be copied. dst_obj (IN): Pointer to location of the destination object or file. loc_params2 (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". The type can be only H5VL_OBJECT_BY_SELF in this callback. dst_name (IN): Name o be assigned to the new copy. ocpypl_id (IN): The object copy property list. lcpl_id (IN): The link creation property list. dxpl_id (IN): The data transfer property list. req (IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

### object: get

The get callback in the object class retrieves information about the object as specified in the get_type parameter.It returns an herr_t indicating success or failure.

Signature:
herr_t (*get)(void *obj, H5VL_loc_params_t *loc_params, H5VL_object_get_args_t *args, hid_t dxpl_id, void **req)
Arguments:
obj (IN): A location object where information needs to be retrieved from. loc_params (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for object 'get' operation */
typedef enum H5VL_object_get_t {
H5VL_OBJECT_GET_FILE, /* object file */
H5VL_OBJECT_GET_NAME, /* object name */
H5VL_OBJECT_GET_TYPE, /* object type */
H5VL_OBJECT_GET_INFO /* H5Oget_info(_by_idx|name) */
} H5VL_object_get_t;
/* Parameters for object 'get' operations */
typedef struct H5VL_object_get_args_t {
H5VL_object_get_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_OBJECT_GET_FILE */
struct {
void **file; /* File object (OUT) */
} get_file;
/* H5VL_OBJECT_GET_NAME */
struct {
size_t buf_size; /* Size of name buffer (IN) */
char *buf; /* Buffer for name (OUT) */
size_t *name_len; /* Actual length of name (OUT) */
} get_name;
/* H5VL_OBJECT_GET_TYPE */
struct {
H5O_type_t *obj_type; /* Type of object (OUT) */
} get_type;
/* H5VL_OBJECT_GET_INFO */
struct {
unsigned fields; /* Flags for fields to retrieve */
H5O_info2_t *oinfo; /* Pointer to object info (OUT) */
} get_info;
} args;
} H5VL_object_get_args_t;
H5O_type_t
H5O_type_t
Definition H5Opublic.h:107
H5VL_object_get_t
H5VL_object_get_t
Definition H5VLconnector.h:676
H5VL_OBJECT_GET_TYPE
@ H5VL_OBJECT_GET_TYPE
Definition H5VLconnector.h:679
H5VL_OBJECT_GET_FILE
@ H5VL_OBJECT_GET_FILE
Definition H5VLconnector.h:677
H5VL_OBJECT_GET_NAME
@ H5VL_OBJECT_GET_NAME
Definition H5VLconnector.h:678
H5VL_OBJECT_GET_INFO
@ H5VL_OBJECT_GET_INFO
Definition H5VLconnector.h:680
H5VL_object_get_args_t::buf
char * buf
Definition H5VLconnector.h:697
H5VL_object_get_args_t::get_name
struct H5VL_object_get_args_t::@352130112131156373063211320350222140001066225312::@173003014157303202055262317310241354006250362370 get_name
H5VL_object_get_args_t::args
union H5VL_object_get_args_t::@352130112131156373063211320350222140001066225312 args
H5VL_object_get_args_t::file
void ** file
Definition H5VLconnector.h:691
H5VL_object_get_args_t::fields
unsigned fields
Definition H5VLconnector.h:708
H5VL_object_get_args_t::oinfo
H5O_info2_t * oinfo
Definition H5VLconnector.h:709
H5VL_object_get_args_t::get_info
struct H5VL_object_get_args_t::@352130112131156373063211320350222140001066225312::@164260044111221266351245026126217306145002344171 get_info
H5VL_object_get_args_t::op_type
H5VL_object_get_t op_type
Definition H5VLconnector.h:685
H5VL_object_get_args_t::get_type
struct H5VL_object_get_args_t::@352130112131156373063211320350222140001066225312::@377304200060360374262244006204223067317155161020 get_type
H5VL_object_get_args_t::get_file
struct H5VL_object_get_args_t::@352130112131156373063211320350222140001066225312::@142056250136200174027260237306244055222327254074 get_file
H5VL_object_get_args_t::name_len
size_t * name_len
Definition H5VLconnector.h:698
H5VL_object_get_args_t::buf_size
size_t buf_size
Definition H5VLconnector.h:696
H5VL_object_get_args_t::obj_type
H5O_type_t * obj_type
Definition H5VLconnector.h:703

### object: specific

The specific callback in the object class implements specific operations on HDF5 objects as specified in the specific_type parameter. It returns an herr_t indicating success or failure.

Signature:
herr_t (*specific)(void *obj, H5VL_loc_params_t *loc_params, H5VL_object_specific_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): A location object where he operation needs to happen. loc_params (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

/* Values for object 'specific' operation */
typedef enum H5VL_object_specific_t {
H5VL_OBJECT_CHANGE_REF_COUNT, /* H5Oincr/decr_refcount */
H5VL_OBJECT_EXISTS, /* H5Oexists_by_name */
H5VL_OBJECT_LOOKUP, /* Lookup object */
H5VL_OBJECT_VISIT, /* H5Ovisit(_by_name) */
H5VL_OBJECT_FLUSH, /* H5{D|G|O|T}flush */
H5VL_OBJECT_REFRESH /* H5{D|G|O|T}refresh */
} H5VL_object_specific_t;
/* Parameters for object 'visit' operation */
typedef struct H5VL_object_visit_args_t {
H5_index_t idx_type; /* Type of index to iterate over */
H5_iter_order_t order; /* Order of index iteration */
unsigned fields; /* Flags for fields to provide in 'info' object for 'op' callback */
H5O_iterate2_t op; /* Iteration callback function */
void *op_data; /* Iteration callback context */
} H5VL_object_visit_args_t;
/* Parameters for object 'specific' operations */
typedef struct H5VL_object_specific_args_t {
H5VL_object_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_OBJECT_CHANGE_REF_COUNT */
struct {
int delta; /* Amount to modify object's refcount */
} change_rc;
/* H5VL_OBJECT_EXISTS */
struct {
bool *exists; /* Whether object exists (OUT) */
} exists;
/* H5VL_OBJECT_LOOKUP */
struct {
H5O_token_t *token_ptr; /* Pointer to token for lookup (OUT) */
} lookup;
/* H5VL_OBJECT_VISIT */
H5VL_object_visit_args_t visit;
/* H5VL_OBJECT_FLUSH */
struct {
hid_t obj_id; /* Object ID (IN) */
} flush;
/* H5VL_OBJECT_REFRESH */
struct {
hid_t obj_id; /* Object ID (IN) */
} refresh;
} args;
} H5VL_object_specific_args_t;
H5O_iterate2_t
herr_t(* H5O_iterate2_t)(hid_t obj, const char *name, const H5O_info2_t *info, void *op_data)
Definition H5Opublic.h:195
H5VL_object_specific_t
H5VL_object_specific_t
Definition H5VLconnector.h:715
H5VL_OBJECT_EXISTS
@ H5VL_OBJECT_EXISTS
Definition H5VLconnector.h:717
H5VL_OBJECT_CHANGE_REF_COUNT
@ H5VL_OBJECT_CHANGE_REF_COUNT
Definition H5VLconnector.h:716
H5VL_OBJECT_LOOKUP
@ H5VL_OBJECT_LOOKUP
Definition H5VLconnector.h:718
H5VL_OBJECT_VISIT
@ H5VL_OBJECT_VISIT
Definition H5VLconnector.h:719
H5VL_OBJECT_FLUSH
@ H5VL_OBJECT_FLUSH
Definition H5VLconnector.h:720
H5VL_OBJECT_REFRESH
@ H5VL_OBJECT_REFRESH
Definition H5VLconnector.h:721
H5VL_object_specific_args_t::visit
H5VL_object_visit_args_t visit
Definition H5VLconnector.h:755
H5VL_object_specific_args_t::delta
int delta
Definition H5VLconnector.h:741
H5VL_object_specific_args_t::op_type
H5VL_object_specific_t op_type
Definition H5VLconnector.h:735
H5VL_object_specific_args_t::change_rc
struct H5VL_object_specific_args_t::@367057131301240221347263176354375362051322354251::@243231100274041020304122177222060150016251265254 change_rc
H5VL_object_specific_args_t::lookup
struct H5VL_object_specific_args_t::@367057131301240221347263176354375362051322354251::@132116352151033157344037206363347145151257102360 lookup
H5VL_object_specific_args_t::refresh
struct H5VL_object_specific_args_t::@367057131301240221347263176354375362051322354251::@316235325166361056043036123027027125045361321214 refresh
H5VL_object_specific_args_t::obj_id
hid_t obj_id
Definition H5VLconnector.h:759
H5VL_object_specific_args_t::exists
bool * exists
Definition H5VLconnector.h:746
H5VL_object_specific_args_t::flush
struct H5VL_object_specific_args_t::@367057131301240221347263176354375362051322354251::@323030252212253042047170143162311170344017306267 flush
H5VL_object_specific_args_t::args
union H5VL_object_specific_args_t::@367057131301240221347263176354375362051322354251 args
H5VL_object_specific_args_t::token_ptr
H5O_token_t * token_ptr
Definition H5VLconnector.h:751
H5VL_object_visit_args_t
Definition H5VLconnector.h:725
H5VL_object_visit_args_t::idx_type
H5_index_t idx_type
Definition H5VLconnector.h:726
H5VL_object_visit_args_t::op
H5O_iterate2_t op
Definition H5VLconnector.h:729
H5VL_object_visit_args_t::fields
unsigned fields
Definition H5VLconnector.h:728
H5VL_object_visit_args_t::op_data
void * op_data
Definition H5VLconnector.h:730
H5VL_object_visit_args_t::order
H5_iter_order_t order
Definition H5VLconnector.h:727

### object: optional

The optional callback in the object class implements connector specific operations on an HDF5 object. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, const H5VL_loc_params_t *loc_params, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): A container or object where he operation needs to happen. loc_params (IN): Pointer to the location parameters for the destination object as explained in "Mapping the API to the Callbacks". args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

## Introspection Callbacks

Structure for VOL connector introspection callback routines, H5VLconnector.h

typedef struct H5VL_introspect_class_t {
herr_t (*get_conn_cls)(void *obj, H5VL_get_conn_lvl_t lvl, const struct H5VL_class_t **conn_cls);
herr_t (*get_cap_flags)(const void *info, uint64_t *cap_flags);
herr_t (*opt_query)(void *obj, H5VL_subclass_t cls, int opt_type, uint64_t *flags);
} H5VL_introspect_class_t;
H5VL_get_conn_lvl_t
H5VL_get_conn_lvl_t
Definition H5VLconnector.h:973
H5VL_introspect_class_t
Definition H5VLconnector.h:984
H5VL_introspect_class_t::get_conn_cls
herr_t(* get_conn_cls)(void *obj, H5VL_get_conn_lvl_t lvl, const struct H5VL_class_t **conn_cls)
Definition H5VLconnector.h:985
H5VL_introspect_class_t::get_cap_flags
herr_t(* get_cap_flags)(const void *info, uint64_t *cap_flags)
Definition H5VLconnector.h:986
H5VL_introspect_class_t::opt_query
herr_t(* opt_query)(void *obj, H5VL_subclass_t cls, int opt_type, uint64_t *flags)
Definition H5VLconnector.h:987

### introspect: get_conn_cls

Get a connector's H5VL_class_t struct.

Signature:
herr_t (*get_conn_cls)(void *obj, H5VL_get_conn_lvl_t lvl, const struct H5VL_class_t **conn_cls);
Arguments:
obj (IN): The VOL object. lvl (IN): Current or terminal connector. cls (OUT): A const pointer to the connector.

The "lvl" argument is an enum:

/* "Levels" for 'get connector class' introspection callback */
typedef enum H5VL_get_conn_lvl_t {
H5VL_GET_CONN_LVL_CURR, /* Get "current" connector (for this object) */
H5VL_GET_CONN_LVL_TERM /* Get "terminal" connector (for this object) */
/* (Recursively called, for pass-through connectors) */
/* (Connectors that "split" must choose which connector to return) */
} H5VL_get_conn_lvl_t;
H5VL_GET_CONN_LVL_TERM
@ H5VL_GET_CONN_LVL_TERM
Definition H5VLconnector.h:975
H5VL_GET_CONN_LVL_CURR
@ H5VL_GET_CONN_LVL_CURR
Definition H5VLconnector.h:974

### introspect: get_cap_flags

Get a connector's capability flags.

Signature:
herr_t (*get_cap_flags)(const void *info, unsigned *cap_flags) H5VL_class_t::cap_flags uint64_t cap_flags Definition H5VLconnector.h:1026
Arguments:
info (IN): A const pointer to pertinent VOL info. cap_flags (OUT): A pointer to capability flags.

### introspect: opt_query

Query a class for a capability or functionality.

Signature:
herr_t (*opt_query)(void *obj, H5VL_subclass_t cls, int opt_type, bool *supported);
Arguments:
obj (IN): The VOL object. cls (IN): The VOL 'class' to query. opt_type (IN): The specific option to query. supported (OUT): Whether the operation is supported or not.

The "cls" argument is an enum:

// Enum type for each VOL subclass
// (Used for various queries, etc)
typedef enum H5VL_subclass_t {
H5VL_SUBCLS_NONE, // Operations outside of a subclass
H5VL_SUBCLS_INFO, // 'Info' subclass
H5VL_SUBCLS_WRAP, // 'Wrap' subclass
H5VL_SUBCLS_ATTR, // 'Attribute' subclass
H5VL_SUBCLS_DATASET, // 'Dataset' subclass
H5VL_SUBCLS_DATATYPE, // 'Named datatype' subclass
H5VL_SUBCLS_FILE, // 'File' subclass
H5VL_SUBCLS_GROUP, // 'Group' subclass
H5VL_SUBCLS_LINK, // 'Link' subclass
H5VL_SUBCLS_OBJECT, // 'Object' subclass
H5VL_SUBCLS_REQUEST, // 'Request' subclass
H5VL_SUBCLS_BLOB, // 'Blob' subclass
H5VL_SUBCLS_TOKEN // 'Token' subclass
} H5VL_subclass_t;
H5VL_SUBCLS_TOKEN
@ H5VL_SUBCLS_TOKEN
Definition H5VLpublic.h:196
H5VL_SUBCLS_INFO
@ H5VL_SUBCLS_INFO
Definition H5VLpublic.h:185
H5VL_SUBCLS_LINK
@ H5VL_SUBCLS_LINK
Definition H5VLpublic.h:192
H5VL_SUBCLS_DATATYPE
@ H5VL_SUBCLS_DATATYPE
Definition H5VLpublic.h:189
H5VL_SUBCLS_OBJECT
@ H5VL_SUBCLS_OBJECT
Definition H5VLpublic.h:193
H5VL_SUBCLS_WRAP
@ H5VL_SUBCLS_WRAP
Definition H5VLpublic.h:186
H5VL_SUBCLS_FILE
@ H5VL_SUBCLS_FILE
Definition H5VLpublic.h:190
H5VL_SUBCLS_NONE
@ H5VL_SUBCLS_NONE
Definition H5VLpublic.h:184
H5VL_SUBCLS_ATTR
@ H5VL_SUBCLS_ATTR
Definition H5VLpublic.h:187
H5VL_SUBCLS_DATASET
@ H5VL_SUBCLS_DATASET
Definition H5VLpublic.h:188
H5VL_SUBCLS_REQUEST
@ H5VL_SUBCLS_REQUEST
Definition H5VLpublic.h:194
H5VL_SUBCLS_GROUP
@ H5VL_SUBCLS_GROUP
Definition H5VLpublic.h:191
H5VL_SUBCLS_BLOB
@ H5VL_SUBCLS_BLOB
Definition H5VLpublic.h:195

## Request (Async) Callbacks

Structure for async request callback routines, H5VLconnector.h

typedef struct H5VL_request_class_t {
herr_t (*wait)(void *req, uint64_t timeout, H5VL_request_status_t *status);
herr_t (*notify)(void *req, H5VL_request_notify_t cb, void *ctx);
herr_t (*cancel)(void *req, H5VL_request_status_t *status);
herr_t (*specific)(void *req, H5VL_request_specific_args_t *args);
herr_t (*optional)(void *req, H5VL_optional_args_t *args);
herr_t (*free)(void *req);
} H5VL_request_class_t;
H5VL_request_notify_t
herr_t(* H5VL_request_notify_t)(void *ctx, H5VL_request_status_t status)
Definition H5VLconnector.h:970
H5VL_request_status_t
H5VL_request_status_t
Definition H5VLconnector.h:773
H5VL_request_class_t
Definition H5VLconnector.h:991
H5VL_request_class_t::notify
herr_t(* notify)(void *req, H5VL_request_notify_t cb, void *ctx)
Definition H5VLconnector.h:993
H5VL_request_class_t::wait
herr_t(* wait)(void *req, uint64_t timeout, H5VL_request_status_t *status)
Definition H5VLconnector.h:992
H5VL_request_class_t::specific
herr_t(* specific)(void *req, H5VL_request_specific_args_t *args)
Definition H5VLconnector.h:995
H5VL_request_class_t::free
herr_t(* free)(void *req)
Definition H5VLconnector.h:997
H5VL_request_class_t::cancel
herr_t(* cancel)(void *req, H5VL_request_status_t *status)
Definition H5VLconnector.h:994
H5VL_request_class_t::optional
herr_t(* optional)(void *req, H5VL_optional_args_t *args)
Definition H5VLconnector.h:996
H5VL_request_specific_args_t
Definition H5VLconnector.h:792

### request: wait

Wait (with a timeout) for an async operation to complete. Releases the request if the operation has completed and the connector callback succeeds.

Signature:
herr_t (*wait)(void *req, uint64_t timeout, H5VL_request_status_t *status);
Arguments:
req (IN): The async request on which to wait. timeout (IN): The timeout value. status (IN): The status.

The "status" argument is an enum:

/* Status values for async request operations */
typedef enum H5VL_request_status_t {
H5VL_REQUEST_STATUS_IN_PROGRESS, /* Operation has not yet completed */
H5VL_REQUEST_STATUS_SUCCEED, /* Operation has completed, successfully */
H5VL_REQUEST_STATUS_FAIL, /* Operation has completed, but failed */
H5VL_REQUEST_STATUS_CANT_CANCEL, /* An attempt to cancel this operation was made, but it */
/* can't be canceled immediately. The operation has */
/* not completed successfully or failed, and is not yet */
/* in progress. Another attempt to cancel it may be */
/* attempted and may (or may not) succeed. */
H5VL_REQUEST_STATUS_CANCELED /* Operation has not completed and was canceled */
} H5VL_request_status_t;
H5VL_REQUEST_STATUS_SUCCEED
@ H5VL_REQUEST_STATUS_SUCCEED
Definition H5VLconnector.h:775
H5VL_REQUEST_STATUS_CANT_CANCEL
@ H5VL_REQUEST_STATUS_CANT_CANCEL
Definition H5VLconnector.h:777
H5VL_REQUEST_STATUS_CANCELED
@ H5VL_REQUEST_STATUS_CANCELED
Definition H5VLconnector.h:782
H5VL_REQUEST_STATUS_FAIL
@ H5VL_REQUEST_STATUS_FAIL
Definition H5VLconnector.h:776
H5VL_REQUEST_STATUS_IN_PROGRESS
@ H5VL_REQUEST_STATUS_IN_PROGRESS
Definition H5VLconnector.h:774

### request: notify

Registers a user callback to be invoked when an asynchronous operation completes. Releases the request if connector callback succeeds.

Signature:
herr_t (*notify)(void *req, H5VL_request_notify_t cb, void *ctx);
Arguments:
req (IN): The async request that will receive the notify callback. cb (IN): The notify callback for the request. ctx (IN): The request's context.

The "cb" argument is an enum:

typedef herr_t (*H5VL_request_notify_t)(void *ctx, H5ES_status_t status)
H5ES_status_t
H5ES_status_t
Definition H5ESpublic.h:51

### request: cancel

Signature:
herr_t (*cancel)(void *req, H5VL_request_status_t *status);
Arguments:
req (IN): The async request to be cancelled. status (IN): The status.

The "status" argument is an enum:

/* Status values for async request operations */
typedef enum H5VL_request_status_t {
H5VL_REQUEST_STATUS_IN_PROGRESS, /* Operation has not yet completed */
H5VL_REQUEST_STATUS_SUCCEED, /* Operation has completed, successfully */
H5VL_REQUEST_STATUS_FAIL, /* Operation has completed, but failed */
H5VL_REQUEST_STATUS_CANT_CANCEL, /* An attempt to cancel this operation was made, but it */
/* can't be canceled immediately. The operation has */
/* not completed successfully or failed, and is not yet */
/* in progress. Another attempt to cancel it may be */
/* attempted and may (or may not) succeed. */
H5VL_REQUEST_STATUS_CANCELED /* Operation has not completed and was canceled */
} H5VL_request_status_t;

### request: specific

Perform a specific operation on an asynchronous request.

Signature:
herr_t (*specific)(void *req, H5VL_request_specific_args_t *args);
Arguments:
req (IN): The async request on which to perform the operation. args (IN/OUT): A pointer to the arguments struct.

/* Values for async request 'specific' operation */
typedef enum H5VL_request_specific_t {
H5VL_REQUEST_GET_ERR_STACK, /* Retrieve error stack for failed operation */
H5VL_REQUEST_GET_EXEC_TIME /* Retrieve execution time for operation */
} H5VL_request_specific_t;
/* Parameters for request 'specific' operations */
typedef struct H5VL_request_specific_args_t {
H5VL_request_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_REQUEST_GET_ERR_STACK */
struct {
hid_t err_stack_id; /* Error stack ID for operation (OUT) */
} get_err_stack;
/* H5VL_REQUEST_GET_EXEC_TIME */
struct {
uint64_t *exec_ts; /* Timestamp for start of task execution (OUT) */
uint64_t *exec_time; /* Duration of task execution (in ns) (OUT) */
} get_exec_time;
} args;
} H5VL_request_specific_args_t;
H5VL_request_specific_t
H5VL_request_specific_t
Definition H5VLconnector.h:786
H5VL_REQUEST_GET_ERR_STACK
@ H5VL_REQUEST_GET_ERR_STACK
Definition H5VLconnector.h:787
H5VL_REQUEST_GET_EXEC_TIME
@ H5VL_REQUEST_GET_EXEC_TIME
Definition H5VLconnector.h:788
H5VL_request_specific_args_t::args
union H5VL_request_specific_args_t::@001316000106006326263370212102314303306103140342 args
H5VL_request_specific_args_t::exec_ts
uint64_t * exec_ts
Definition H5VLconnector.h:804
H5VL_request_specific_args_t::get_exec_time
struct H5VL_request_specific_args_t::@001316000106006326263370212102314303306103140342::@041335317214072146141141224222305140242063042067 get_exec_time
H5VL_request_specific_args_t::err_stack_id
hid_t err_stack_id
Definition H5VLconnector.h:799
H5VL_request_specific_args_t::exec_time
uint64_t * exec_time
Definition H5VLconnector.h:805
H5VL_request_specific_args_t::op_type
H5VL_request_specific_t op_type
Definition H5VLconnector.h:793
H5VL_request_specific_args_t::get_err_stack
struct H5VL_request_specific_args_t::@001316000106006326263370212102314303306103140342::@165015246060323300365012332125246340142251334111 get_err_stack

### request: optional

Perform a connector-specific operation for a request.

Signature:
herr_t (*optional)(void *req, H5VL_optional_args_t *args);
Arguments:
req (IN): The async request on which to perform the operation. args (IN/OUT): A pointer to the arguments struct.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct.

### request: free

Frees an asynchronous request.

Signature:
herr_t (*free)(void *req);
Arguments:
req (IN): The async request to be freed.

## Blob Callbacks

Structure for blob callback routines, H5VLconnector.h

typedef struct H5VL_blob_class_t {
herr_t (*put)(void *obj, const void *buf, size_t size, void *blob_id, void *ctx);
herr_t (*get)(void *obj, const void *blob_id, void *buf, size_t size, void *ctx);
herr_t (*specific)(void *obj, void *blob_id, H5VL_blob_specific_args_t *args);
herr_t (*optional)(void *obj, void *blob_id, H5VL_optional_args_t *args);
} H5VL_blob_class_t;
H5VL_blob_class_t
Definition H5VLconnector.h:1001
H5VL_blob_class_t::put
herr_t(* put)(void *obj, const void *buf, size_t size, void *blob_id, void *ctx)
Definition H5VLconnector.h:1002
H5VL_blob_class_t::specific
herr_t(* specific)(void *obj, void *blob_id, H5VL_blob_specific_args_t *args)
Definition H5VLconnector.h:1004
H5VL_blob_class_t::optional
herr_t(* optional)(void *obj, void *blob_id, H5VL_optional_args_t *args)
Definition H5VLconnector.h:1005
H5VL_blob_class_t::get
herr_t(* get)(void *obj, const void *blob_id, void *buf, size_t size, void *ctx)
Definition H5VLconnector.h:1003
H5VL_blob_specific_args_t
Definition H5VLconnector.h:822

### blob: put

Put a blob through the VOL.

Signature:
herr_t (*put)(void *obj, const void *buf, size_t size, void *blob_id, void *ctx);
Arguments:
obj (IN): Pointer to the blob container. buf (IN): Pointer to the blob. size (IN): Size of the blob. blob_id (OUT): Pointer to the blob's connector-specific ID. ctx (IN): Connector-specific blob context.

### blob: get

Get a blob through the VOL.

Signature:
herr_t (*get)(void *obj, const void *blob_id, void *buf, size_t size, void *ctx);
Arguments:
obj (IN): Pointer to the blob container. blob_id (IN): Pointer to the blob's connector-specific ID. buf (IN/OUT): Pointer to the blob. size (IN): Size of the blob. ctx (IN): Connector-specific blob context.

### blob: specific

Perform a defined operation on a blob via the VOL.

Signature:
herr_t (*specific)(void *obj, void *blob_id, H5VL_blob_specific_args_t *args);
Arguments:
obj (IN): Pointer to the blob container. blob_id (IN): Pointer to the blob's connector-specific ID. args (IN/OUT): A pointer to the arguments struct.

/* Values for 'blob' 'specific' operation */
typedef enum H5VL_blob_specific_t {
H5VL_BLOB_DELETE, /* Delete a blob (by ID) */
H5VL_BLOB_ISNULL, /* Check if a blob ID is "null" */
H5VL_BLOB_SETNULL /* Set a blob ID to the connector's "null" blob ID value */
} H5VL_blob_specific_t;
/* Parameters for blob 'specific' operations */
typedef struct H5VL_blob_specific_args_t {
H5VL_blob_specific_t op_type; /* Operation to perform */
/* Parameters for each operation */
union {
/* H5VL_BLOB_DELETE */
/* No args */
/* H5VL_BLOB_ISNULL */
struct {
bool *isnull; /* Whether blob ID is "null" (OUT) */
} is_null;
/* H5VL_BLOB_SETNULL */
/* No args */
} args;
} H5VL_blob_specific_args_t;
H5VL_blob_specific_t
H5VL_blob_specific_t
Definition H5VLconnector.h:815
H5VL_BLOB_ISNULL
@ H5VL_BLOB_ISNULL
Definition H5VLconnector.h:817
H5VL_BLOB_SETNULL
@ H5VL_BLOB_SETNULL
Definition H5VLconnector.h:818
H5VL_BLOB_DELETE
@ H5VL_BLOB_DELETE
Definition H5VLconnector.h:816
H5VL_blob_specific_args_t::isnull
bool * isnull
Definition H5VLconnector.h:832
H5VL_blob_specific_args_t::op_type
H5VL_blob_specific_t op_type
Definition H5VLconnector.h:823
H5VL_blob_specific_args_t::is_null
struct H5VL_blob_specific_args_t::@131305020060203175140171235213000033064064140250::@346126041062122026244106230345351003030056115247 is_null
H5VL_blob_specific_args_t::args
union H5VL_blob_specific_args_t::@131305020060203175140171235213000033064064140250 args

### blob: optional

Perform a connector-specific operation on a blob via the VOL

Signature:
herr_t (*optional)(void *obj, void *blob_id, H5VL_optional_args_t *args);
Arguments:
obj (IN): Pointer to the blob container. blob_id (IN): Pointer to the blob's connector-specific ID. args (IN/OUT): A pointer to the arguments struct.

Each connector that requires connector-specific operations should compare the value of the op_type field of the H5VL_optional_args_t struct with the values returned from calling H5VLregister_opt_operation to determine how to handle the optional call and interpret the arguments passed in the struct

## Token Callbacks

Structure for token callback routines, H5VLconnector.h

typedef struct H5VL_token_class_t {
herr_t (*cmp)(void *obj, const H5O_token_t *token1, const H5O_token_t *token2, int *cmp_value);
herr_t (*to_str)(void *obj, H5I_type_t obj_type, const H5O_token_t *token, char **token_str);
herr_t (*from_str)(void *obj, H5I_type_t obj_type, const char *token_str, H5O_token_t *token);
} H5VL_token_class_t;
H5O_token_t
Definition H5public.h:437
H5VL_token_class_t
Definition H5VLconnector.h:1009
H5VL_token_class_t::to_str
herr_t(* to_str)(void *obj, H5I_type_t obj_type, const H5O_token_t *token, char **token_str)
Definition H5VLconnector.h:1011
H5VL_token_class_t::from_str
herr_t(* from_str)(void *obj, H5I_type_t obj_type, const char *token_str, H5O_token_t *token)
Definition H5VLconnector.h:1012
H5VL_token_class_t::cmp
herr_t(* cmp)(void *obj, const H5O_token_t *token1, const H5O_token_t *token2, int *cmp_value)
Definition H5VLconnector.h:1010

### token: cmp

Compares two tokens and outputs a value like strcmp.

Signature:
herr_t (*cmp)(void *obj, const H5O_token_t *token1, const H5O_token_t *token2, int *cmp_value);
Arguments:
obj (IN): The underlying VOL object. token1 (IN): The first token to compare. token2 (IN): The second token to compare. cmp_value (OUT): A value like strcmp.

### token: to_str

Converts a token to a string representation.

Signature:
herr_t (*to_str)(void *obj, H5I_type_t obj_type, const H5O_token_t *token, char **token_str)
Arguments:
obj (IN): The underlying VOL object. obj_type (IN): The type of the object. token (IN): The token to turn into a string representation. token_str (OUT): The string representation of the token.

The "obj_type" argument is an enum: (from H5Ipublic.h)

typedef enum H5I_type_t {
H5I_UNINIT = (-2),
H5I_BADID = (-1),
H5I_FILE = 1,
H5I_GROUP,
H5I_DATATYPE,
H5I_DATASPACE,
H5I_DATASET,
H5I_MAP,
H5I_ATTR,
H5I_VFL,
H5I_VOL,
H5I_GENPROP_CLS,
H5I_GENPROP_LST,
H5I_ERROR_CLASS,
H5I_ERROR_MSG,
H5I_ERROR_STACK,
H5I_SPACE_SEL_ITER,
H5I_EVENTSET,
H5I_NTYPES
} H5I_type_t;

The only values which should be used for this call are:

- H5I_GROUP
- H5I_DATATYPE
- H5I_DATASET
- H5I_MAP

as these are the only objects for which tokens are valid.

### token: from_str

Converts a string representation of a token to a token.

Signature:
herr_t (*from_str)(void *obj, H5I_type_t obj_type, const char *token_str, H5O_token_t *token);
Arguments:
obj (IN): The underlying VOL object. obj_type (IN): The type of the object. token_str (IN): The string representation of the token. token (OUT): The token reated from the string representation.

The "obj_type" argument is an enum: (from H5Ipublic.h)

typedef enum H5I_type_t {
H5I_UNINIT = (-2),
H5I_BADID = (-1),
H5I_FILE = 1,
H5I_GROUP,
H5I_DATATYPE,
H5I_DATASPACE,
H5I_DATASET,
H5I_MAP,
H5I_ATTR,
H5I_VFL,
H5I_VOL,
H5I_GENPROP_CLS,
H5I_GENPROP_LST,
H5I_ERROR_CLASS,
H5I_ERROR_MSG,
H5I_ERROR_STACK,
H5I_SPACE_SEL_ITER,
H5I_EVENTSET,
H5I_NTYPES
} H5I_type_t;

The only values which should be used for this call are:

- H5I_GROUP
- H5I_DATATYPE
- H5I_DATASET
- H5I_MAP

as these are the only objects for which tokens are valid.

## Optional Generic Callback

A generic optional callback is provided for services that are specific to a connector. The optional callback has the following definition. It returns an herr_t indicating success or failure.

Signature:
herr_t (*optional)(void *obj, H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
Arguments:
obj (IN): A container or object where he operation needs to happen. args (IN/OUT): A pointer to the arguments struct. dxpl_id (IN): The data transfer property list. req IN/OUT): A pointer to the asynchronous request of the operation created by the connector.

# New VOL API Routines

API routines have been added to the HDF5 library to manage VOL connectors. This section details each new API call and explains its intended usage. Additionally, a set of API calls that map directly to the VOL callbacks themselves have been added to aid in the development of passthrough connectors which can be stacked and/or split. A list of these API calls is given in an appendix.

## H5VLpublic.h

The API calls in this header are for VOL management and general use (i.e., not limited to VOL connector authors).

### H5VLregister_connector_by_name

Signature:
hid_t H5VLregister_connector_by_name(const char *connector_name, hid_t vipl_id); H5VLregister_connector_by_name hid_t H5VLregister_connector_by_name(const char *connector_name, hid_t vipl_id) Registers a new VOL connector by name.
Arguments:
connector_name (IN): The connector name to search for and register. vipl_id (IN): An ID for a VOL initialization property list (vipl).

Registers a VOL connector with the HDF5 library given the name of the connector and returns an identifier for it (H5I_INVALID_HID on errors). If the connector is already registered, the library will create a new identifier for it and returns it to the user; otherwise the library will search the plugin path for a connector of that name, loading and registering it, returning an ID for it, if found. See the HDF5 Virtual Object Layer (VOL) for more information on loading plugins and the search paths.

### H5VLregister_connector_by_value

Signature:
hid_t H5VLregister_connector_by_value(H5VL_class_value_t connector_value, hid_t vipl_id); H5VL_class_value_t int H5VL_class_value_t VOL connector identifiers. Definition H5VLpublic.h:175 H5VLregister_connector_by_value hid_t H5VLregister_connector_by_value(H5VL_class_value_t connector_value, hid_t vipl_id) Registers a new VOL connector by value.
Arguments:
connector_value (IN): The connector value to search for and register. vipl_id (IN): An ID for a VOL initialization property list (vipl).

Registers a VOL connector with the HDF5 library given a value for the connector and returns an identifier for it (H5I_INVALID_HID on errors). If the connector is already registered, the library will create a new identifier for it and returns it to the user; otherwise the library will search the plugin path for a connector of that name, loading and registering it, returning an ID for it, if found. See the VOL User Guide for more information on loading plugins and the search paths.

### H5VLis_connector_registered_by_name

Signature:
htri_t H5VLis_connector_registered_by_name(const char *name); htri_t int htri_t Definition H5public.h:282 H5VLis_connector_registered_by_name htri_t H5VLis_connector_registered_by_name(const char *name) Tests whether a VOL class has been registered under a certain name.
Arguments:
name (IN): The connector name to check for.

Checks if a VOL connector is registered with the library given the connector name and returns TRUE/FALSE on success, otherwise it returns a negative value.

### H5VLis_connector_registered_by_value

Signature:
htri_t H5VLis_connector_registered_by_value(H5VL_class_value_t connector_value); H5VLis_connector_registered_by_value htri_t H5VLis_connector_registered_by_value(H5VL_class_value_t connector_value) Tests whether a VOL class has been registered for a given value.
Arguments:
connector_value (IN): The connector value to check for.

Checks if a VOL connector is registered with the library given the connector value and returns TRUE/FALSE on success, otherwise it returns a negative value.

### H5VLget_connector_id

Signature:
hid_t H5VLget_connector_id(hid_t obj_id); H5VLget_connector_id hid_t H5VLget_connector_id(hid_t obj_id) Retrieves the VOL connector identifier for a given object identifier.
Arguments:
obj_id (IN): An ID for an HDF5 VOL object.

Given a VOL object such as a dataset or an attribute, this function returns an identifier for its associated connector. If the ID is not a VOL object (such as a dataspace or uncommitted datatype), H5I_INVALID_HID is returned. The identifier must be released with a call to H5VLclose.

### H5VLget_connector_id_by_name

Signature:
hid_t H5VLget_connector_id_by_name(const char *name); H5VLget_connector_id_by_name hid_t H5VLget_connector_id_by_name(const char *name) Retrieves the identifier for a registered VOL connector name.
Arguments:
name (IN): The connector name to check for.

Given a connector name that is registered with the library, this function returns an identifier for the connector. If the connector is not registered with the library, H5I_INVALID_HID is returned.The identifier must be released with a call to H5VLclose.

### H5VLget_connector_id_by_value

Signature:
hid_t H5VLget_connector_id_by_value(H5VL_class_value_t connector_value); H5VLget_connector_id_by_value hid_t H5VLget_connector_id_by_value(H5VL_class_value_t connector_value) Retrieves the identifier for a registered VOL connector value.
Arguments:
connector_value (IN): The connector value to check for.

Given a connector value that is registered with the library, this function returns an identifier for the connector. If the connector is not registered with the library, H5I_INVALID_HID is returned.The identifier must be released with a call to H5VLclose.

### H5VLget_connector_name

Signature:
ssize_t H5VLget_connector_name(hid_t id, char *name /*out*/, size_t size); H5VLget_connector_name ssize_t H5VLget_connector_name(hid_t id, char *name, size_t size) Retrieves a connector name for a VOL.
Arguments:
id (IN): The object identifier to check. name (OUT): Buffer pointer to put the connector name. If NULL, the library just returns thesize required to store the connector name. size (IN): the size of the passed in buffer.

Retrieves the name of a VOL connector given an object identifier that was created/opened ith it. On success, the name length is returned.

### H5VLclose

Signature:
herr_t H5VLclose(hid_t connector_id); H5VLclose herr_t H5VLclose(hid_t connector_id) Closes a VOL connector identifier.
Arguments:
connector_id (IN): A valid identifier of the connector to close.

Shuts down access to the connector that the identifier points to and release resources associated with it.

### H5VLunregister_connector

Signature:
herr_t H5VLunregister_connector(hid_t connector_id); H5VLunregister_connector herr_t H5VLunregister_connector(hid_t connector_id) Removes a VOL connector identifier from the library.
Arguments:
connector_id (IN): A valid identifier of the connector to unregister.

Unregisters a connector from the library and return a positive value on success otherwise return a negative value. The native VOL connector cannot be unregistered (this will return a negative herr_t value).

### H5VLquery_optional

Signature:
herr_t H5VLquery_optional(hid_t obj_id, H5VL_subclass_t subcls, int opt_type, uint64_t *flags); H5VLquery_optional herr_t H5VLquery_optional(hid_t obj_id, H5VL_subclass_t subcls, int opt_type, uint64_t *flags) Determine if a VOL connector supports a particular optional callback operation.
Arguments:
obj_id (IN): A valid identifier of a VOL-managed object. subcls (IN): The subclass of the optional operation. opt_type (IN): The optional operation. The native VOL connector uses hard-coded values. Other VOL connectors get this value when the optional operations are registered. flags (OUT): Bitwise flags indicating support and behavior.

Determines if a connector or connector stack (determined from the passed-in object) supports an optional operation. The returned flags (listed below) not only indicate whether the operation is supported or not, but also give a sense of the option's behavior (useful for pass-through connectors).

Bitwise query flag values:

#define H5VL_OPT_QUERY_SUPPORTED 0x0001 /* VOL connector supports this operation */
#define H5VL_OPT_QUERY_READ_DATA 0x0002 /* Operation reads data for object */
#define H5VL_OPT_QUERY_WRITE_DATA 0x0004 /* Operation writes data for object */
#define H5VL_OPT_QUERY_QUERY_METADATA 0x0008 /* Operation reads metadata for object */
#define H5VL_OPT_QUERY_MODIFY_METADATA 0x0010 /* Operation modifies metadata for object */
#define H5VL_OPT_QUERY_COLLECTIVE 0x0020 /* Operation is collective (operations without this flag are assumed to be independent) */
#define H5VL_OPT_QUERY_NO_ASYNC 0x0040 /* Operation may NOT be executed asynchronously */
#define H5VL_OPT_QUERY_MULTI_OBJ 0x0080 /* Operation involves multiple objects */

## H5VLconnector.h

This functionality is intended for VOL connector authors and includes helper functions that are useful for writing connectors.

API calls to manage optional operations are also found in this header file. These are discussed in the section on optional operations, above.

### H5VLregister_connector

Signature:
hid_t H5VLregister_connector(const H5VL_class_t *cls, hid_t vipl_id); H5VLregister_connector hid_t H5VLregister_connector(const H5VL_class_t *cls, hid_t vipl_id) Registers a new VOL connector.
Arguments:
cls (IN): A pointer to the connector structure to register. vipl_id (IN): An ID for a VOL initialization property list (vipl).

Registers a user-defined VOL connector with the HDF5 library and returns an identifier for that connector (H5I_INVALID_HID on errors). This function is used when the application has direct access to the connector it wants to use and is able to obtain a pointer for the connector structure to pass to the HDF5 library.

### H5VLobject

Signature:
void *H5VLobject(hid_t obj_id); H5VLobject void * H5VLobject(hid_t obj_id)
Arguments:
obj_id (IN): identifier of the object to dereference.

Retrieves a pointer to the VOL object from an HDF5 file or object identifier.

### H5VLget_file_type

Signature:
hid_t H5VLget_file_type(void *file_obj, hid_t connector_id, hid_t dtype_id); H5VLget_file_type hid_t H5VLget_file_type(void *file_obj, hid_t connector_id, hid_t dtype_id)
Arguments:
file_obj (IN): pointer to a file or file object's connector-specific data. connector_id (IN): A valid identifier of the connector to use. dtype_id (IN): A valid identifier for the type.

Returns a copy of the dtype_id parameter but with the location set to be in the file. Returns a negative value (H5I_INVALID_HID) on errors.

## H5VLconnector_passthru.h

This functionality is intended for VOL connector authors who are writing pass-through connectors and includes helper functions that are useful for writing such connectors. Callback equivalent functions can be found in this header as well. A list of these functions is included as an appendix to this document.

### H5VLcmp_connector_cls

Signature:
herr_t H5VLcmp_connector_cls(int *cmp, hid_t connector_id1, hid_t connector_id2); H5VLcmp_connector_cls herr_t H5VLcmp_connector_cls(int *cmp, hid_t connector_id1, hid_t connector_id2)
Arguments:
cmp (OUT): a value like strcmp. connector_id1 (IN): the ID of the first connector to compare. connector_id2 (IN): the ID of the second connector to compare

Compares two connectors (given by the connector IDs) to see if they refer to the same connector underneath. Returns a positive value on success and a negative value on errors.

### H5VLwrap_register

Signature:
hid_t H5VLwrap_register(void *obj, H5I_type_t type); H5VLwrap_register hid_t H5VLwrap_register(void *obj, H5I_type_t type) Wrap an internal object with a "wrap context" and register an hid_t for the resulting object.
Arguments:
obj (IN): an object to wrap. type (IN): the type of the object (see below).

Wrap an internal object with a "wrap context" and register and return an hidt for the resulting object. This routine is mainly targeted toward wrapping objects for iteration routine callbacks (i.e. the callbacks from H5Aiterate*, H5Literate* / H5Lvisit*, and H5Ovisit* ). Using it in an application will return an error indicating the API context isn't available or can't be retrieved. he type must be a VOL-managed object class:

- H5I_FILE
- H5I_GROUP
- H5I_DATATYPE
- H5I_DATASET
- H5I_MAP
- H5I_ATTR

### H5VLretrieve_lib_state

Signature:
herr_t H5VLretrieve_lib_state(void **state); H5VLretrieve_lib_state herr_t H5VLretrieve_lib_state(void **state)
Arguments:
state (OUT): the library state.

Retrieves a copy of the internal state of the HDF5 library, so that it can be restored later. Returns a positive value on success and a negative value on errors.

### H5VLopen_lib_context

Signature:
herr_t H5VLopen_lib_context(void **context); H5VLopen_lib_context herr_t H5VLopen_lib_context(void **context) Opens a new internal context for the HDF5 library.

Opens a new internal context for the HDF5 library. Returns a non-negative value if `*context` is set; otherwise returns negative value if `*context` is unset.

### H5VLrestore_lib_state

Signature:
herr_t H5VLrestore_lib_state(const void *state); H5VLrestore_lib_state herr_t H5VLrestore_lib_state(const void *state)
Arguments:
state (IN): the library state.

Restores the internal state of the HDF5 library. Returns a positive value on success and a negative value on errors.

### H5VLclose_lib_context

Signature:
herr_t H5VLclose_lib_context(void *context); H5VLclose_lib_context herr_t H5VLclose_lib_context(void *context) Closes the internal state of the HDF5 library.

Closes the state of the library, undoing the effects of H5VLopen_lib_context. Returns a positive value on success and a negative value on errors.

### H5VLfree_lib_state

Signature:
herr_t H5VLfree_lib_state(void *state); H5VLfree_lib_state herr_t H5VLfree_lib_state(void *state)
Arguments:
state (IN): the library state.

Free a retrieved library state. Returns a positive value on success and a negative value on errors.

# Appendix A Mapping of VOL Callbacks to HDF5 API Calls

VOL Callback | HDF5 API Call
FILE
create | H5Fcreate
open | H5Fopen
get | H5Fget_access_plist H5Fget_create_plist H5Fget_fileno H5Fget_intent H5Fget_name H5Fget_obj_count H5Fget_obj_ids
specific | H5Fdelete H5Fflush H5Fis_accessible H5Fis_hdf5 (deprecated, hard-coded to use native connector) H5Freopen
close | H5Fclose
GROUP
create | H5Gcreate1 (deprecated) H5Gcreate2 H5Gcreate_anon
open | H5Gopen1 (deprecated) H5Gopen2
get | H5Gget_create_plist H5Gget_info H5Gget_info_by_idx H5Gget_info_by_name H5Gget_num_objs (deprecated)
specific | H5Fmount H5Funmount H5Gflush H5Grefresh
close | H5Gclose
DATASET
create | H5Dcreate1 (deprecated) H5Dcreate2
open | H5Dopen1 (deprecated) H5Dopen2
read | H5Dread
write | H5Dwrite
get | H5Dget_access_plist H5Dget_create_plist H5Dget_space H5Dget_space_status H5Dget_storage_size H5Dget_type
specific | H5Dextend (deprecated) H5Dflush H5Drefresh H5Dset_extent
close | H5Dclose
OBJECT
open | H5Oopen H5Oopen_by_addr (deprecated) H5Oopen_by_idx H5Oopen_by_token
copy | H5Ocopy
get | H5Oget_info1 (deprecated) H5Oget_info2 (deprecated) H5Oget_info3
specific | H5Odecr_refcount H5Oexists_by_name H5Oflush H5Oincr_refcount H5Orefresh H5Ovisit_by_name1 (deprecated) H5Ovisit_by_name2 (deprecated) H5Ovisit_by_name3 H5Ovisit1 (deprecated) H5Ovisit2 (deprecated) H5Ovisit3
close | H5Oclose
LINK
create | H5Glink (deprecated) H5Glink2 (deprecated) H5Lcreate_hard H5Lcreate_soft H5Lcreate_ud H5Olink
copy | H5Lcopy
move | H5Gmove (deprecated) H5Gmove2 (deprecated) H5Lmove
get | H5Gget_linkval (deprecated) H5Lget_info1 (deprecated) H5Lget_info2 H5Lget_info_by_idx H5Lget_name_by_idx H5Lget_val H5Lget_val_by_idx
specific | H5Gunlink (deprecated) H5Ldelete H5Ldelete_by_idx H5Lexists H5Literate1 (deprecated) H5Literate2 H5Literate_by_name1 (deprecated) H5Literate_by_name2 H5Lvisit1 (deprecated) H5Lvisit2 H5Lvisit_by_name1 (deprecated) H5Lvisit_by_name2
DATATYPE
commit | H5Tcommit1 (deprecated) H5Tcommit2 H5Tcommit+anon
open | H5Topen1 (deprecated) H5Topen2
get | H5Tget_create_plist
specific | H5Tflush H5Trefresh
close | H5Tclose
ATTRIBUTE
create | H5Acreate1 (deprecated) H5Acreate2 H5Acreate_by_name
open | H5Aopen H5Aopen_by_idx H5Aopen_by_name H5Aopen_idx (deprecated) H5Aopen_name (deprecated)
read | H5Aread
write | H5Awrite
get | H5Aget_create_plist H5Aget_info H5Aget_info_by_idx H5Aget_info_by_name H5Aget_name H5Aget_name_by_idx H5Aget_space H5Aget_storage_size H5Aget_type
specific | H5Adelete H5Adelete_by_idx H5Adelete_by_name H5Aexists H5Aexists_by_name H5Aiterate1 (deprecated) H5Aiterate2 H5Aiterate_by_name H5Arename H5Arename_by_name
close | H5Aclose

# Appendix B Callback Wrapper API Calls for Passthrough Connector Authors

/* Pass-through callbacks */
H5_DLL void *H5VLget_object(void *obj, hid_t connector_id);
H5_DLL herr_t H5VLget_wrap_ctx(void *obj, hid_t connector_id, void **wrap_ctx);
H5_DLL void *H5VLwrap_object(void *obj, H5I_type_t obj_type, hid_t connector_id, void *wrap_ctx);
H5_DLL void *H5VLunwrap_object(void *obj, hid_t connector_id);
H5_DLL herr_t H5VLfree_wrap_ctx(void *wrap_ctx, hid_t connector_id);
/* Public wrappers for generic callbacks */
H5_DLL herr_t H5VLinitialize(hid_t connector_id, hid_t vipl_id);
H5_DLL herr_t H5VLterminate(hid_t connector_id);
H5_DLL herr_t H5VLget_cap_flags(hid_t connector_id, uint64_t *cap_flags);
H5_DLL herr_t H5VLget_value(hid_t connector_id, H5VL_class_value_t *conn_value);
/* Public wrappers for info fields and callbacks */
H5_DLL herr_t H5VLcopy_connector_info(hid_t connector_id, void **dst_vol_info, void *src_vol_info);
H5_DLL herr_t H5VLcmp_connector_info(int *cmp, hid_t connector_id, const void *info1, const void *info2);
H5_DLL herr_t H5VLfree_connector_info(hid_t connector_id, void *vol_info);
H5_DLL herr_t H5VLconnector_info_to_str(const void *info, hid_t connector_id, char **str);
H5_DLL herr_t H5VLconnector_str_to_info(const char *str, hid_t connector_id, void **info);
/* Public wrappers for attribute callbacks */
H5_DLL void *H5VLattr_create(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *attr_name, hid_t type_id, hid_t space_id, hid_t acpl_id,
hid_t aapl_id, hid_t dxpl_id, void **req);
H5_DLL void *H5VLattr_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *name, hid_t aapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLattr_read(void *attr, hid_t connector_id, hid_t dtype_id, void *buf, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLattr_write(void *attr, hid_t connector_id, hid_t dtype_id, const void *buf, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLattr_get(void *obj, hid_t connector_id, H5VL_attr_get_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLattr_specific(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5VL_attr_specific_args_t *args, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLattr_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLattr_close(void *attr, hid_t connector_id, hid_t dxpl_id, void **req);
/* Public wrappers for dataset callbacks */
H5_DLL void *H5VLdataset_create(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *name, hid_t lcpl_id, hid_t type_id, hid_t space_id, hid_t dcpl_id,
hid_t dapl_id, hid_t dxpl_id, void **req);
H5_DLL void *H5VLdataset_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *name, hid_t dapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLdataset_read(size_t count, void *dset[], hid_t connector_id, hid_t mem_type_id[],
hid_t mem_space_id[], hid_t file_space_id[], hid_t plist_id, void *buf[],
void **req);
H5_DLL herr_t H5VLdataset_write(size_t count, void *dset[], hid_t connector_id, hid_t mem_type_id[],
hid_t mem_space_id[], hid_t file_space_id[], hid_t plist_id,
const void *buf[], void **req);
H5_DLL herr_t H5VLdataset_get(void *dset, hid_t connector_id, H5VL_dataset_get_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLdataset_specific(void *obj, hid_t connector_id, H5VL_dataset_specific_args_t *args,
hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLdataset_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLdataset_close(void *dset, hid_t connector_id, hid_t dxpl_id, void **req);
/* Public wrappers for named datatype callbacks */
H5_DLL void *H5VLdatatype_commit(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *name, hid_t type_id, hid_t lcpl_id, hid_t tcpl_id, hid_t tapl_id,
hid_t dxpl_id, void **req);
H5_DLL void *H5VLdatatype_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *name, hid_t tapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLdatatype_get(void *dt, hid_t connector_id, H5VL_datatype_get_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLdatatype_specific(void *obj, hid_t connector_id, H5VL_datatype_specific_args_t *args,
hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLdatatype_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLdatatype_close(void *dt, hid_t connector_id, hid_t dxpl_id, void **req);
/* Public wrappers for file callbacks */
H5_DLL void *H5VLfile_create(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id, hid_t dxpl_id,
void **req);
H5_DLL void *H5VLfile_open(const char *name, unsigned flags, hid_t fapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLfile_get(void *file, hid_t connector_id, H5VL_file_get_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLfile_specific(void *obj, hid_t connector_id, H5VL_file_specific_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLfile_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLfile_close(void *file, hid_t connector_id, hid_t dxpl_id, void **req);
/* Public wrappers for group callbacks */
H5_DLL void *H5VLgroup_create(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *name, hid_t lcpl_id, hid_t gcpl_id, hid_t gapl_id, hid_t dxpl_id,
void **req);
H5_DLL void *H5VLgroup_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
const char *name, hid_t gapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLgroup_get(void *obj, hid_t connector_id, H5VL_group_get_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLgroup_specific(void *obj, hid_t connector_id, H5VL_group_specific_args_t *args,
hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLgroup_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id,
void **req);
H5_DLL herr_t H5VLgroup_close(void *grp, hid_t connector_id, hid_t dxpl_id, void **req);
/* Public wrappers for link callbacks */
H5_DLL herr_t H5VLlink_create(H5VL_link_create_args_t *args, void *obj, const H5VL_loc_params_t *loc_params,
hid_t connector_id, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLlink_copy(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj,
const H5VL_loc_params_t *loc_params2, hid_t connector_id, hid_t lcpl_id,
hid_t lapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLlink_move(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj,
const H5VL_loc_params_t *loc_params2, hid_t connector_id, hid_t lcpl_id,
hid_t lapl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLlink_get(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5VL_link_get_args_t *args, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLlink_specific(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5VL_link_specific_args_t *args, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLlink_optional(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
/* Public wrappers for object callbacks */
H5_DLL void *H5VLobject_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5I_type_t *opened_type, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLobject_copy(void *src_obj, const H5VL_loc_params_t *loc_params1, const char *src_name,
void *dst_obj, const H5VL_loc_params_t *loc_params2, const char *dst_name,
hid_t connector_id, hid_t ocpypl_id, hid_t lcpl_id, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLobject_get(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5VL_object_get_args_t *args, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLobject_specific(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5VL_object_specific_args_t *args, hid_t dxpl_id, void **req);
H5_DLL herr_t H5VLobject_optional(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id,
H5VL_optional_args_t *args, hid_t dxpl_id, void **req);
/* Public wrappers for connector/container introspection callbacks */
H5_DLL herr_t H5VLintrospect_get_conn_cls(void *obj, hid_t connector_id, H5VL_get_conn_lvl_t lvl,
const H5VL_class_t **conn_cls);
H5_DLL herr_t H5VLintrospect_get_cap_flags(const void *info, hid_t connector_id, uint64_t *cap_flags);
H5_DLL herr_t H5VLintrospect_opt_query(void *obj, hid_t connector_id, H5VL_subclass_t subcls, int opt_type,
uint64_t *flags);
/* Public wrappers for asynchronous request callbacks */
H5_DLL herr_t H5VLrequest_wait(void *req, hid_t connector_id, uint64_t timeout,
H5VL_request_status_t *status);
H5_DLL herr_t H5VLrequest_notify(void *req, hid_t connector_id, H5VL_request_notify_t cb, void *ctx);
H5_DLL herr_t H5VLrequest_cancel(void *req, hid_t connector_id, H5VL_request_status_t *status);
H5_DLL herr_t H5VLrequest_specific(void *req, hid_t connector_id, H5VL_request_specific_args_t *args);
H5_DLL herr_t H5VLrequest_optional(void *req, hid_t connector_id, H5VL_optional_args_t *args);
H5_DLL herr_t H5VLrequest_free(void *req, hid_t connector_id);
/* Public wrappers for blob callbacks */
H5_DLL herr_t H5VLblob_put(void *obj, hid_t connector_id, const void *buf, size_t size, void *blob_id,
void *ctx);
H5_DLL herr_t H5VLblob_get(void *obj, hid_t connector_id, const void *blob_id, void *buf, size_t size,
void *ctx);
H5_DLL herr_t H5VLblob_specific(void *obj, hid_t connector_id, void *blob_id,
H5VL_blob_specific_args_t *args);
H5_DLL herr_t H5VLblob_optional(void *obj, hid_t connector_id, void *blob_id, H5VL_optional_args_t *args);
/* Public wrappers for token callbacks */
H5_DLL herr_t H5VLtoken_cmp(void *obj, hid_t connector_id, const H5O_token_t *token1,
const H5O_token_t *token2, int *cmp_value);
H5_DLL herr_t H5VLtoken_to_str(void *obj, H5I_type_t obj_type, hid_t connector_id, const H5O_token_t *token,
char **token_str);
H5_DLL herr_t H5VLtoken_from_str(void *obj, H5I_type_t obj_type, hid_t connector_id, const char *token_str,
H5O_token_t *token);
/* Public wrappers for generic 'optional' callback */
H5_DLL herr_t H5VLoptional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id,
void **req);
H5VLattr_get
herr_t H5VLattr_get(void *obj, hid_t connector_id, H5VL_attr_get_args_t *args, hid_t dxpl_id, void **req)
H5VLblob_put
herr_t H5VLblob_put(void *obj, hid_t connector_id, const void *buf, size_t size, void *blob_id, void *ctx)
H5VLobject_optional
herr_t H5VLobject_optional(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLlink_move
herr_t H5VLlink_move(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj, const H5VL_loc_params_t *loc_params2, hid_t connector_id, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req)
H5VLrequest_optional
herr_t H5VLrequest_optional(void *req, hid_t connector_id, H5VL_optional_args_t *args)
H5VLfree_connector_info
herr_t H5VLfree_connector_info(hid_t connector_id, void *vol_info)
H5VLlink_create
herr_t H5VLlink_create(H5VL_link_create_args_t *args, void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req)
H5VLcmp_connector_info
herr_t H5VLcmp_connector_info(int *cmp, hid_t connector_id, const void *info1, const void *info2)
H5VLtoken_from_str
herr_t H5VLtoken_from_str(void *obj, H5I_type_t obj_type, hid_t connector_id, const char *token_str, H5O_token_t *token)
H5VLobject_get
herr_t H5VLobject_get(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5VL_object_get_args_t *args, hid_t dxpl_id, void **req)
H5VLintrospect_get_cap_flags
herr_t H5VLintrospect_get_cap_flags(const void *info, hid_t connector_id, uint64_t *cap_flags)
H5VLblob_optional
herr_t H5VLblob_optional(void *obj, hid_t connector_id, void *blob_id, H5VL_optional_args_t *args)
H5VLgroup_optional
herr_t H5VLgroup_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLattr_optional
herr_t H5VLattr_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLfile_close
herr_t H5VLfile_close(void *file, hid_t connector_id, hid_t dxpl_id, void **req)
H5VLintrospect_get_conn_cls
herr_t H5VLintrospect_get_conn_cls(void *obj, hid_t connector_id, H5VL_get_conn_lvl_t lvl, const H5VL_class_t **conn_cls)
H5VLobject_open
void * H5VLobject_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5I_type_t *opened_type, hid_t dxpl_id, void **req)
H5VLfile_get
herr_t H5VLfile_get(void *file, hid_t connector_id, H5VL_file_get_args_t *args, hid_t dxpl_id, void **req)
H5VLlink_copy
herr_t H5VLlink_copy(void *src_obj, const H5VL_loc_params_t *loc_params1, void *dst_obj, const H5VL_loc_params_t *loc_params2, hid_t connector_id, hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id, void **req)
H5VLintrospect_opt_query
herr_t H5VLintrospect_opt_query(void *obj, hid_t connector_id, H5VL_subclass_t subcls, int opt_type, uint64_t *flags)
H5VLfile_specific
herr_t H5VLfile_specific(void *obj, hid_t connector_id, H5VL_file_specific_args_t *args, hid_t dxpl_id, void **req)
H5VLdataset_open
void * H5VLdataset_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *name, hid_t dapl_id, hid_t dxpl_id, void **req)
H5VLconnector_str_to_info
herr_t H5VLconnector_str_to_info(const char *str, hid_t connector_id, void **info)
H5VLterminate
herr_t H5VLterminate(hid_t connector_id)
H5VLblob_specific
herr_t H5VLblob_specific(void *obj, hid_t connector_id, void *blob_id, H5VL_blob_specific_args_t *args)
H5VLtoken_to_str
herr_t H5VLtoken_to_str(void *obj, H5I_type_t obj_type, hid_t connector_id, const H5O_token_t *token, char **token_str)
H5VLdatatype_close
herr_t H5VLdatatype_close(void *dt, hid_t connector_id, hid_t dxpl_id, void **req)
H5VLget_cap_flags
herr_t H5VLget_cap_flags(hid_t connector_id, uint64_t *cap_flags)
H5VLrequest_free
herr_t H5VLrequest_free(void *req, hid_t connector_id)
H5VLlink_specific
herr_t H5VLlink_specific(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5VL_link_specific_args_t *args, hid_t dxpl_id, void **req)
H5VLdataset_write
herr_t H5VLdataset_write(size_t count, void *dset[], hid_t connector_id, hid_t mem_type_id[], hid_t mem_space_id[], hid_t file_space_id[], hid_t plist_id, const void *buf[], void **req)
H5VLget_object
void * H5VLget_object(void *obj, hid_t connector_id)
H5VLrequest_specific
herr_t H5VLrequest_specific(void *req, hid_t connector_id, H5VL_request_specific_args_t *args)
H5VLfile_open
void * H5VLfile_open(const char *name, unsigned flags, hid_t fapl_id, hid_t dxpl_id, void **req)
H5VLunwrap_object
void * H5VLunwrap_object(void *obj, hid_t connector_id)
H5VLdataset_close
herr_t H5VLdataset_close(void *dset, hid_t connector_id, hid_t dxpl_id, void **req)
H5VLdatatype_specific
herr_t H5VLdatatype_specific(void *obj, hid_t connector_id, H5VL_datatype_specific_args_t *args, hid_t dxpl_id, void **req)
H5VLgroup_create
void * H5VLgroup_create(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *name, hid_t lcpl_id, hid_t gcpl_id, hid_t gapl_id, hid_t dxpl_id, void **req)
H5VLattr_close
herr_t H5VLattr_close(void *attr, hid_t connector_id, hid_t dxpl_id, void **req)
H5VLrequest_wait
herr_t H5VLrequest_wait(void *req, hid_t connector_id, uint64_t timeout, H5VL_request_status_t *status)
H5VLdataset_get
herr_t H5VLdataset_get(void *dset, hid_t connector_id, H5VL_dataset_get_args_t *args, hid_t dxpl_id, void **req)
H5VLdatatype_open
void * H5VLdatatype_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *name, hid_t tapl_id, hid_t dxpl_id, void **req)
H5VLinitialize
herr_t H5VLinitialize(hid_t connector_id, hid_t vipl_id)
H5VLgroup_get
herr_t H5VLgroup_get(void *obj, hid_t connector_id, H5VL_group_get_args_t *args, hid_t dxpl_id, void **req)
H5VLcopy_connector_info
herr_t H5VLcopy_connector_info(hid_t connector_id, void **dst_vol_info, void *src_vol_info)
H5VLtoken_cmp
herr_t H5VLtoken_cmp(void *obj, hid_t connector_id, const H5O_token_t *token1, const H5O_token_t *token2, int *cmp_value)
H5VLobject_specific
herr_t H5VLobject_specific(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5VL_object_specific_args_t *args, hid_t dxpl_id, void **req)
H5VLdataset_optional
herr_t H5VLdataset_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLrequest_notify
herr_t H5VLrequest_notify(void *req, hid_t connector_id, H5VL_request_notify_t cb, void *ctx)
H5VLdataset_read
herr_t H5VLdataset_read(size_t count, void *dset[], hid_t connector_id, hid_t mem_type_id[], hid_t mem_space_id[], hid_t file_space_id[], hid_t plist_id, void *buf[], void **req)
H5VLlink_optional
herr_t H5VLlink_optional(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLgroup_specific
herr_t H5VLgroup_specific(void *obj, hid_t connector_id, H5VL_group_specific_args_t *args, hid_t dxpl_id, void **req)
H5VLconnector_info_to_str
herr_t H5VLconnector_info_to_str(const void *info, hid_t connector_id, char **str)
H5VLwrap_object
void * H5VLwrap_object(void *obj, H5I_type_t obj_type, hid_t connector_id, void *wrap_ctx)
H5VLdatatype_optional
herr_t H5VLdatatype_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLdataset_create
void * H5VLdataset_create(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *name, hid_t lcpl_id, hid_t type_id, hid_t space_id, hid_t dcpl_id, hid_t dapl_id, hid_t dxpl_id, void **req)
H5VLfile_create
void * H5VLfile_create(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id, hid_t dxpl_id, void **req)
H5VLdatatype_commit
void * H5VLdatatype_commit(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *name, hid_t type_id, hid_t lcpl_id, hid_t tcpl_id, hid_t tapl_id, hid_t dxpl_id, void **req)
H5VLattr_write
herr_t H5VLattr_write(void *attr, hid_t connector_id, hid_t dtype_id, const void *buf, hid_t dxpl_id, void **req)
H5VLattr_specific
herr_t H5VLattr_specific(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5VL_attr_specific_args_t *args, hid_t dxpl_id, void **req)
H5VLlink_get
herr_t H5VLlink_get(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, H5VL_link_get_args_t *args, hid_t dxpl_id, void **req)
H5VLgroup_open
void * H5VLgroup_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *name, hid_t gapl_id, hid_t dxpl_id, void **req)
H5VLobject_copy
herr_t H5VLobject_copy(void *src_obj, const H5VL_loc_params_t *loc_params1, const char *src_name, void *dst_obj, const H5VL_loc_params_t *loc_params2, const char *dst_name, hid_t connector_id, hid_t ocpypl_id, hid_t lcpl_id, hid_t dxpl_id, void **req)
H5VLget_wrap_ctx
herr_t H5VLget_wrap_ctx(void *obj, hid_t connector_id, void **wrap_ctx)
H5VLattr_read
herr_t H5VLattr_read(void *attr, hid_t connector_id, hid_t dtype_id, void *buf, hid_t dxpl_id, void **req)
H5VLdatatype_get
herr_t H5VLdatatype_get(void *dt, hid_t connector_id, H5VL_datatype_get_args_t *args, hid_t dxpl_id, void **req)
H5VLget_value
herr_t H5VLget_value(hid_t connector_id, H5VL_class_value_t *conn_value)
H5VLrequest_cancel
herr_t H5VLrequest_cancel(void *req, hid_t connector_id, H5VL_request_status_t *status)
H5VLattr_create
void * H5VLattr_create(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *attr_name, hid_t type_id, hid_t space_id, hid_t acpl_id, hid_t aapl_id, hid_t dxpl_id, void **req)
H5VLattr_open
void * H5VLattr_open(void *obj, const H5VL_loc_params_t *loc_params, hid_t connector_id, const char *name, hid_t aapl_id, hid_t dxpl_id, void **req)
H5VLfile_optional
herr_t H5VLfile_optional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLblob_get
herr_t H5VLblob_get(void *obj, hid_t connector_id, const void *blob_id, void *buf, size_t size, void *ctx)
H5VLoptional
herr_t H5VLoptional(void *obj, hid_t connector_id, H5VL_optional_args_t *args, hid_t dxpl_id, void **req)
H5VLfree_wrap_ctx
herr_t H5VLfree_wrap_ctx(void *wrap_ctx, hid_t connector_id)
H5VLgroup_close
herr_t H5VLgroup_close(void *grp, hid_t connector_id, hid_t dxpl_id, void **req)
H5VLdataset_specific
herr_t H5VLdataset_specific(void *obj, hid_t connector_id, H5VL_dataset_specific_args_t *args, hid_t dxpl_id, void **req)

# Appendix C Native VOL Connector Optional Values By Subclass

/* H5VL_SUBCLS_ATTR */
#define H5VL_NATIVE_ATTR_ITERATE_OLD 0 /* H5Aiterate (deprecated routine) */
/* H5VL_SUBCLS_DATASET */
#define H5VL_NATIVE_DATASET_FORMAT_CONVERT 0 /* H5Dformat_convert (internal) */
#define H5VL_NATIVE_DATASET_GET_CHUNK_INDEX_TYPE 1 /* H5Dget_chunk_index_type */
#define H5VL_NATIVE_DATASET_GET_CHUNK_STORAGE_SIZE 2 /* H5Dget_chunk_storage_size */
#define H5VL_NATIVE_DATASET_GET_NUM_CHUNKS 3 /* H5Dget_num_chunks */
#define H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX 4 /* H5Dget_chunk_info */
#define H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COORD 5 /* H5Dget_chunk_info_by_coord */
#define H5VL_NATIVE_DATASET_CHUNK_READ 6 /* H5Dchunk_read */
#define H5VL_NATIVE_DATASET_CHUNK_WRITE 7 /* H5Dchunk_write */
#define H5VL_NATIVE_DATASET_GET_VLEN_BUF_SIZE 8 /* H5Dvlen_get_buf_size */
#define H5VL_NATIVE_DATASET_GET_OFFSET 9 /* H5Dget_offset */
#define H5VL_NATIVE_DATASET_CHUNK_ITER 10 /* H5Dchunk_iter */
/* H5VL_SUBCLS_FILE */
#define H5VL_NATIVE_FILE_CLEAR_ELINK_CACHE 0 /* H5Fclear_elink_file_cache */
#define H5VL_NATIVE_FILE_GET_FILE_IMAGE 1 /* H5Fget_file_image */
#define H5VL_NATIVE_FILE_GET_FREE_SECTIONS 2 /* H5Fget_free_sections */
#define H5VL_NATIVE_FILE_GET_FREE_SPACE 3 /* H5Fget_freespace */
#define H5VL_NATIVE_FILE_GET_INFO 4 /* H5Fget_info1/2 */
#define H5VL_NATIVE_FILE_GET_MDC_CONF 5 /* H5Fget_mdc_config */
#define H5VL_NATIVE_FILE_GET_MDC_HR 6 /* H5Fget_mdc_hit_rate */
#define H5VL_NATIVE_FILE_GET_MDC_SIZE 7 /* H5Fget_mdc_size */
#define H5VL_NATIVE_FILE_GET_SIZE 8 /* H5Fget_filesize */
#define H5VL_NATIVE_FILE_GET_VFD_HANDLE 9 /* H5Fget_vfd_handle */
#define H5VL_NATIVE_FILE_RESET_MDC_HIT_RATE 10 /* H5Freset_mdc_hit_rate_stats */
#define H5VL_NATIVE_FILE_SET_MDC_CONFIG 11 /* H5Fset_mdc_config */
#define H5VL_NATIVE_FILE_GET_METADATA_READ_RETRY_INFO 12 /* H5Fget_metadata_read_retry_info */
#define H5VL_NATIVE_FILE_START_SWMR_WRITE 13 /* H5Fstart_swmr_write */
#define H5VL_NATIVE_FILE_START_MDC_LOGGING 14 /* H5Fstart_mdc_logging */
#define H5VL_NATIVE_FILE_STOP_MDC_LOGGING 15 /* H5Fstop_mdc_logging */
#define H5VL_NATIVE_FILE_GET_MDC_LOGGING_STATUS 16 /* H5Fget_mdc_logging_status */
#define H5VL_NATIVE_FILE_FORMAT_CONVERT 17 /* H5Fformat_convert */
#define H5VL_NATIVE_FILE_RESET_PAGE_BUFFERING_STATS 18 /* H5Freset_page_buffering_stats */
#define H5VL_NATIVE_FILE_GET_PAGE_BUFFERING_STATS 19 /* H5Fget_page_buffering_stats */
#define H5VL_NATIVE_FILE_GET_MDC_IMAGE_INFO 20 /* H5Fget_mdc_image_info */
#define H5VL_NATIVE_FILE_GET_EOA 21 /* H5Fget_eoa */
#define H5VL_NATIVE_FILE_INCR_FILESIZE 22 /* H5Fincrement_filesize */
#define H5VL_NATIVE_FILE_SET_LIBVER_BOUNDS 23 /* H5Fset_latest_format/libver_bounds */
#define H5VL_NATIVE_FILE_GET_MIN_DSET_OHDR_FLAG 24 /* H5Fget_dset_no_attrs_hint */
#define H5VL_NATIVE_FILE_SET_MIN_DSET_OHDR_FLAG 25 /* H5Fset_dset_no_attrs_hint */
#ifdef H5_HAVE_PARALLEL
#define H5VL_NATIVE_FILE_GET_MPI_ATOMICITY 26 /* H5Fget_mpi_atomicity */
#define H5VL_NATIVE_FILE_SET_MPI_ATOMICITY 27 /* H5Fset_mpi_atomicity */
#endif
#define H5VL_NATIVE_FILE_POST_OPEN 28 /* Adjust file after open, with wrapping context */
/* H5VL_SUBCLS_GROUP */
#define H5VL_NATIVE_GROUP_ITERATE_OLD 0 /* HG5Giterate (deprecated routine) */
#define H5VL_NATIVE_GROUP_GET_OBJINFO 1 /* HG5Gget_objinfo (deprecated routine) */
/* H5VL_SUBCLS_OBJECT */
#define H5VL_NATIVE_OBJECT_GET_COMMENT 0 /* H5G|H5Oget_comment, H5Oget_comment_by_name */
#define H5VL_NATIVE_OBJECT_SET_COMMENT 1 /* H5G|H5Oset_comment, H5Oset_comment_by_name */
#define H5VL_NATIVE_OBJECT_DISABLE_MDC_FLUSHES 2 /* H5Odisable_mdc_flushes */
#define H5VL_NATIVE_OBJECT_ENABLE_MDC_FLUSHES 3 /* H5Oenable_mdc_flushes */
#define H5VL_NATIVE_OBJECT_ARE_MDC_FLUSHES_DISABLED 4 /* H5Oare_mdc_flushes_disabled */
#define H5VL_NATIVE_OBJECT_GET_NATIVE_INFO 5 /* H5Oget_native_info(_by_idx, _by_name) */

Navigate back: Main / Technical Notes