|
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 |
The C Interfaces:
|
|
|
|
|
General Datatype Operations
Enumeration Datatypes |
Atomic Datatype Properties
|
Array Datatypes
Compound Datatype Properties Variable-length Datatypes Opaque Datatypes |
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.
H5Tarray_create(
hid_t base,
int rank,
const hsize_t dims[/*rank*/],
const int perm[/*rank*/]
)
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.)
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.) |
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
H5Tclose(hid_t type_id
)
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.
hid_t type_id |
Identifier of datatype to release. |
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
H5Tcommit(hid_t loc_id,
const char * name,
hid_t type
)
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.
hid_t loc_id |
IN: A file or group identifier. |
const char * name |
IN: A datatype name. |
hid_t type |
IN: A datatype identifier. |
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
H5Tcommitted(hid_t type)
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.
hid_t type |
IN: Datatype identifier. |
TRUE,
if the datatype has been committed, or 0 (zero),
for FALSE, if the datatype has not been committed.
Otherwise returns a negative value.
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
H5Tconvert(hid_t src_id,
hid_t dst_id,
size_t nelmts,
void *buf,
void *background,
hid_t plist_id
)
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.
hid_t src_id |
Identifier for the source datatype. |
hid_t dst_id |
Identifier for the destination datatype. |
size_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. |
H5Tcopy(hid_t type_id)
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.
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. |
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
H5Tcreate(H5T_class_t class,
size_tsize
)
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.
H5T_class_t class |
Class of datatype to create. |
size_t size |
The number of bytes in the datatype to create. |
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
H5Tdetect_class(hid_t dtype_id,
H5T_class_tdtype_class
)
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.
hid_t dtype_id |
Datatype identifier. |
H5T_class_t dtype_class |
Datatype class. |
TRUE or FALSE if successful;
otherwise returns a negative value.
H5Tenum_create(hid_t parent_id
)
H5Tenum_create creates a new enumeration datatype
based on the specified base datatype, parent_id,
which must be an integer type.
hid_t parent_id |
IN: Datatype identifier for the base datatype. |
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
H5Tenum_insert(hid_t type,
const char *name,
void *value
)
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.
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. |
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
H5Tenum_nameof(hid_t type
void *value,
char *name,
size_t size
)
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.
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). |
size allows it,
the first character of name is
set to NULL.
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
H5Tenum_valueof(hid_t type
char *name,
void *value
)
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.
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. |
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
H5Tequal(hid_t type_id1,
hid_ttype_id2
)
H5Tequal determines whether two datatype identifiers
refer to the same datatype.
hid_t type_id1 |
Identifier of datatype to compare. |
hid_t type_id2 |
Identifier of datatype to compare. |
TRUE,
if the datatype identifiers refer to the same datatype,
or 0 (zero), for FALSE.
Otherwise returns a negative value.
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
H5Tfind(hid_t src_id,
hid_t dst_id,
H5T_cdata_t **pcdata
)
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.
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. |
H5Tget_array_dims(
hid_t adtype_id,
hsize_t *dims[],
int *perm[]
)
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.
hid_t adtype_id |
IN: Datatype identifier of array object. |
hsize_t *dims[] |
OUT: Sizes of array dimensions. |
int *perm[] |
OUT: Dimension permutations. |
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
H5Tget_array_ndims(
hid_t adtype_id
)
H5Tget_array_ndims returns the rank,
the number of dimensions, of an array datatype object.
hid_t adtype_id |
IN: Datatype identifier of array object. |
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
H5Tget_class(hid_t type_id
)
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
Note that the library returns H5T_STRING
for both fixed-length and variable-length strings.
hid_t type_id |
Identifier of datatype to query. |
H5T_NO_CLASS (-1).
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
H5Tget_cset(hid_t type_id
)
H5Tget_cset retrieves the character set type
of a string datatype. Valid character set types are:
0)
hid_t type_id |
Identifier of datatype to query. |
H5T_CSET_ERROR (-1).
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
H5Tget_ebias(hid_t type_id
)
H5Tget_ebias retrieves the exponent bias of a floating-point type.
hid_t type_id |
Identifier of datatype to query. |
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
H5Tget_fields(hid_t type_id,
size_t *spos,
size_t *epos,
size_t *esize,
size_t *mpos,
size_t *msize
)
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.
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. |
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
H5Tget_inpad(hid_t type_id
)
H5Tget_inpad retrieves the internal padding type for
unused bits in floating-point datatypes.
Valid padding types are:
0)
1)
2)
hid_t type_id |
Identifier of datatype to query. |
H5T_PAD_ERROR (-1).
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
H5Tget_member_class(
hid_t cdtype_id,
unsigned member_no
)
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.
hid_t cdtype_id |
IN: Datatype identifier of compound object. |
unsigned member_no |
IN: Compound object member number. |
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
H5Tget_member_index(hid_t type_id,
const char * field_name
)
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.
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. |
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
H5Tget_member_name(hid_t type_id,
unsigned field_idx
)
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.
hid_t type_id |
Identifier of datatype to query. |
unsigned field_idx |
Zero-based index of the field or element whose name is to be retrieved. |
malloc() if successful;
otherwise returns NULL.
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
H5Tget_member_offset(hid_t type_id,
unsigned memb_no
)
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.
hid_t type_id |
Identifier of datatype to query. |
unsigned memb_no |
Number of the field whose offset is requested. |
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.
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
H5Tget_member_type(hid_t type_id,
unsigned field_idx
)
H5Tget_member_type returns the datatype of the specified member. The caller
should invoke H5Tclose() to release resources associated with the type.
hid_t type_id |
Identifier of datatype to query. |
unsigned field_idx |
Field index (0-based) of the field type to retrieve. |
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
H5Tget_member_value(hid_t type
unsigned memb_no,
void *value
)
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.
hid_t type |
IN: Datatype identifier for the enumeration datatype. |
unsigned 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. |
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
H5Tget_native_type(hid_t type_id,
H5T_direction_t direction
)
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.
hid_t type_id |
Datatype identifier for the dataset datatype. |
H5T_direction_t direction |
Direction of search. |
H5Tget_nmembers(hid_t type_id
)
H5Tget_nmembers retrieves
the number of fields in a compound datatype or
the number of members of an enumeration datatype.
hid_t type_id |
Identifier of datatype to query. |
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
H5Tget_norm(hid_t type_id
)
H5Tget_norm retrieves the mantissa normalization of
a floating-point datatype. Valid normalization types are:
0)
1)
2)
hid_t type_id |
Identifier of datatype to query. |
H5T_NORM_ERROR (-1).
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
H5Tget_offset(hid_t type_id
)
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] |
hid_t type_id |
Identifier of datatype to query. |
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
H5Tget_order(hid_t type_id
)
H5Tget_order returns the byte order of an
atomic datatype.
Possible return values are:
H5T_ORDER_LE (0)
H5T_ORDER_BE (1)
H5T_ORDER_VAX (2)
hid_t type_id |
Identifier of datatype to query. |
H5T_ORDER_ERROR (-1).
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
H5Tget_overflow(void)
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.
H5Tget_pad(hid_t type_id,
H5T_pad_t * lsb,
H5T_pad_t * msb
)
H5Tget_pad retrieves the padding type of the least and most-significant
bit padding. Valid types are:
0)
1)
2)
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. |
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
H5Tget_precision(hid_t type_id
)
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().
hid_t type_id |
Identifier of datatype to query. |
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
H5Tget_sign(hid_t type_id
)
H5Tget_sign retrieves the sign type for an integer type.
Valid types are:
0)
1)
hid_t type_id |
Identifier of datatype to query. |
H5T_SGN_ERROR (-1).
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
H5Tget_size(hid_t type_id
)
H5Tget_size returns the size of a datatype in bytes.
hid_t type_id |
Identifier of datatype to query. |
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
H5Tget_strpad(hid_t type_id
)
H5Tget_strpad retrieves the storage mechanism
for a string datatype, as defined in
H5Tset_strpad.
hid_t type_id |
Identifier of datatype to query. |
H5T_STR_ERROR (-1).
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
H5Tget_super(hid_t type
)
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.
hid_t type |
Datatype identifier for the derived datatype. |
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
H5Tget_tag(hid_t type_id
)
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.
hid_t type_id |
Datatype identifier for the opaque datatype. |
NULL.
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
H5Tinsert(hid_t type_id,
const char * name,
size_t offset,
hid_t field_id
)
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.
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. |
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
H5Tis_variable_str(hid_t dtype_id
)
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.
hid_t dtype_id |
Datatype identifier. |
TRUE or FALSE if successful;
otherwise returns a negative value.
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
H5Tlock(hid_t type_id
)
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.
hid_t type_id |
Identifier of datatype to lock. |
H5Topen(hid_t loc_id,
const char * name
)
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.
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. |
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
H5Tpack(hid_t type_id
)
H5Tpack recursively removes padding from within a compound
datatype to make it more efficient (space-wise) to store that data.
hid_t type_id |
Identifier of datatype to modify. |
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
H5Tregister(H5T_pers_t pers,
const char * name,
hid_t src_id,
hid_t dst_id,
H5T_conv_t func
)
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:
typedefherr_t (*H5T_conv_t) (hid_tsrc_id, hid_tdst_id, H5T_cdata_t *cdata, size_tnelmts, size_tbuf_stride, size_tbkg_stride, void *buf, void *bkg, hid_tdset_xfer_plist)
The H5T_cdata_t struct is declared as:
typedefstruct*H5T_cdata_t(H5T_cmd_tcommand, H5T_bkg_tneed_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.
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. |
H5Tset_cset(hid_t type_id,
H5T_cset_t cset
)
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:
0)
hid_t type_id |
Identifier of datatype to modify. |
H5T_cset_t cset |
Character set type. |
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
H5Tset_ebias(hid_t type_id,
size_t ebias
)
H5Tset_ebias sets the exponent bias of a floating-point type.
hid_t type_id |
Identifier of datatype to set. |
size_t ebias |
Exponent bias value. |
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
H5Tset_fields(hid_t type_id,
size_t spos,
size_t epos,
size_t esize,
size_t mpos,
size_t msize
)
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.
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. |
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
H5Tset_inpad(hid_t type_id,
H5T_pad_t inpad
)
H5Tset_inpad will be filled
according to the value of the padding value property inpad.
Valid padding types are:
0)
1)
2)
hid_t type_id |
Identifier of datatype to modify. |
H5T_pad_t pad |
Padding type. |
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
H5Tset_norm(hid_t type_id,
H5T_norm_t norm
)
H5Tset_norm sets the mantissa normalization of
a floating-point datatype. Valid normalization types are:
0)
1)
2)
hid_t type_id |
Identifier of datatype to set. |
H5T_norm_t norm |
Mantissa normalization type. |
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
H5Tset_offset(hid_t type_id,
size_t offset
)
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.
hid_t type_id |
Identifier of datatype to set. |
size_t offset |
Offset of first significant bit. |
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
H5Tset_order(hid_t type_id,
H5T_order_torder
)
H5Tset_order sets the byte ordering of an atomic datatype.
Byte orderings currently supported are:
0)
1)
2)
hid_t type_id |
Identifier of datatype to set. |
H5T_order_t order |
Byte ordering constant. |
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
H5Tset_overflow(H5T_overflow_t func)
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.
H5T_overflow_t func |
Overflow function. |
H5Tset_pad(hid_t type_id,
H5T_pad_t lsb,
H5T_pad_t msb
)
H5Tset_pad sets the least and most-significant bits padding types.
0)
1)
2)
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. |
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
H5Tset_precision(hid_t type_id,
size_tprecision
)
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.
hid_t type_id |
Identifier of datatype to set. |
size_t precision |
Number of bits of precision for datatype. |
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
H5Tset_sign(hid_t type_id,
H5T_sign_t sign
)
H5Tset_sign sets the sign property for an integer type.
0)
1)
hid_t type_id |
Identifier of datatype to set. |
H5T_sign_t sign |
Sign type. |
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
H5Tset_size(hid_t type_id,
size_tsize
)
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.
hid_t type_id |
Identifier of datatype to change size. |
size_t size |
Size in bytes to modify datatype. |
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
H5Tset_strpad(hid_t type_id,
H5T_str_t strpad
)
H5Tset_strpad defines the storage mechanism for the string.
The method used to store character strings differs with the programming language:
strpad, are as follows:
0)
1)
2)
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.
hid_t type_id |
Identifier of datatype to modify. |
H5T_str_t strpad |
String padding type. |
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
H5Tset_tag(hid_t type_id
const char *tag
)
H5Tset_tag tags an opaque datatype type_id
with a descriptive ASCII identifier, tag.
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. |
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
H5Tunregister(H5T_conv_t func
)
H5Tunregister removes a conversion function from all conversion paths.
The conversion function pointer type declaration is described in H5Tregister.
H5T_conv_t func |
Function to remove from conversion paths. |
H5Tvlen_create(hid_t base_type_id
)
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.
hid_t base_type_id |
Base type of datatype to create. |
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 |