HDF5 documents and links 
Introduction to HDF5 
HDF5 User Guide 
 And in this document, the HDF5 Reference Manual  
  H5   H5A   H5D   H5E   H5F   H5G   H5I   H5P  
H5R   H5S   H5T   H5Z   Tools   Datatypes  
Collective Calls in Parallel  
(PDF of complete manual formatted as print volume)   

H5T: Datatype Interface

Datatype Object API Functions

These functions create and manipulate the datatype which describes elements of a dataset.

The C Interfaces:
General Datatype Operations
  • H5Tcreate
  • H5Topen
  • H5Tcommit
  • H5Tcommitted
  • H5Tcopy
  • H5Tequal
  • H5Tlock
  • H5Tget_class
  • H5Tget_size
  • H5Tget_super
  • H5Tget_native_type
  • H5Tdetect_class
  • H5Tclose

    Conversion Functions
  • H5Tconvert
  • H5Tfind
  • H5Tset_overflow
  • H5Tget_overflow
  • H5Tregister
  • H5Tunregister
    		•        Atomic Datatype Properties
  • H5Tset_size
  • H5Tget_order
  • H5Tset_order
  • H5Tget_precision
  • H5Tset_precision
  • H5Tget_offset
  • H5Tset_offset
  • H5Tget_pad
  • H5Tset_pad
  • H5Tget_sign
  • H5Tset_sign
  • H5Tget_fields
  • H5Tset_fields
  • H5Tget_ebias
  • H5Tset_ebias
  • H5Tget_norm
  • H5Tset_norm
  • H5Tget_inpad
  • H5Tset_inpad
  • H5Tget_cset
  • H5Tset_cset
  • H5Tget_strpad
  • H5Tset_strpad


    • Enumeration Datatypes
  • H5Tenum_create
  • H5Tenum_insert
  • H5Tenum_nameof
  • H5Tenum_valueof
  • H5Tget_member_value
  • H5Tget_nmembers
  • H5Tget_member_name
  • H5Tget_member_index
    		•        Compound Datatype Properties
  • H5Tget_nmembers
  • H5Tget_member_class
  • H5Tget_member_name
  • H5Tget_member_index
  • H5Tget_member_offset
  • H5Tget_member_type
  • H5Tinsert
  • H5Tpack

    Array Datatypes
  • H5Tarray_create
  • H5Tget_array_ndims
  • H5Tget_array_dims

    Variable-length Datatypes
  • H5Tvlen_create
  • H5Tis_variable_str

    Opaque Datatypes
  • H5Tset_tag
  • H5Tget_tag

    • Alphabetical Listing
  • H5Tarray_create
  • H5Tclose
  • H5Tcommit
  • H5Tcommitted
  • H5Tconvert
  • H5Tcopy
  • H5Tcreate
  • H5Tdetect_class
  • H5Tenum_create
  • H5Tenum_insert
  • H5Tenum_nameof
  • H5Tenum_valueof
  • H5Tequal
  • H5Tfind
  • H5Tget_array_dims
  • H5Tget_array_ndims
  • H5Tget_class
  • H5Tget_cset
  • H5Tget_ebias
  • H5Tget_fields
  • H5Tget_inpad
    		•       
  • H5Tget_member_class
  • H5Tget_member_index
  • H5Tget_member_name
  • H5Tget_member_offset
  • H5Tget_member_type
  • H5Tget_member_value
  • H5Tget_native_type
  • H5Tget_nmembers
  • H5Tget_norm
  • H5Tget_offset
  • H5Tget_order
  • H5Tget_overflow
  • H5Tget_pad
  • H5Tget_precision
  • H5Tget_sign
  • H5Tget_size
  • H5Tget_strpad
  • H5Tget_super
  • H5Tget_tag
  • H5Tinsert
  • H5Tis_variable_str
    		•       
  • H5Tlock
  • H5Topen
  • H5Tpack
  • H5Tregister
  • H5Tset_cset
  • H5Tset_ebias
  • H5Tset_fields
  • H5Tset_inpad
  • H5Tset_norm
  • H5Tset_offset
  • H5Tset_order
  • H5Tset_overflow
  • H5Tset_pad
  • H5Tset_precision
  • H5Tset_sign
  • H5Tset_size
  • H5Tset_strpad
  • H5Tset_tag
  • H5Tunregister
  • H5Tvlen_create

    • The FORTRAN90 Interfaces:
    In general, each FORTRAN90 subroutine performs exactly the same task as the corresponding C function.
    General Datatype Operations
  • h5tcreate_f
  • h5topen_f
  • h5tcommit_f
  • h5tcommitted_f
  • h5tcopy_f
  • h5tequal_f
  • h5tget_class_f
  • h5tget_size_f
  • h5tget_super_f
  • h5tclose_f

    Enumeration Datatypes
  • h5tenum_create_f
  • h5tenum_insert_f
  • h5tenum_nameof_f
  • h5tenum_valueof_f
  • h5tget_member_value_f
  • h5tget_nmembers_f
  • h5tget_member_name_f
  • h5tget_member_index_f
    		•        Atomic Datatype Properties
  • h5tset_size_f
  • h5tget_order_f
  • h5tset_order_f
  • h5tget_precision_f
  • h5tset_precision_f
  • h5tget_offset_f
  • h5tset_offset_f
  • h5tget_pad_f
  • h5tset_pad_f
  • h5tget_sign_f
  • h5tset_sign_f
  • h5tget_fields_f
  • h5tset_fields_f
  • h5tget_ebiass_f
  • h5tset_ebiass_f
  • h5tget_norm_f
  • h5tset_norm_f
  • h5tget_inpad_f
  • h5tset_inpad_f
  • h5tget_cset_f
  • h5tset_cset_f
  • h5tget_strpad_f
  • h5tset_strpad_f
    		•        Array Datatypes
  • h5tarray_create_f
  • h5tget_array_ndims_f
  • h5tget_array_dims_f

    Compound Datatype Properties
  • h5tget_nmembers_f
  • h5tget_member_class_f
  • h5tget_member_name_f
  • h5tget_member_index_f
  • h5tget_member_offset_f
  • h5tget_member_type_f
  • h5tinsert_f
  • h5tpack_f

    Variable-length Datatypes
  • h5tvlen_create_f
  • h5tis_variable_str_f

    Opaque Datatypes
  • h5tset_tag_f
  • h5tget_tag_f

    • The Datatype interface, H5T, provides a mechanism to describe the storage format of individual data points of a data set and is hopefully designed in such a way as to allow new features to be easily added without disrupting applications that use the data type interface. A dataset (the H5D interface) is composed of a collection or raw data points of homogeneous type organized according to the data space (the H5S interface).

    A datatype is a collection of datatype properties, all of which can be stored on disk, and which when taken as a whole, provide complete information for data conversion to or from that datatype. The interface provides functions to set and query properties of a datatype.

    A data point is an instance of a datatype, which is an instance of a type class. We have defined a set of type classes and properties which can be extended at a later time. The atomic type classes are those which describe types which cannot be decomposed at the datatype interface level; all other classes are compound.

    See The Datatype Interface (H5T) in the HDF5 User's Guide for further information, including a complete list of all supported datatypes.

    Name: H5Tarray_create
    Signature:
    hid_t H5Tarray_create( hid_t base, int rank, const hsize_t dims[/*rank*/], const int perm[/*rank*/] )
    Purpose:
    Creates an array datatype object.
    Description:
    H5Tarray_create creates a new array datatype object.

    base is the datatype of every element of the array, i.e., of the number at each position in the array.

    rank is the number of dimensions and the size of each dimension is specified in the array dims. The value of rank is currently limited to H5S_MAX_RANK and must be greater than 0 (zero). All dimension sizes specified in dims must be greater than 0 (zero).

    The array perm is designed to contain the dimension permutation, i.e. C versus FORTRAN array order.   (The parameter perm is currently unused and is not yet implemented.)

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tarray_create_f 
    SUBROUTINE h5tarray_create_f(base_id, rank, dims, type_id, hdferr)
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: base_id   ! Identifier of array base datatype
  INTEGER, INTENT(IN)        ::  rank     ! Rank of the array
  INTEGER(HSIZE_T), DIMENSION(*), INTENT(IN) :: dims 
                                          ! Sizes of each array dimension
  INTEGER(HID_T), INTENT(OUT) :: type_id  ! Identifier of the array datatype
  INTEGER, INTENT(OUT)        :: hdferr   ! Error code
END SUBROUTINE h5tarray_create_f
    History:
    Name: H5Tclose
    Signature:
    herr_t H5Tclose(hid_t type_id )
    Purpose:
    Releases a datatype.
    Description:
    H5Tclose releases a datatype. Further access through the datatype identifier is illegal. Failure to release a datatype with this call will result in resource leaks.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tclose_f 
    SUBROUTINE h5tclose_f(type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
                                        ! 0 on success and -1 on failure
END SUBROUTINE h5tclose_f
    Name: H5Tcommit
    Signature:
    herr_tH5Tcommit(hid_t loc_id, const char * name, hid_t type )
    Purpose:
    Commits a transient datatype to a file, creating a new named datatype.
    Description:
    H5Tcommit commits a transient datatype (not immutable) to a file, turned it into a named datatype. The loc_id is either a file or group identifier which, when combined with name, refers to a new named datatype.

    As is the case for any object in a group, the length of the name of a named datatype is not limited.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tcommit_f 
    SUBROUTINE h5tcommit_f(loc_id, name, type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: loc_id  ! File or group identifier 
  CHARACTER(LEN=*), INTENT(IN) :: name  ! Datatype name within file or group
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
                                        ! 0 on success and -1 on failure
END SUBROUTINE h5tcommit_f
    Name: H5Tcommitted
    Signature:
    htri_tH5Tcommitted(hid_t type)
    Purpose:
    Determines whether a datatype is a named type or a transient type.
    Description:
    H5Tcommitted queries a type to determine whether the type specified by the type identifier is a named type or a transient type. If this function returns a positive value, then the type is named (that is, it has been committed, perhaps by some other application). Datasets which return committed datatypes with H5Dget_type() are able to share the datatype with other datasets in the same file.
    Parameters:
    Returns:
    When successful, returns a positive value, for TRUE, if the datatype has been committed, or 0 (zero), for FALSE, if the datatype has not been committed. Otherwise returns a negative value.
    Fortran90 Interface: h5tcommitted_f 
    SUBROUTINE h5tcommitted_f(type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tcommitted_f
    Name: H5Tconvert
    Signature:
    herr_t H5Tconvert(hid_t src_id, hid_t dst_id, size_t nelmts, void *buf, void *background, hid_t plist_id )
    Purpose:
    Converts data from between specified datatypes.
    Description:
    H5Tconvert converts nelmts elements from the type specified by the src_id identifier to type dst_id. The source elements are packed in buf and on return the destination will be packed in buf. That is, the conversion is performed in place. The optional background buffer is an array of nelmts values of destination type which are merged with the converted values to fill in cracks (for instance, background might be an array of structs with the a and b fields already initialized and the conversion of buf supplies the c and d field values).

    The parameter plist_id contains the dataset transfer property list identifier which is passed to the conversion functions. As of Release 1.2, this parameter is only used to pass along the variable-length datatype custom allocation information.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface:
    None.
    History:
    Name: H5Tcopy
    Signature:
    hid_t H5Tcopy(hid_t type_id)
    Purpose:
    Copies an existing datatype.
    Description:
    H5Tcopy copies an existing datatype. The returned type is always transient and unlocked.

    The type_id argument can be either a datatype identifier, a predefined datatype (defined in H5Tpublic.h), or a dataset identifier. If type_id is a dataset identifier instead of a datatype identifier, then this function returns a transient, modifiable datatype which is a copy of the dataset's datatype.

    The datatype identifier returned should be released with H5Tclose or resource leaks will occur.

    Parameters:
    Returns:
    Returns a datatype identifier if successful; otherwise returns a negative value
    Fortran90 Interface: h5tcopy_f 
    SUBROUTINE h5tcopy_f(type_id, new_type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id      ! Datatype identifier 
  INTEGER(HID_T), INTENT(OUT) :: new_type_id ! Identifier of datatype's copy 
  INTEGER, INTENT(OUT) :: hdferr             ! Error code
                                             ! 0 on success and -1 on failure
END SUBROUTINE h5tcopy_f
    Name: H5Tcreate
    Signature:
    hid_t H5Tcreate(H5T_class_t class, size_tsize )
    Purpose:
    Creates a new datatype.
    Description:
    H5Tcreate creates a new datatype of the specified class with the specified number of bytes.

    The following datatype classes are supported with this function:

    Use H5Tcopy to create integer or floating-point datatypes.

    The datatype identifier returned from this function should be released with H5Tclose or resource leaks will result.

    Parameters:
    Returns:
    Returns datatype identifier if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tcreate_f 
    SUBROUTINE h5tcreate_f(class, size, type_id, hdferr) 
  IMPLICIT NONE
  INTEGER, INTENT(IN) :: class             ! Datatype class can be one of
                                           !    H5T_COMPOUND_F (6)
                                           !    H5T_ENUM_F     (8)
                                           !    H5T_OPAQUE_F   (9)
  INTEGER(SIZE_T), INTENT(IN) :: size      ! Size of the datatype
  INTEGER(HID_T), INTENT(OUT) :: type_id   ! Datatype identifier
  INTEGER, INTENT(OUT) :: hdferr           ! Error code
END SUBROUTINE h5tcreate_f
    Name: H5Tdetect_class
    Signature:
    htri_t H5Tdetect_class(hid_t dtype_id, H5T_class_tdtype_class )
    Purpose:
    Determines whether a datatype contains any datatypes of the given datatype class.
    Description:
    H5Tdetect_class determines whether the datatype specified in dtype_id contains any datatypes of the datatype class specified in dtype_class.

    This function is useful primarily in recursively examining all the fields and/or base types of compound, array, and variable-length datatypes.

    Valid class identifiers are as defined in H5Tget_class.

    Parameters:
    Returns:
    Returns TRUE or FALSE if successful; otherwise returns a negative value.
    Fortran90 Interface:
    None.
    History:
    Name: H5Tenum_create
    Signature:
    hid_t H5Tenum_create(hid_t parent_id )
    Purpose:
    Creates a new enumeration datatype.
    Description:
    H5Tenum_create creates a new enumeration datatype based on the specified base datatype, parent_id, which must be an integer type.
    Parameters:
    Returns:
    Returns the datatype identifier for the new enumeration datatype if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tenum_create_f 
    SUBROUTINE h5tenum_create_f(parent_id, new_type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: parent_id     ! Datatype identifier for
                                              ! the  base datatype
  INTEGER(HID_T), INTENT(OUT) :: new_type_id  ! Datatype identifier for the
                                              ! new enumeration datatype    
  INTEGER, INTENT(OUT) :: hdferr              ! Error code
END SUBROUTINE h5tenum_create_f
    Name: H5Tenum_insert
    Signature:
    herr_t H5Tenum_insert(hid_t type, const char *name, void *value )
    Purpose:
    Inserts a new enumeration datatype member.
    Description:
    H5Tenum_insert inserts a new enumeration datatype member into an enumeration datatype.

    type is the enumeration datatype, name is the name of the new member, and value points to the value of the new member.

    name and value must both be unique within type.

    value points to data which is of the datatype defined when the enumeration datatype was created.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tenum_insert_f 
    SUBROUTINE h5tenum_insert_f(type_id,  name, value, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  CHARACTER(LEN=*), INTENT(IN) :: name  ! Name of the new member
  INTEGER, INTENT(IN) :: value          ! Value of the new member
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tenum_insert_f
    Name: H5Tenum_nameof
    Signature:
    herr_t H5Tenum_nameof( hid_t type, void *value, char *name, size_t size )
    Purpose:
    Returns the symbol name corresponding to a specified member of an enumeration datatype.
    Description:
    H5Tenum_nameof finds the symbol name that corresponds to the specified value of the enumeration datatype type.

    At most size characters of the symbol name are copied into the name buffer. If the entire symbol name and null terminator do not fit in the name buffer, then as many characters as possible are copied (not null terminated) and the function fails.

    Parameters:
    Returns:
    Returns a non-negative value if successful. Otherwise returns a negative value and, if size allows it, the first character of name is set to NULL.
    Fortran90 Interface: h5tenum_nameof_f 
    SUBROUTINE h5tenum_nameof_f(type_id, value, namelen, name, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  INTEGER, INTENT(IN) :: value           ! Value of the enumeration datatype
  INTEGER(SIZE_T), INTENT(IN) :: namelen ! Length of the name
  CHARACTER(LEN=*), INTENT(OUT) :: name  ! Name of the enumeration datatype
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
END SUBROUTINE h5tenum_nameof_f
    Name: H5Tenum_valueof
    Signature:
    herr_t H5Tenum_valueof( hid_t type, char *name, void *value )
    Purpose:
    Returns the value corresponding to a specified member of an enumeration datatype.
    Description:
    H5Tenum_valueof finds the value that corresponds to the specified name of the enumeration datatype type.

    The value argument should be at least as large as the value of H5Tget_size(type) in order to hold the result.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tenum_valueof_f 
    SUBROUTINE h5tenum_valueof_f(type_id,  name, value, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  CHARACTER(LEN=*), INTENT(IN) :: name  ! Name of the enumeration datatype
  INTEGER, INTENT(OUT) :: value         ! Value of the enumeration datatype
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tenum_valueof_f
    Name: H5Tequal
    Signature:
    htri_t H5Tequal(hid_t type_id1, hid_ttype_id2 )
    Purpose:
    Determines whether two datatype identifiers refer to the same datatype.
    Description:
    H5Tequal determines whether two datatype identifiers refer to the same datatype.
    Parameters:
    Returns:
    When successful, returns a positive value, for TRUE, if the datatype identifiers refer to the same datatype, or 0 (zero), for FALSE. Otherwise returns a negative value.
    Fortran90 Interface: h5tequal_f 
    SUBROUTINE h5tequal_f(type1_id, type2_id, flag, hdferr)
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type1_id ! Datatype identifier 
  INTEGER(HID_T), INTENT(IN) :: type2_id ! Datatype identifier 
  LOGICAL, INTENT(OUT) :: flag           ! TRUE/FALSE flag to indicate 
                                         ! if two datatypes are equal
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
END SUBROUTINE h5tequal_f
    Name: H5Tfind
    Signature:
    H5T_conv_t H5Tfind(hid_t src_id, hid_t dst_id, H5T_cdata_t **pcdata )
    Purpose:
    Finds a conversion function.
    Description:
    H5Tfind finds a conversion function that can handle a conversion from type src_id to type dst_id. The pcdata argument is a pointer to a pointer to type conversion data which was created and initialized by the soft type conversion function of this path when the conversion function was installed on the path.
    Parameters:
    Returns:
    Returns a pointer to a suitable conversion function if successful. Otherwise returns NULL.
    Fortran90 Interface:
    None.
    Name: H5Tget_array_dims
    Signature:
    int H5Tget_array_dims( hid_t adtype_id, hsize_t dims[], int perm[] )
    Purpose:
    Retrieves sizes of array dimensions and dimension permutations.
    Description:
    H5Tget_array_dims returns the sizes of the dimensions and the dimension permutations of the specified array datatype object.

    The sizes of the dimensions are returned in the array dims. The dimension permutations, i.e., C versus FORTRAN array order, are returned in the array perm.

    Parameters:
    Returns:
    Returns the non-negative number of dimensions of the array type if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_array_dims_f 
    SUBROUTINE h5tget_array_dims_f(type_id, dims, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id      ! Identifier of the array datatype
  INTEGER(HSIZE_T), DIMENSION(*), INTENT(OUT) ::  dims 
                                             ! Buffer to store array datatype
  INTEGER, INTENT(OUT)  :: hdferr            ! Error code
END SUBROUTINE h5tget_array_dims_f
    History:
    Name: H5Tget_array_ndims
    Signature:
    int H5Tget_array_ndims( hid_t adtype_id )
    Purpose:
    Returns the rank of an array datatype.
    Description:
    H5Tget_array_ndims returns the rank, the number of dimensions, of an array datatype object.
    Parameters:
    Returns:
    Returns the rank of the array if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_array_ndims_f 
    SUBROUTINE h5tget_array_ndims_f(type_id, ndims, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Identifier of the array datatype
  INTEGER, INTENT(OUT)       ::  ndims   ! Number of array dimensions
  INTEGER, INTENT(OUT)       :: hdferr   ! Error code
END SUBROUTINE h5tget_array_ndims_f
    History:
    Name: H5Tget_class
    Signature:
    H5T_class_t H5Tget_class(hid_t type_id )
    Purpose:
    Returns the datatype class identifier.
    Description:
    H5Tget_class returns the datatype class identifier.

    Valid class identifiers, as defined in H5Tpublic.h, are:

    Note that the library returns H5T_STRING for both fixed-length and variable-length strings.

    Note that the time datatype class, H5T_TIME, is not fully supported in the current version of the HDF5 Library.

    Parameters:
    Returns:
    Returns datatype class identifier if successful; otherwise H5T_NO_CLASS (-1).
    Fortran90 Interface: h5tget_class_f 
    SUBROUTINE h5tget_class_f(type_id, class, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  INTEGER, INTENT(OUT) :: class          ! Datatype class, possible values are:
                                         !    H5T_NO_CLASS_F 
                                         !    H5T_INTEGER_F 
                                         !    H5T_FLOAT_F
                                         !    H5T_TIME_F
                                         !    H5T_STRING_F
                                         !    H5T_BITFIELD_F
                                         !    H5T_OPAQUE_F
                                         !    H5T_COMPOUND_F
                                         !    H5T_REFERENCE_F
                                         !    H5T_ENUM_F
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
                                         ! 0 on success and -1 on failure
END SUBROUTINE h5tget_class_f
    Name: H5Tget_cset
    Signature:
    H5T_cset_t H5Tget_cset(hid_t type_id )
    Purpose:
    Retrieves the character set type of a string datatype.
    Description:
    H5Tget_cset retrieves the character set type of a string datatype. Valid character set types are:
             H5T_CSET_ASCII   (0)      Character set is US ASCII.
    Parameters:
    Returns:
    Returns a valid character set type if successful; otherwise H5T_CSET_ERROR (-1).
    Fortran90 Interface: h5tget_cset_f 
    SUBROUTINE h5tget_cset_f(type_id, cset, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: cset          ! Character set type of a string 
                                        ! datatype 
                                        ! Possible values of padding type are:
                                        !    H5T_CSET_ASCII_F = 0
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_cset_f
    Name: H5Tget_ebias
    Signature:
    size_t H5Tget_ebias(hid_t type_id )
    Purpose:
    Retrieves the exponent bias of a floating-point type.
    Description:
    H5Tget_ebias retrieves the exponent bias of a floating-point type.
    Parameters:
    Returns:
    Returns the bias if successful; otherwise 0.
    Fortran90 Interface: h5tget_ebias_f 
    SUBROUTINE h5tget_ebias_f(type_id, ebias, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: ebias         ! Datatype exponent bias 
                                        ! of a floating-point type
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_ebias_f
    Name: H5Tget_fields
    Signature:
    herr_t H5Tget_fields(hid_t type_id, size_t *spos, size_t *epos, size_t *esize, size_t *mpos, size_t *msize )
    Purpose:
    Retrieves floating point datatype bit field information.
    Description:
    H5Tget_fields retrieves information about the locations of the various bit fields of a floating point datatype. The field positions are bit positions in the significant region of the datatype. Bits are numbered with the least significant bit number zero. Any (or even all) of the arguments can be null pointers.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_fields_f 
    SUBROUTINE h5tget_fields_f(type_id, epos, esize, mpos, msize, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: epos          ! Exponent bit-position 
  INTEGER, INTENT(OUT) :: esize         ! Size of exponent in bits
  INTEGER, INTENT(OUT) :: mpos          ! Mantissa bit-position 
  INTEGER, INTENT(OUT) :: msize         ! Size of mantissa in bits
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_fields_f
    Name: H5Tget_inpad
    Signature:
    H5T_pad_t H5Tget_inpad(hid_t type_id )
    Purpose:
    Retrieves the internal padding type for unused bits in floating-point datatypes.
    Description:
    H5Tget_inpad retrieves the internal padding type for unused bits in floating-point datatypes. Valid padding types are:
    Parameters:
    Returns:
    Returns a valid padding type if successful; otherwise H5T_PAD_ERROR (-1).
    Fortran90 Interface: h5tget_inpad_f 
    SUBROUTINE h5tget_inpad_f(type_id, padtype, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: padtype       ! Padding type for unused bits 
                                        ! in floating-point datatypes
                                        ! Possible values of padding type are:
                                        !     H5T_PAD_ZERO_F = 0
                                        !     H5T_PAD_ONE_F = 1
                                        !     H5T_PAD_BACKGROUND_F = 2
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_inpad_f
    Name: H5Tget_member_class
    Signature:
    H5T_class_t H5Tget_member_class( hid_t cdtype_id, unsigned member_no )
    Purpose:
    Returns datatype class of compound datatype member.
    Description:
    Given a compound datatype, cdtype_id, the function H5Tget_member_class returns the datatype class of the compound datatype member specified by member_no.

    Valid class identifiers are as defined in H5Tget_class.

    Parameters:
    Returns:
    Returns the datatype class, a non-negative value, if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_member_class_f 
    SUBROUTINE h5tget_member_class_f(type_id, member_no, class, hdferr) 
  INTEGER(HID_T), INTENT(IN) :: type_id       ! Datatype identifier 
  INTEGER, INTENT(IN) :: member_no            ! Member number
  INTEGER, INTENT(OUT) :: class               ! Member class
  INTEGER, INTENT(OUT) :: hdferr              ! Error code
END SUBROUTINE h5tget_member_class_f
    History:
    Name: H5Tget_member_index
    Signature:
    int H5Tget_member_index(hid_t type_id, const char * field_name )
    Purpose:
    Retrieves the index of a compound or enumeration datatype member.
    Description:
    H5Tget_member_index retrieves the index of a field of a compound datatype or an element of an enumeration datatype.

    The name of the target field or element is specified in field_name.

    Fields are stored in no particular order with index values of 0 through N-1, where N is the value returned by H5Tget_nmembers.

    Parameters:
    Returns:
    Returns a valid field or member index if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_member_index_f 
    SUBROUTINE h5tget_member_index_f(type_id, name, index, hdferr) 
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  CHARACTER(LEN=*), INTENT(IN) :: name   ! Member name
  INTEGER, INTENT(OUT) :: index          ! Member index
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
END SUBROUTINE h5tget_member_index_f
    History:
    Name: H5Tget_member_name
    Signature:
    char * H5Tget_member_name(hid_t type_id, unsigned field_idx )
    Purpose:
    Retrieves the name of a compound or enumeration datatype member.
    Description:
    H5Tget_member_name retrieves the name of a field of a compound datatype or an element of an enumeration datatype.

    The index of the target field or element is specified in field_idx. Compound datatype fields and enumeration datatype elements are stored in no particular order with index values of 0 through N-1, where N is the value returned by H5Tget_nmembers.

    A buffer to receive the name of the field is allocated with malloc() and the caller is responsible for freeing the memory used.

    Parameters:
    Returns:
    Returns a valid pointer to a string allocated with malloc() if successful; otherwise returns NULL.
    Fortran90 Interface: h5tget_member_name_f 
    SUBROUTINE h5tget_member_name_f(type_id,index, member_name,  namelen, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id        ! Datatype identifier 
  INTEGER, INTENT(IN) :: index                 ! Field index (0-based) of 
                                               ! the field name to retrieve 
  CHARACTER(LEN=*), INTENT(OUT) :: member_name ! Name of a field of
                                               ! a compound datatype 
  INTEGER, INTENT(OUT) :: namelen              ! Length of the name 
  INTEGER, INTENT(OUT) :: hdferr               ! Error code
END SUBROUTINE h5tget_member_name_f
    History:
    Name: H5Tget_member_offset
    Signature:
    size_t H5Tget_member_offset(hid_t type_id, unsigned memb_no )
    Purpose:
    Retrieves the offset of a field of a compound datatype.
    Description:
    H5Tget_member_offset retrieves the byte offset of the beginning of a field within a compound datatype with respect to the beginning of the compound data type datum.
    Parameters:
    Returns:
    Returns the byte offset of the field if successful; otherwise returns 0 (zero). Note that zero is a valid offset and that this function will fail only if a call to H5Tget_member_class() fails with the same arguments.
    Fortran90 Interface: h5tget_member_offset_f 
    SUBROUTINE h5tget_member_offset_f(type_id, member_no, offset, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id    ! Datatype identifier 
  INTEGER, INTENT(IN) :: member_no         ! Number of the field  
                                           ! whose offset is requested
  INTEGER(SIZE_T), INTENT(OUT) :: offset   ! Byte offset of the the 
                                           ! beginning of the field
  INTEGER, INTENT(OUT) :: hdferr           ! Error code
END SUBROUTINE h5tget_member_offset_f
    History:
    Name: H5Tget_member_type
    Signature:
    hid_t H5Tget_member_type(hid_t type_id, unsigned field_idx )
    Purpose:
    Returns the datatype of the specified member.
    Description:
    H5Tget_member_type returns the datatype of the specified member. The caller should invoke H5Tclose() to release resources associated with the type.
    Parameters:
    Returns:
    Returns the identifier of a copy of the datatype of the field if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_member_type_f 
    SUBROUTINE h5tget_member_type_f(type_id,  field_idx, datatype, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id   ! Datatype identifier 
  INTEGER, INTENT(IN) :: field_idx        ! Field index (0-based) of the 
                                          ! field type to retrieve
  INTEGER(HID_T), INTENT(OUT) :: datatype ! Identifier of a copy of 
                                          ! the datatype of the field 
  INTEGER, INTENT(OUT) :: hdferr          ! Error code
END SUBROUTINE h5tget_member_type_f
    History:
    Name: H5Tget_member_value
    Signature:
    herr_t H5Tget_member_value(hid_t type unsigned memb_no, void *value )
    Purpose:
    Returns the value of an enumeration datatype member.
    Description:
    H5Tget_member_value returns the value of the enumeration datatype member memb_no.

    The member value is returned in a user-supplied buffer pointed to by value.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_member_value_f 
    SUBROUTINE h5tget_member_value_f(type_id,  member_no, value, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(IN) :: member_no      ! Number of the enumeration 
                                        ! datatype member
  INTEGER, INTENT(OUT) :: value         ! Value of the enumeration datatype
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_member_value_f
    History:
    Name: H5Tget_native_type
    Signature:
    hid_t H5Tget_native_type(hid_t type_id, H5T_direction_t direction )
    Purpose:
    Returns the native datatype of a specified datatype.
    Description:
    H5Tget_native_type returns the equivalent native datatype for the datatype specified in type_id.

    H5Tget_native_type is a high-level function designed primarily to facilitate use of the H5Dread function, for which users otherwise must undertake a multi-step process to determine the native datatype of a dataset prior to reading it into memory. It can be used not only to determine the native datatype for atomic datatypes, but also to determine the native datatypes of the individual components of a compound datatype, an enumerated datatype, an array datatype, or a variable-length datatype. For example, if dtype_id is a compound datatype, the returned datatype identifier will be for a similar compound datatype with each element converted to the corresponding native datatype.

    H5Tget_native_type selects the matching native datatype from the following list: 

            H5T_NATIVE_CHAR         
        H5T_NATIVE_SHORT        
        H5T_NATIVE_INT          
        H5T_NATIVE_LONG         
        H5T_NATIVE_LLONG        

        H5T_NATIVE_UCHAR
        H5T_NATIVE_USHORT
        H5T_NATIVE_UINT
        H5T_NATIVE_ULONG
        H5T_NATIVE_ULLONG

        H5T_NATIVE_FLOAT
        H5T_NATIVE_DOUBLE
        H5T_NATIVE_LDOUBLE

    The direction parameter indicates the order in which the library searches for a native datatype match. Valid values for direction are as follows:
         H5T_DIR_ASCEND Searches the above list in ascending size of the datatype,
    i.e., from top to bottom. (Default)
      H5T_DIR_DESCEND   Searches the above list in descending size of the datatype,
    i.e., from bottom to top.

    H5Tget_native_type is designed primarily for use with integer and floating point datatypes. String, time, bitfield, opaque, and reference datatypes are returned as a copy of type_id.

    The identifier returned by H5Tget_native_type should eventually be closed by calling H5Tclose to release resources.

    Parameters:
    Returns:
    Returns the native datatype identifier for the specified dataset datatype if successful; otherwise returns a negative value.
    Fortran90 Interface:
    None.
    History:
    Name: H5Tget_nmembers
    Signature:
    int H5Tget_nmembers(hid_t type_id )
    Purpose:
    Retrieves the number of elements in a compound or enumeration datatype.
    Description:
    H5Tget_nmembers retrieves the number of fields in a compound datatype or the number of members of an enumeration datatype.
    Parameters:
    Returns:
    Returns the number of elements if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_nmembers_f 
    SUBROUTINE h5tget_nmembers_f(type_id, num_members, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: num_members   ! Number of fields in a 
                                        ! compound datatype 
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_nmembers_f
    Name: H5Tget_norm
    Signature:
    H5T_norm_t H5Tget_norm(hid_t type_id )
    Purpose:
    Retrieves mantissa normalization of a floating-point datatype.
    Description:
    H5Tget_norm retrieves the mantissa normalization of a floating-point datatype. Valid normalization types are:
    Parameters:
    Returns:
    Returns a valid normalization type if successful; otherwise H5T_NORM_ERROR (-1).
    Fortran90 Interface: h5tget_norm_f 
    SUBROUTINE h5tget_norm_f(type_id, norm, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  
                                 ! Datatype identifier 
  INTEGER, INTENT(OUT) :: norm   ! Mantissa normalization of a 
                                 ! floating-point datatype
                                 ! Valid normalization types are:
                                 !    H5T_NORM_IMPLIED_F(0) 
                                 !        MSB of mantissa is not 
                                 !        stored, always 1
                                 !    H5T_NORM_MSBSET_F(1) 
                                 !        MSB of mantissa is always 1 
                                 !    H5T_NORM_NONE_F(2) 
                                 !        Mantissa is not normalized
  INTEGER, INTENT(OUT) :: hdferr ! Error code
END SUBROUTINE h5tget_norm_f
    Name: H5Tget_offset
    Signature:
    int H5Tget_offset(hid_t type_id )
    Purpose:
    Retrieves the bit offset of the first significant bit.
    Description:
    H5Tget_offset retrieves the bit offset of the first significant bit. The significant bits of an atomic datum can be offset from the beginning of the memory for that datum by an amount of padding. The `offset' property specifies the number of bits of padding that appear to the "right of" the value. That is, if we have a 32-bit datum with 16-bits of precision having the value 0x1122 then it will be laid out in memory as (from small byte address toward larger byte addresses):

    Byte Position Big-Endian Offset=0 Big-Endian Offset=16 Little-Endian Offset=0 Little-Endian Offset=16
    0: [ pad] [0x11] [0x22] [ pad]
    1: [ pad] [0x22] [0x11] [ pad]
    2: [0x11] [ pad] [ pad] [0x22]
    3: [0x22] [ pad] [ pad] [0x11]
    Parameters:
    Returns:
    Returns an offset value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_offset_f 
    SUBROUTINE h5tget_offset_f(type_id, offset, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: offset        ! Datatype bit offset of the
                                        ! first significant bit
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_offset_f
    Name: H5Tget_order
    Signature:
    H5T_order_t H5Tget_order(hid_t dtype_id )

    Purpose:
    Returns the byte order of an atomic datatype.

    Description:
    H5Tget_order returns the byte order of an atomic datatype.

    Possible return values are:

    Parameters:

    Returns:
    Returns a byte order constant if successful; otherwise H5T_ORDER_ERROR (-1).

    Fortran90 Interface: h5tget_order_f 
    SUBROUTINE h5tget_order_f(type_id, order, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: order         ! Datatype byte order 
                                        ! Possible values are:
                                        !    H5T_ORDER_LE_F 
                                        !    H5T_ORDER_BE_F 
                                        !    H5T_ORDER_VAX_F  
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
                                        ! 0 on success and -1 on failure
END SUBROUTINE h5tget_order_f
    Name: H5Tget_overflow
    Signature: H5Tget_overflow ()
    H5T_overflow_t H5Tget_overflow(void)
    Purpose:
    Returns a pointer to the current global overflow function.
    Description:
    H5Tset_overflow returns a pointer to the current global overflow function. This is an application-defined function that is called whenever a datatype conversion causes an overflow.
    Parameters:
    None.
    Returns:
    Returns a pointer to an application-defined function if successful. Otherwise returns NULL; this can happen if no overflow handling function is registered.
    Fortran90 Interface:
    None.
    Name: H5Tget_pad
    Signature:
    herr_t H5Tget_pad(hid_t type_id, H5T_pad_t * lsb, H5T_pad_t * msb )
    Purpose:
    Retrieves the padding type of the least and most-significant bit padding.
    Description:
    H5Tget_pad retrieves the padding type of the least and most-significant bit padding. Valid types are:
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_pad_f 
    SUBROUTINE h5tget_pad_f(type_id, lsbpad, msbpad, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: lsbpad        ! Padding type of the  
                                        ! least significant bit
  INTEGER, INTENT(OUT) :: msbpad        ! Padding type of the 
                                        ! most significant bit
                                        ! Possible values of 
                                        ! padding type are:
                                        !    H5T_PAD_ZERO_F = 0
                                        !    H5T_PAD_ONE_F = 1
                                        !    H5T_PAD_BACKGROUND_F = 2
                                        !    H5T_PAD_ERROR_F = -1
                                        !    H5T_PAD_NPAD_F = 3
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_pad_f
    Name: H5Tget_precision
    Signature:
    size_t H5Tget_precision(hid_t type_id )
    Purpose:
    Returns the precision of an atomic datatype.
    Description:
    H5Tget_precision returns the precision of an atomic datatype. The precision is the number of significant bits which, unless padding is present, is 8 times larger than the value returned by H5Tget_size.
    Parameters:
    Returns:
    Returns the number of significant bits if successful; otherwise 0.
    Fortran90 Interface: h5tget_precision_f 
    SUBROUTINE h5tget_precision_f(type_id, precision, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(OUT) :: precision     ! Datatype precision
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tget_precision_f
    Name: H5Tget_sign
    Signature:
    H5T_sign_t H5Tget_sign(hid_t type_id )
    Purpose:
    Retrieves the sign type for an integer type.
    Description:
    H5Tget_sign retrieves the sign type for an integer type. Valid types are:
    Parameters:
    Returns:
    Returns a valid sign type if successful; otherwise H5T_SGN_ERROR (-1).
    Fortran90 Interface: h5tget_sign_f 
    SUBROUTINE h5tget_sign_f(type_id, sign, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  INTEGER, INTENT(OUT) :: sign           ! Sign type for an integer type
                                         ! Possible values are:
                                         !    Unsigned integer type 
                                         !        H5T_SGN_NONE_F = 0
                                         !    Two's complement signed 
                                         !        integer type
                                         !        H5T_SGN_2_F = 1
                                         !    or error value
                                         !         H5T_SGN_ERROR_F = -1 
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
END SUBROUTINE h5tget_sign_f
    Name: H5Tget_size
    Signature:
    size_t H5Tget_size(hid_t type_id )
    Purpose:
    Returns the size of a datatype.
    Description:
    H5Tget_size returns the size of a datatype in bytes.
    Parameters:
    Returns:
    Returns the size of the datatype in bytes if successful; otherwise 0.
    Fortran90 Interface: h5tget_size_f 
    SUBROUTINE h5tget_size_f(type_id, size, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER(SIZE_T), INTENT(OUT) :: size  ! Datatype size
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
                                        ! 0 on success and -1 on failure
END SUBROUTINE h5tget_size_f
    Name: H5Tget_strpad
    Signature:
    H5T_str_t H5Tget_strpad(hid_t type_id )
    Purpose:
    Retrieves the storage mechanism for a string datatype.
    Description:
    H5Tget_strpad retrieves the storage mechanism for a string datatype, as defined in H5Tset_strpad.
    Parameters:
    Returns:
    Returns a valid string storage mechanism if successful; otherwise H5T_STR_ERROR (-1).
    Fortran90 Interface: h5tget_strpad_f 
    SUBROUTINE h5tget_strpad_f(type_id, strpad, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id    
                                  ! Datatype identifier 
  INTEGER, INTENT(OUT) :: strpad  ! String padding method for a string datatype 
                                  ! Possible values of padding type are:
                                  !    Pad with zeros (as C does): 
                                  !        H5T_STR_NULLPAD_F(0) 
                                  !    Pad with spaces (as FORTRAN does): 
                                  !        H5T_STR_SPACEPAD_F(1)
  INTEGER, INTENT(OUT) :: hdferr  ! Error code
END SUBROUTINE h5tget_strpad_f
    Name: H5Tget_super
    Signature:
    hid_t H5Tget_super(hid_t type )
    Purpose:
    Returns the base datatype from which a datatype is derived.
    Description:
    H5Tget_super returns the base datatype from which the datatype type is derived.

    In the case of an enumeration type, the return value is an integer type.

    Parameters:
    Returns:
    Returns the datatype identifier for the base datatype if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tget_super_f 
    SUBROUTINE h5tget_super_f(type_id, base_type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  INTEGER(HID_T), INTENT(OUT) :: type_id ! Base datatype identifier 
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
END SUBROUTINE h5tget_super_f
    Name: H5Tget_tag
    Signature:
    char *H5Tget_tag(hid_t type_id )
    Purpose:
    Gets the tag associated with an opaque datatype.
    Description:
    H5Tget_tag returns the tag associated with the opaque datatype type_id.

    The tag is returned via a pointer to an allocated string, which the caller must free.

    Parameters:
    Returns:
    Returns a pointer to an allocated string if successful; otherwise returns NULL.
    Fortran90 Interface: h5tget_tag_f 
    SUBROUTINE h5tget_tag_f(type_id, tag,taglen, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  CHARACTER(LEN=*), INTENT(OUT) :: tag   ! Unique ASCII string with which the
                                         ! opaque datatype is to be tagged
  INTEGER, INTENT(OUT) :: taglen         ! Length of tag 
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
END SUBROUTINE h5tget_tag_f
    Name: H5Tinsert
    Signature:
    herr_t H5Tinsert(hid_t type_id, const char * name, size_t offset, hid_t field_id )
    Purpose:
    Adds a new member to a compound datatype.
    Description:
    H5Tinsert adds another member to the compound datatype type_id. The new member has a name which must be unique within the compound datatype. The offset argument defines the start of the member in an instance of the compound datatype, and field_id is the datatype identifier of the new member.

    Note: Members of a compound datatype do not have to be atomic datatypes; a compound datatype can have a member which is a compound datatype.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tinsert_f 
    SUBROUTINE h5tinsert_f(type_id,  name, offset, field_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  CHARACTER(LEN=*), INTENT(IN) :: name   ! Name of the field to insert
  INTEGER(SIZE_T), INTENT(IN) :: offset  ! Offset in memory structure 
                                         ! of the field to insert
  INTEGER(HID_T), INTENT(IN) :: field_id ! Datatype identifier of the 
                                         ! new member
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
END SUBROUTINE h5tinsert_f
    Name: H5Tis_variable_str
    Signature:
    htri_t H5Tis_variable_str(hid_t dtype_id )
    Purpose:
    Determines whether datatype is a variable-length string.
    Description:
    H5Tis_variable_str determines whether the datatype identified in dtype_id is a variable-length string.

    This function can be used to distinguish between fixed and variable-length string datatypes.

    Parameters:
    Returns:
    Returns TRUE or FALSE if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tis_variable_str_f 
    SUBROUTINE h5tis_variable_str_f(type_id, status, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id   ! Datatype identifier 
  LOGICAL, INTENT(OUT)       :: status    ! Logical flag:
                                          !    .TRUE. if datatype is a 
                                          !         variable string
                                          !    .FALSE. otherwise 
  INTEGER, INTENT(OUT) :: hdferr          ! Error code
END SUBROUTINE h5tis_variable_str_f
    History:
    Name: H5Tlock
    Signature:
    herr_t H5Tlock(hid_t type_id )
    Purpose:
    Locks a datatype.
    Description:
    H5Tlock locks the datatype specified by the type_id identifier, making it read-only and non-destructible. This is normally done by the library for predefined datatypes so the application does not inadvertently change or delete a predefined type. Once a datatype is locked it can never be unlocked.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface:
    None.
    Name: H5Topen
    Signature:
    hid_tH5Topen(hid_t loc_id, const char * name )
    Purpose:
    Opens a named datatype.
    Description:
    H5Topen opens a named datatype at the location specified by loc_id and returns an identifier for the datatype. loc_id is either a file or group identifier. The identifier should eventually be closed by calling H5Tclose to release resources.
    Parameters:
    Returns:
    Returns a named datatype identifier if successful; otherwise returns a negative value.
    Fortran90 Interface: h5topen_f 
    SUBROUTINE h5topen_f(loc_id, name, type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: loc_id    ! File or group identifier 
  CHARACTER(LEN=*), INTENT(IN) :: name    ! Datatype name within file or
                                          ! group
  INTEGER(HID_T), INTENT(out) :: type_id  ! Datatype identifier 
  INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                          ! 0 on success and -1 on failure
END SUBROUTINE h5topen_f
    Name: H5Tpack
    Signature:
    herr_t H5Tpack(hid_t type_id )
    Purpose:
    Recursively removes padding from within a compound datatype.
    Description:
    H5Tpack recursively removes padding from within a compound datatype to make it more efficient (space-wise) to store that data.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tpack_f 
    SUBROUTINE h5tpack_f(type_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tpack_f
    Name: H5Tregister
    Signature:
    herr_t H5Tregister(H5T_pers_t pers, const char * name, hid_t src_id, hid_t dst_id, H5T_conv_t func )
    Purpose:
    Registers a conversion function.
    Description:
    H5Tregister registers a hard or soft conversion function for a datatype conversion path.

    The parameter pers indicates whether a conversion function is hard (H5T_PERS_HARD) or soft (H5T_PERS_SOFT).

    A conversion path can have only one hard function. When pers is H5T_PERS_HARD, func replaces any previous hard function. If pers is H5T_PERS_HARD and func is the null pointer, then any hard function registered for this path is removed.

    When pers is H5T_PERS_SOFT, H5Tregister adds the function to the end of the master soft list and replaces the soft function in all applicable existing conversion paths. Soft functions are used when determining which conversion function is appropriate for this path.

    The name is used only for debugging and should be a short identifier for the function.

    The path is specified by the source and destination datatypes src_id and dst_id. For soft conversion functions, only the class of these types is important.

    The type of the conversion function pointer is declared as: 

    typedef herr_t (*H5T_conv_t) (hid_t src_id, 
                              hid_t dst_id, 
                              H5T_cdata_t *cdata,
                              size_t nelmts, 
                              size_t buf_stride, 
                              size_t bkg_stride, 
                              void *buf, 
                              void *bkg,
                              hid_t dset_xfer_plist)

    The H5T_cdata_t struct is declared as: 

    typedef struct *H5T_cdata_t (H5T_cmd_t command, 
                             H5T_bkg_t need_bkg, 
                             hbool_t *recalc,
                             void *priv)

    The H5T_conv_t parameters and the elements of the H5T_cdata_t struct are described more fully in the “Data Conversion” section of  “The Datatype Interface (H5T)” in the HDF5 User's Guide.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface:
    None.
    History:
    Name: H5Tset_cset
    Signature:
    herr_t H5Tset_cset(hid_t type_id, H5T_cset_t cset )
    Purpose:
    Sets character set to be used.
    Description:
    H5Tset_cset sets the character set to be used.

    HDF5 is able to distinguish between character sets of different nationalities and to convert between them to the extent possible. Valid character set types are:
             H5T_CSET_ASCII   (0)      Character set is US ASCII.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_cset_f 
    SUBROUTINE h5tset_cset_f(type_id, cset, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id 
                                  ! Datatype identifier 
  INTEGER, INTENT(IN) :: cset     ! Character set type of a string datatype  
                                  ! Possible values of padding type are:
                                  !    H5T_CSET_ASCII_F = 0
  INTEGER, INTENT(OUT) :: hdferr  ! Error code
END SUBROUTINE h5tset_cset_f
    Name: H5Tset_ebias
    Signature:
    herr_t H5Tset_ebias(hid_t type_id, size_t ebias )
    Purpose:
    Sets the exponent bias of a floating-point type.
    Description:
    H5Tset_ebias sets the exponent bias of a floating-point type.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_ebias_f 
    SUBROUTINE h5tset_ebias_f(type_id, ebias, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(IN) :: ebias          ! Datatype exponent bias 
                                        ! of a floating-point type, 
                                        ! which cannot be 0
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tset_ebias_f
    Name: H5Tset_fields
    Signature:
    herr_t H5Tset_fields(hid_t type_id, size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize )
    Purpose:
    Sets locations and sizes of floating point bit fields.
    Description:
    H5Tset_fields sets the locations and sizes of the various floating-point bit fields. The field positions are bit positions in the significant region of the datatype. Bits are numbered with the least significant bit number zero.

    Fields are not allowed to extend beyond the number of bits of precision, nor are they allowed to overlap with one another.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_fields_f 
    SUBROUTINE h5tset_fields_f(type_id, epos, esize, mpos, msize, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier
  INTEGER, INTENT(IN) :: epos           ! Exponent bit-position 
  INTEGER, INTENT(IN) :: esize          ! Size of exponent in bits
  INTEGER, INTENT(IN) :: mpos           ! Mantissa bit-position 
  INTEGER, INTENT(IN) :: msize          ! Size of mantissa in bits
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tset_fields_f
    Name: H5Tset_inpad
    Signature:
    herr_t H5Tset_inpad(hid_t type_id, H5T_pad_t inpad )
    Purpose:
    Fills unused internal floating point bits.
    Description:
    If any internal bits of a floating point type are unused (that is, those significant bits which are not part of the sign, exponent, or mantissa), then H5Tset_inpad will be filled according to the value of the padding value property inpad. Valid padding types are:
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_inpad_f 
    SUBROUTINE h5tset_inpad_f(type_id, padtype, hdferr)
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id 
                                  ! Datatype identifier 
  INTEGER, INTENT(IN) :: padtype  ! Padding type for unused bits 
                                  ! in floating-point datatypes.
                                  ! Possible values of padding type are:
                                  !    H5T_PAD_ZERO_F = 0
                                  !    H5T_PAD_ONE_F = 1
                                  !    H5T_PAD_BACKGROUND_F = 2
  INTEGER, INTENT(OUT) :: hdferr  ! Error code
END SUBROUTINE h5tset_inpad_f
    Name: H5Tset_norm
    Signature:
    herr_t H5Tset_norm(hid_t type_id, H5T_norm_t norm )
    Purpose:
    Sets the mantissa normalization of a floating-point datatype.
    Description:
    H5Tset_norm sets the mantissa normalization of a floating-point datatype. Valid normalization types are:
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_norm_f 
    SUBROUTINE h5tset_norm_f(type_id, norm, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  
                                  ! Datatype identifier 
  INTEGER, INTENT(IN) :: norm     ! Mantissa normalization of a 
                                  ! floating-point datatype
                                  ! Valid normalization types are:
                                  !    H5T_NORM_IMPLIED_F(0)
                                  !       MSB of mantissa is not stored,
                                  !       always 1 
                                  !    H5T_NORM_MSBSET_F(1) 
                                  !       MSB of mantissa is always 1 
                                  !    H5T_NORM_NONE_F(2)
                                  !       Mantissa is not normalized
  INTEGER, INTENT(OUT) :: hdferr  ! Error code
END SUBROUTINE h5tset_norm_f
    Name: H5Tset_offset
    Signature:
    herr_t H5Tset_offset(hid_t type_id, size_t offset )
    Purpose:
    Sets the bit offset of the first significant bit.
    Description:
    H5Tset_offset sets the bit offset of the first significant bit. The significant bits of an atomic datum can be offset from the beginning of the memory for that datum by an amount of padding. The `offset' property specifies the number of bits of padding that appear to the "right of" the value. That is, if we have a 32-bit datum with 16-bits of precision having the value 0x1122 then it will be laid out in memory as (from small byte address toward larger byte addresses):

    Byte Position Big-Endian Offset=0 Big-Endian Offset=16 Little-Endian Offset=0 Little-Endian Offset=16
    0: [ pad] [0x11] [0x22] [ pad]
    1: [ pad] [0x22] [0x11] [ pad]
    2: [0x11] [ pad] [ pad] [0x22]
    3: [0x22] [ pad] [ pad] [0x11]

    If the offset is incremented then the total size is incremented also if necessary to prevent significant bits of the value from hanging over the edge of the datatype.

    The offset of an H5T_STRING cannot be set to anything but zero.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_offset_f 
    SUBROUTINE h5tset_offset_f(type_id, offset, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(IN) :: offset         ! Datatype bit offset of 
                                        ! the first significant bit
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tset_offset_f
    Name: H5Tset_order
    Signature:
    herr_t H5Tset_order(hid_t dtype_id, H5T_order_t order )

    Purpose:
    Sets the byte order of an atomic datatype.

    Description:
    H5Tset_order sets the byte order of an atomic datatype.

    Byte orders currently supported are:

    H5T_ORDER_NONE (3) is also a valid value for order, but it has no effect. It is valid only for fixed-length strings and object and region references and specifies “no particular order.”

    Parameters:

    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.

    Fortran90 Interface: h5tset_order_f 
    SUBROUTINE h5tset_order_f(type_id, order, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id   ! Datatype identifier 
  INTEGER, INTENT(IN) :: order            ! Datatype byte order 
                                          ! Possible values are:
                                          !    H5T_ORDER_LE_F 
                                          !    H5T_ORDER_BE_F 
                                          !    H5T_ORDER_VAX_F  
  INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                          ! 0 on success and -1 on failure
END SUBROUTINE h5tset_order_f
    Name: H5Tset_overflow
    Signature:
    herr_t H5Tset_overflow(H5T_overflow_t func)
    Purpose:
    Sets the overflow handler to a specified function.
    Description:
    H5Tset_overflow sets the overflow handler to be the function specified by func. func will be called for all datatype conversions that result in an overflow.

    See the definition of H5T_overflow_t in H5Tpublic.h for documentation of arguments and return values. The prototype for H5T_overflow_t is as follows:
    herr_t (*H5T_overflow_t)(hid_t src_id, hid_t dst_id, void *src_buf, void *dst_buf);

    The NULL pointer may be passed to remove the overflow handler.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface:
    None.
    Name: H5Tset_pad
    Signature:
    herr_t H5Tset_pad(hid_t type_id, H5T_pad_t lsb, H5T_pad_t msb )
    Purpose:
    Sets the least and most-significant bits padding types.
    Description:
    H5Tset_pad sets the least and most-significant bits padding types.
      H5T_PAD_ZERO (0)
      Set background to zeros.
      H5T_PAD_ONE (1)
      Set background to ones.
      H5T_PAD_BACKGROUND (2)
      Leave background alone.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_pad_f 
    SUBROUTINE h5tset_pad_f(type_id, lsbpad, msbpad, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(IN) :: lsbpad         ! Padding type of the 
                                        ! least significant bit
  INTEGER, INTENT(IN) :: msbpad         ! Padding type of the 
                                        ! most significant bit
                                        ! Possible values of padding 
                                        ! type are:
                                        !    H5T_PAD_ZERO_F = 0
                                        !    H5T_PAD_ONE_F = 1
                                        !    H5T_PAD_BACKGROUND_F = 2
                                        !    H5T_PAD_ERROR_F = -1
                                        !    H5T_PAD_NPAD_F = 3
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tset_pad_f
    Name: H5Tset_precision
    Signature:
    herr_t H5Tset_precision(hid_t type_id, size_tprecision )
    Purpose:
    Sets the precision of an atomic datatype.
    Description:
    H5Tset_precision sets the precision of an atomic datatype. The precision is the number of significant bits which, unless padding is present, is 8 times larger than the value returned by H5Tget_size.

    If the precision is increased then the offset is decreased and then the size is increased to insure that significant bits do not "hang over" the edge of the datatype.

    Changing the precision of an H5T_STRING automatically changes the size as well. The precision must be a multiple of 8.

    When decreasing the precision of a floating point type, set the locations and sizes of the sign, mantissa, and exponent fields first.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_precision_f 
    SUBROUTINE h5tset_precision_f(type_id, precision, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  INTEGER, INTENT(IN) :: precision      ! Datatype precision
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tset_precision_f
    Name: H5Tset_sign
    Signature:
    herr_t H5Tset_sign(hid_t type_id, H5T_sign_t sign )
    Purpose:
    Sets the sign property for an integer type.
    Description:
    H5Tset_sign sets the sign property for an integer type.
    H5T_SGN_NONE (0)
    Unsigned integer type.
    H5T_SGN_2 (1)
    Two's complement signed integer type.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_sign_f 
    SUBROUTINE h5tset_sign_f(type_id, sign, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  
                                  ! Datatype identifier 
  INTEGER, INTENT(IN) :: sign     ! Sign type for an integer type 
                                  ! Possible values are:
                                  !    Unsigned integer type 
                                  !       H5T_SGN_NONE_F = 0
                                  !    Two's complement signed integer type
                                  !       H5T_SGN_2_F = 1
                                  !    or error value 
                                  !       H5T_SGN_ERROR_F=-1 
  INTEGER, INTENT(OUT) :: hdferr  ! Error code
END SUBROUTINE h5tset_sign_f
    Name: H5Tset_size
    Signature:
    herr_t H5Tset_size(hid_t type_id, size_tsize )
    Purpose:
    Sets the total size for an atomic datatype.
    Description:
    H5Tset_size sets the total size in bytes, size, for a datatype. If the datatype is atomic and size is decreased so that the significant bits of the datatype extend beyond the edge of the new size, then the `offset' property is decreased toward zero. If the `offset' becomes zero and the significant bits of the datatype still hang over the edge of the new size, then the number of significant bits is decreased. The size set for a string should include space for the null-terminator character, otherwise it will not be stored on (or retrieved from) disk. Adjusting the size of a string automatically sets the precision to 8*size. A compound datatype may increase in size, but may not shrink. All datatypes must have a positive size.
    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_size_f 
    SUBROUTINE h5tset_size_f(type_id, size, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier 
  INTEGER(SIZE_T), INTENT(IN) :: size    ! Datatype size
  INTEGER, INTENT(OUT) :: hdferr         ! Error code
                                         ! 0 on success and -1 on failure
END SUBROUTINE h5tset_size_f
    Name: H5Tset_strpad
    Signature:
    herr_t H5Tset_strpad(hid_t type_id, H5T_str_t strpad )
    Purpose:
    Defines the storage mechanism for character strings.
    Description:
    H5Tset_strpad defines the storage mechanism for the string.

    The method used to store character strings differs with the programming language:

    Valid string padding values, as passed in the parameter strpad, are as follows:

    When converting from a longer string to a shorter string, the behavior is as follows. If the short string is H5T_STR_NULLPAD or H5T_STR_SPACEPAD, then the string is simply truncated. If the short string is H5T_STR_NULLTERM, it is truncated and a null terminator is appended.

    When converting from a shorter string to a longer string, the long string is padded on the end by appending nulls or spaces.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_strpad_f 
    SUBROUTINE h5tset_strpad_f(type_id, strpad, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id 
                                 ! Datatype identifier 
  INTEGER, INTENT(IN) :: strpad  ! String padding method for a string datatype 
                                 ! Possible values of padding type are:
                                 !    Pad with zeros (as C does): 
                                 !       H5T_STR_NULLPAD_F(0)
                                 !    Pad with spaces (as FORTRAN does): 
                                 !       H5T_STR_SPACEPAD_F(1)
  INTEGER, INTENT(OUT) :: hdferr ! Error code
END SUBROUTINE h5tset_strpad_f
    Name: H5Tset_tag
    Signature:
    herr_t H5Tset_tag(hid_t type_id const char *tag )
    Purpose:
    Tags an opaque datatype.
    Description:
    H5Tset_tag tags an opaque datatype type_id with a descriptive ASCII identifier, tag.

    tag is intended to provide a concise description; the maximum size is hard-coded in the HDF5 Library as 256 bytes (H5T_OPAQUE_TAG_MAX).

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tset_tag_f 
    SUBROUTINE h5tset_tag_f(type_id, tag, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier 
  CHARACTER(LEN=*), INTENT(IN) :: tag   ! Unique ASCII string with which the
                                        ! opaque datatype is to be tagged 
  INTEGER, INTENT(OUT) :: hdferr        ! Error code
END SUBROUTINE h5tset_tag_f
    History:
    Name: H5Tunregister
    Signature:
    herr_t H5Tunregister(H5T_conv_t func )
    Purpose:
    Removes a conversion function from all conversion paths.
    Description:
    H5Tunregister removes a conversion function from all conversion paths.

    The conversion function pointer type declaration is described in H5Tregister.

    Parameters:
    Returns:
    Returns a non-negative value if successful; otherwise returns a negative value.
    Fortran90 Interface:
    None.
    History:
    Name: H5Tvlen_create
    Signature:
    hid_t H5Tvlen_create(hid_t base_type_id )
    Purpose:
    Creates a new variable-length datatype.
    Description:
    H5Tvlen_create creates a new variable-length (VL) datatype.

    The base datatype will be the datatype that the sequence is composed of, characters for character strings, vertex coordinates for polygon lists, etc. The base type specified for the VL datatype can be of any HDF5 datatype, including another VL datatype, a compound datatype or an atomic datatype.

    When necessary, use H5Tget_super to determine the base type of the VL datatype.

    The datatype identifier returned from this function should be released with H5Tclose or resource leaks will result.

    Parameters:
    See Also:
    H5Dget_vlen_buf_size
    H5Dvlen_reclaim
    Returns:
    Returns datatype identifier if successful; otherwise returns a negative value.
    Fortran90 Interface: h5tvlen_create_f 
    SUBROUTINE h5tvlen_create_f(type_id, vltype_id, hdferr) 
  IMPLICIT NONE
  INTEGER(HID_T), INTENT(IN) :: type_id    ! Datatype identifier of base type 
                                           ! Base type can only be atomic 
  INTEGER(HID_T), INTENT(OUT) :: vltype_id ! VL datatype identifier 
  INTEGER, INTENT(OUT) :: hdferr           ! Error code
END SUBROUTINE h5tvlen_create_f
    History:
    HDF5 documents and links 
    Introduction to HDF5 
    HDF5 User Guide 
    		 And in this document, the HDF5 Reference Manual  
      H5   H5A   H5D   H5E   H5F   H5G   H5I   H5P  
    H5R   H5S   H5T   H5Z   Tools   Datatypes  
    Collective Calls in Parallel  
    (PDF of complete manual formatted as print volume)   
    The HDF Group Help Desk:
    Describes HDF5 Release 1.6.10, November 2009