HDF5/H5T API Specification

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

# 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 Atomic Datatype Properties h5tset_size_f h5tget_order_f h5tset_order_f h5tget_precision_f h5tset_precision_f h5tget_offset_f h5tset_offset_f |  | Atomic (continued) 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_name_f h5tget_member_offset_f h5tget_member_type_f h5tinsert_f h5tpack_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 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:

hid_t `base`
  IN: Datatype identifier for the array base datatype.
int `rank`
  IN: Rank of the array.
const hsize_t `dims[/*rank*/]`
  IN: Size of each array dimension.
const int `perm[/*rank*/]`
  IN: Dimension permutation. (Currently not implemented.)

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

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:

hid_t `type_id`
  Identifier of datatype to release.

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_t`H5Tcommit`(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.
Parameters:

hid_t `loc_id`
  IN: A file or group identifier.
const char * `name`
  IN: A datatype name.
hid_t `type`
  IN: A datatype identifier.

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_t`H5Tcommitted`(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:

hid_t `type`
  IN: Datatype identifier.

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`, hsize_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:

hid_t `src_id`
  Identifier for the source datatype.
hid_t `dst_id`
  Identifier for the destination datatype.
hsize_t `nelmts`
  Size of array `buf`.
void *`buf`
  Array containing pre- and post-conversion values.
void *`background`
  Optional background buffer.
hid_t `plist_id`
  Dataset transfer property list identifier.

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

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:

hid_t `type_id`
  Identifier of datatype to copy. Can be a datatype identifier, a predefined datatype (defined in `H5Tpublic.h`), or a dataset identifier.

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_t`size` )
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:

  - `H5T_COMPOUND`
  - `H5T_OPAQUE`
  - `H5T_ENUM`

  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:

H5T_class_t `class`
  Class of datatype to create.
size_t `size`
  The number of bytes in the datatype to create.

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_t`dtype_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:

hid_t `dtype_id`
  Datatype identifier.
H5T_class_t`dtype_class`
  Datatype class.

Returns:
  Returns `TRUE` or `FALSE` if successful; otherwise returns a negative value.
Fortran90 Interface:
  None.

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:

hid_t `parent_id`
  IN: Datatype identifier for the base datatype.

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:

hid_t `type`
  IN: Datatype identifier for the enumeration datatype.
const char *`name`
  IN: Name of the new member.
void *`value`
  IN: Pointer to the value of the new member.

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:

hid_t `type`
  IN: Enumeration datatype identifier.
void *`value`,
  IN: Value of the enumeration datatype.
char *`name`,
  OUT: Buffer for output of the symbol name.
size_t `size`
  IN: Anticipated size of the symbol name, in bytes (characters).

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,  name, namelen, value, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: type_id  ! Datatype identifier
        CHARACTER(LEN=*), INTENT(OUT) :: name  ! Name of the  enumeration datatype
        INTEGER(SIZE_T), INTENT(IN) :: namelen ! Length of the name
        INTEGER, INTENT(IN) :: value           ! Value 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:

hid_t `type`
  IN: Enumeration datatype identifier.
const char *`name`,
  IN: Symbol name of the enumeration datatype.
void *`value`,
  OUT: Buffer for output of the value of the enumeration datatype.

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_t`type_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:

hid_t `type_id1`
  Identifier of datatype to compare.
hid_t `type_id2`
  Identifier of datatype to compare.

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:

hid_t `src_id`
  IN: Identifier for the source datatype.
hid_t `dst_id`
  IN: Identifier for the destination datatype.
H5T_cdata_t **`pcdata`
  OUT: Pointer to type conversion data.

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:

hid_t `adtype_id`
  IN: Datatype identifier of array object.
hsize_t *`dims[]`
  OUT: Sizes of array dimensions.
int *`perm[]`
  OUT: Dimension permutations.

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

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:

hid_t `adtype_id`
  IN: Datatype identifier of array object.

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

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:

  - `H5T_INTEGER`
  - `H5T_FLOAT`
  - `H5T_TIME`
  - `H5T_STRING`
  - `H5T_BITFIELD`
  - `H5T_OPAQUE`
  - `H5T_COMPOUND`
  - `H5T_REFERENCE`
  - `H5T_ENUM`
  - `H5T_VLEN`
  - `H5T_ARRAY`
Parameters:

hid_t `type_id`
  Identifier of datatype to query.

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:

hid_t `type_id`
  Identifier of datatype to query.

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:

hid_t `type_id`
  Identifier of datatype to query.

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:

hid_t `type_id`
  IN: Identifier of datatype to query.
size_t *`spos`
  OUT: Pointer to location to return floating-point sign bit.
size_t *`epos`
  OUT: Pointer to location to return exponent bit-position.
size_t *`esize`
  OUT: Pointer to location to return size of exponent in bits.
size_t *`mpos`
  OUT: Pointer to location to return mantissa bit-position.
size_t *`msize`
  OUT: Pointer to location to return size of mantissa in bits.

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:
  H5T_PAD_ZERO (`0`)
    Set background to zeros.
  H5T_PAD_ONE (`1`)
    Set background to ones.
  H5T_PAD_BACKGROUND (`2`)
    Leave background alone.
Parameters:

hid_t `type_id`
  Identifier of datatype to query.

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`, int `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`.
Parameters:

hid_t `cdtype_id`
  IN: Datatype identifier of compound object.
int `member_no`
  IN: Compound object member number.

Returns:
  Returns the datatype class, a non-negative value, if successful; otherwise returns a negative value.
Fortran90 Interface:
  None.

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:

hid_t `type_id`
  Identifier of datatype to query.
const char * `field_name`
  Name of the field or member whose index is to be retrieved.

Returns:
  Returns a valid field or member index if successful; otherwise returns a negative value.
Fortran90 Interface:
  None.

Name: H5Tget_member_name
Signature:
  char * `H5Tget_member_name`(hid_t `type_id`, int `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:

hid_t `type_id`
  Identifier of datatype to query.
int `field_idx`
  Zero-based index of the field or element whose name is to be retrieved.

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

Name: H5Tget_member_offset
Signature:
  size_t `H5Tget_member_offset`(hid_t `type_id`, int `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:

hid_t `type_id`
  Identifier of datatype to query.
int `memb_no`
  Number of the field whose offset is requested.

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

Name: H5Tget_member_type
Signature:
  hid_t `H5Tget_member_type`(hid_t `type_id`, int `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:

hid_t `type_id`
  Identifier of datatype to query.
int `field_idx`
  Field index (0-based) of the field type to retrieve.

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

Name: H5Tget_member_value
Signature:
  hid_t `H5Tget_member_value`(hid_t `type` int `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:

hid_t `type`
  IN: Datatype identifier for the enumeration datatype.
int `memb_no`,
  IN: Number of the enumeration datatype member.
void *`value`
  OUT: Pointer to a buffer for output of the value of the enumeration datatype member.

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

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.

  `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 intenger and floating point datatypes. Time, bifield, 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:

hid_t `type_id`
  Datatype identifier for the dataset datatype.
H5T_direction_t `direction`
  Direction of search.

Returns:
  Returns the native datatype identifier for the specified dataset datatype if successful; otherwise returns a negative value.
Fortran90 Interface:
  None.

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:

hid_t `type_id`
  Identifier of datatype to query.

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:
  H5T_NORM_IMPLIED (`0`)
    MSB of mantissa is not stored, always 1
  H5T_NORM_MSBSET (`1`)
    MSB of mantissa is always 1
  H5T_NORM_NONE (`2`)
    Mantissa is not normalized
Parameters:

hid_t `type_id`
  Identifier of datatype to query.

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:

hid_t `type_id`
  Identifier of datatype to query.

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 `type_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:

  `H5T_ORDER_LE` (`0`)
    Little endian byte ordering (default).
  `H5T_ORDER_BE` (`1`)
    Big endian byte ordering.
  `H5T_ORDER_VAX` (`2`)
    VAX mixed byte ordering (not currently supported).
Parameters:

hid_t `type_id`
  Identifier of datatype to query.

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:
  H5T_PAD_ZERO (`0`)
    Set background to zeros.
  H5T_PAD_ONE (`1`)
    Set background to ones.
  H5T_PAD_BACKGROUND (`2`)
    Leave background alone.
Parameters:

hid_t `type_id`
  IN: Identifier of datatype to query.
H5T_pad_t * `lsb`
  OUT: Pointer to location to return least-significant bit padding type.
H5T_pad_t * `msb`
  OUT: Pointer to location to return most-significant bit padding type.

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:

hid_t `type_id`
  Identifier of datatype to query.

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:
  H5T_SGN_NONE (`0`)
    Unsigned integer type.
  H5T_SGN_2 (`1`)
    Two's complement signed integer type.
Parameters:

hid_t `type_id`
  Identifier of datatype to query.

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:

hid_t `type_id`
  Identifier of datatype to query.

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:

hid_t `type_id`
  Identifier of datatype to query.

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:

hid_t `type`
  Datatype identifier for the derived datatype.

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:

hid_t `type_id`
  Datatype identifier for the opaque datatype.

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:

hid_t `type_id`
  Identifier of compound datatype to modify.
const char * `name`
  Name of the field to insert.
size_t `offset`
  Offset in memory structure of the field to insert.
hid_t `field_id`
  Datatype identifier of the field to insert.

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:
  `H5Tvlen_create` 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:

hid_t `dtype_id`
  Datatype identifier.

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
                                                !         varibale string
                                                !    .FALSE. otherwise
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
      END SUBROUTINE h5tis_variable_str_f

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:

hid_t `type_id`
  Identifier of datatype to lock.

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

Name: H5Topen
Signature:
  hid_t`H5Topen`(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:

hid_t `loc_id`
  IN: A file or group identifier.
const char * `name`
  IN: A datatype name, defined within the file or group identified by `loc_id`.

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:

hid_t `type_id`
  Identifier of datatype to modify.

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,
                                    hsize_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:

H5T_pers_t `pers`
  `H5T_PERS_HARD` for hard conversion functions; `H5T_PERS_SOFT` for soft conversion functions.
const char * `name`
  Name displayed in diagnostic output.
hid_t `src_id`
  Identifier of source datatype.
hid_t `dst_id`
  Identifier of destination datatype.
H5T_conv_t `func`
  Function to convert between source and destination datatypes.

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

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` 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:

hid_t `type_id`
  Identifier of datatype to modify.
H5T_cset_t `cset`
  Character set type.

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:

hid_t `type_id`
  Identifier of datatype to set.
size_t `ebias`
  Exponent bias value.

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:

hid_t `type_id`
  Identifier of datatype to set.
size_t `spos`
  Sign position, i.e., the bit offset of the floating-point sign bit.
size_t `epos`
  Exponent bit position.
size_t `esize`
  Size of exponent in bits.
size_t `mpos`
  Mantissa bit position.
size_t `msize`
  Size of mantissa in bits.

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:
  H5T_PAD_ZERO (`0`)
    Set background to zeros.
  H5T_PAD_ONE (`1`)
    Set background to ones.
  H5T_PAD_BACKGROUND (`2`)
    Leave background alone.
Parameters:

hid_t `type_id`
  Identifier of datatype to modify.
H5T_pad_t `pad`
  Padding type.

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:
  H5T_NORM_IMPLIED (`0`)
    MSB of mantissa is not stored, always 1
  H5T_NORM_MSBSET (`1`)
    MSB of mantissa is always 1
  H5T_NORM_NONE (`2`)
    Mantissa is not normalized
Parameters:

hid_t `type_id`
  Identifier of datatype to set.
H5T_norm_t `norm`
  Mantissa normalization type.

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:

hid_t `type_id`
  Identifier of datatype to set.
size_t `offset`
  Offset of first significant bit.

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 `type_id`, H5T_order_t`order` )
Purpose:
  Sets the byte ordering of an atomic datatype.
Description:
  `H5Tset_order` sets the byte ordering of an atomic datatype. Byte orderings currently supported are:
  H5T_ORDER_LE (`0`)
    Little-endian byte ordering (default).
  H5T_ORDER_BE (`1`)
    Big-endian byte ordering.
  H5T_ORDER_VAX (`2`)
    VAX mixed byte ordering (not currently supported).
Parameters:

hid_t `type_id`
  Identifier of datatype to set.
H5T_order_t `order`
  Byte ordering constant.

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:

H5T_overflow_t `func`
  Overflow function.

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:

hid_t `type_id`
  Identifier of datatype to set.
H5T_pad_t `lsb`
  Padding type for least-significant bits.
H5T_pad_t `msb`
  Padding type for most-significant bits.

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_t`precision` )
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:

hid_t `type_id`
  Identifier of datatype to set.
size_t `precision`
  Number of bits of precision for datatype.

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:

hid_t `type_id`
  Identifier of datatype to set.
H5T_sign_t `sign`
  Sign type.

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_t`size` )
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:

hid_t `type_id`
  Identifier of datatype to change size.
size_t `size`
  Size in bytes to modify datatype.

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:

  - C usually null terminates strings while
  - Fortran left-justifies and space-pads strings.
  Valid string padding values, as passed in the parameter `strpad`, are as follows:
  H5T_STR_NULLTERM (`0`)
    Null terminate (as C does)
  H5T_STR_NULLPAD (`1`)
    Pad with zeros
  H5T_STR_SPACEPAD (`2`)
    Pad with spaces (as FORTRAN does)

  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:

hid_t `type_id`
  Identifier of datatype to modify.
H5T_str_t `strpad`
  String padding type.

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):
                                       !r      H5T_STR_NULLPAD_(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`.
Parameters:

hid_t `type_id`
  IN: Datatype identifier for the opaque datatype to be tagged.
const char *`tag`
  IN: Descriptive ASCII string with which the opaque datatype is to be tagged.

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

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:

H5T_conv_t `func`
  Function to remove from conversion paths.

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

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:

hid_t `base_type_id`
  Base type of datatype to create.

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

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