summaryrefslogtreecommitdiffstats
path: root/src/H5T.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/H5T.c')
-rw-r--r--src/H5T.c1702
1 files changed, 842 insertions, 860 deletions
diff --git a/src/H5T.c b/src/H5T.c
index 7c6fdb6..cc19d1a 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -14,47 +14,24 @@
static char RcsId[] = "@(#)$Revision$";
#endif
-/* $Id$ */
-
-/*LINTLIBRARY */
-/*+
- FILE
- H5T.c
- HDF5 Data-type routines
-
- EXPORTED ROUTINES
- H5Tget_num_fields -- Get the number of fields in a compound datatype
- H5Tis_field_atomic -- Check if a field is atomic
- H5Tis_atomic/H5T_is_atomic -- Check if a datatype is atomic
- H5Tset_type -- Set the base type of a user-defined datatype
- H5Tget_type -- Get the base type of a datatype
- H5Tadd_field -- Add a field to a compound datatype
- H5Tsize -- Determine the size of a datatype
-
- LIBRARY-SCOPED ROUTINES
- H5T_create -- (Meta-Object) Create a datatype
- H5T_release -- (Meta-Object) Release access to a datatype
-
- LOCAL ROUTINES
- H5T_init_interface -- initialize the interface
- + */
-
-#include <H5private.h> /* Generic Functions */
-#include <H5Aprivate.h> /* Atom functions */
-#include <H5Eprivate.h> /* Error handling */
-#include <H5Mprivate.h> /* Meta data */
-#include <H5Pprivate.h> /* Data space */
-#include <H5Tprivate.h> /* Data-type functions */
+#define H5T_PACKAGE /*suppress error about including H5Tpkg */
+
+#include <H5private.h> /*generic functions */
+#include <H5Aprivate.h> /*atom functions */
+#include <H5Eprivate.h> /*error handling */
+#include <H5Mprivate.h> /*meta data */
+#include <H5MMprivate.h> /*memory management */
+#include <H5Pprivate.h> /*data space */
+#include <H5Tpkg.h> /*data-type functions */
#define PABLO_MASK H5T_mask
-/*--------------------- Locally scoped variables -----------------------------*/
+#define H5T_COMPND_INC 64 /*typical max numb of members per struct*/
-/* Whether we've installed the library termination function yet for this interface */
+/* Interface initialization */
static intn interface_initialize_g = FALSE;
-
-/*------------------_-- Local function prototypes ----------------------------*/
-static herr_t H5T_init_interface(void);
+#define INTERFACE_INIT H5T_init_interface
+static void H5T_term_interface (void);
/*--------------------------------------------------------------------------
NAME
@@ -68,40 +45,24 @@ DESCRIPTION
Initializes any interface-specific data or routines.
--------------------------------------------------------------------------*/
-static herr_t H5T_init_interface(void)
+herr_t
+H5T_init_interface (void)
{
- herr_t ret_value = SUCCEED;
- FUNC_ENTER (H5T_init_interface, NULL, FAIL);
-
- /* Initialize the atom group for the file IDs */
- if((ret_value=H5Ainit_group(H5_DATATYPE,H5A_DATATYPEID_HASHSIZE,H5T_RESERVED_ATOMS,H5T_destroy))!=FAIL)
- ret_value=H5_add_exit(&H5T_term_interface);
-
- FUNC_LEAVE(ret_value);
-} /* H5T_init_interface */
-
-/*--------------------------------------------------------------------------
-NAME
- H5T_init -- Make certain that the interface has been initialized
-USAGE
- herr_t H5T_init()
+ herr_t ret_value = SUCCEED;
+ FUNC_ENTER (H5T_init_interface, FAIL);
+
+ /* Initialize the atom group for the file IDs */
+ if ((ret_value=H5Ainit_group (H5_DATATYPE, H5A_DATATYPEID_HASHSIZE,
+ H5T_RESERVED_ATOMS,
+ (herr_t (*)(void*))H5T_close))!=FAIL) {
+ ret_value=H5_add_exit (&H5T_term_interface);
+ }
+
+ /* Initialize pre-defined data types */
+ ret_value = H5T_init ();
-RETURNS
- SUCCEED/FAIL
-DESCRIPTION
- Library public routine to make certain the H5T interface has been properly
- initialized.
-
---------------------------------------------------------------------------*/
-herr_t H5T_init(void)
-{
- herr_t ret_value = SUCCEED;
- FUNC_ENTER (H5T_init, H5T_init_interface, FAIL);
-
- /* Actual work is done in the FUNC_ENTER macro */
-
- FUNC_LEAVE(ret_value);
-} /* H5T_init */
+ FUNC_LEAVE (ret_value);
+}
/*--------------------------------------------------------------------------
NAME
@@ -120,814 +81,835 @@ herr_t H5T_init(void)
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
-void H5T_term_interface (void)
+static void
+H5T_term_interface (void)
{
- H5Adestroy_group(H5_DATATYPE);
-} /* end H5T_term_interface() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5T_create
- PURPOSE
- Create a new HDF5 data-type object
- USAGE
- hid_t H5T_create(owner_id, type, name)
- hid_t owner_id; IN: Group/file which owns this object
- hobjtype_t type; IN: Type of object to create
- const char *name; IN: Name of the object
- RETURNS
- Returns ID (atom) on success, FAIL on failure
- DESCRIPTION
- This function actually creates the data-type object.
---------------------------------------------------------------------------*/
-hid_t H5T_create(hid_t owner_id, hobjtype_t type, const char *name)
-{
- h5_datatype_t *new_dt; /* new data-type object to create */
- hid_t ret_value = SUCCEED;
-
- FUNC_ENTER(H5T_create, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- /* Allocate space for the new data-type */
- if((new_dt=HDmalloc(sizeof(h5_datatype_t)))==NULL)
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
-
- /* Initialize the datatype */
- new_dt->dt.base=0; /* No Default datatype */
- new_dt->name=HDstrdup(name); /* Make a copy of the datatype's name */
- new_dt->ci=NULL; /* Set the complex information to NULL */
-
- /* Register the new datatype and get an ID for it */
- if((ret_value=H5Aregister_atom(H5_DATATYPE, (const VOIDP)new_dt))==FAIL)
- HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL);
-
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5T_create() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5Tget_num_fields
- PURPOSE
- Return the number of fields in a compound datatype
- USAGE
- uint32 H5Tget_num_fields(tid)
- hid_t tid; IN: Datatype object to query
- RETURNS
- The number of fields in a compound datatype on success, UFAIL on failure
- DESCRIPTION
- This function checks the number of fields in a compound user-defined
- datatype. UFAIL is returned on an error or if an atomic datatype is
- queried, otherwise the number of fields is returned.
---------------------------------------------------------------------------*/
-uint32 H5Tget_num_fields(hid_t tid)
+ H5Adestroy_group (H5_DATATYPE);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tcreate
+ *
+ * Purpose: Create a new type and initialize it to reasonable values.
+ * The type is a member of type class TYPE and is SIZE bytes.
+ *
+ * Return: Success: A new type identifier.
+ *
+ * Failure: FAIL
+ *
+ * Errors:
+ * ARGS BADVALUE Invalid size.
+ * DATATYPE CANTINIT Can't create type.
+ * DATATYPE CANTREGISTER Can't register data type atom.
+ *
+ * Programmer: Robb Matzke
+ * Friday, December 5, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Tcreate (H5T_class_t type, size_t size)
{
- h5_datatype_t *dt; /* new data-type object to create */
- uint32 ret_value = UFAIL;
-
- FUNC_ENTER(H5Tget_num_fields, H5T_init_interface, UFAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
- /* Check the base type of the datatype */
- if(H5T_COMPOUND!=dt->dt.base)
- HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
-
- /* Check if the compound information has been initialized */
- if(NULL==dt->ci)
- HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, FAIL);
-
- /* Grab the number of fields */
- ret_value=dt->ci->n;
-
-done:
- if(ret_value == UFAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tget_num_fields() */
+ H5T_t *dt = NULL;
+ hid_t ret_value = FAIL;
+
+ FUNC_ENTER (H5Tcreate, FAIL);
-/*--------------------------------------------------------------------------
- NAME
- H5Tis_field_atomic
- PURPOSE
- Check if a field in a compound datatype is atomic
- USAGE
- hbool_t H5Tis_field_atomic(tid, fidx)
- hid_t tid; IN: Datatype object to query
- uintn fidx; IN: Index of the field to query
- RETURNS
- BFAIL/BTRUE/BFALSE
- DESCRIPTION
- This function checks the basic type of field in a user-defined datatype.
- BTRUE is returned if the datatype is atomic (i.e. not compound), BFALSE is
- returned if the datatype is compound, BFAIL on error.
---------------------------------------------------------------------------*/
-hbool_t H5Tis_field_atomic(hid_t tid, uintn fidx)
+ /* check args */
+ if (size<=0) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*invalid size*/
+ }
+
+ /* create the type */
+ if (NULL==(dt=H5T_create (type, size))) {
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL);/*can't create type*/
+ }
+
+ /* Make it an atom */
+ if ((ret_value=H5Aregister_atom (H5_DATATYPE, dt))<0) {
+ /* Can't register data type atom */
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL);
+ }
+
+ FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5T_create
+ *
+ * Purpose: Creates a new data type and initializes it to reasonable
+ * values. The new data type is SIZE bytes and an instance of
+ * the class TYPE.
+ *
+ * Return: Success: Pointer to the new type.
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Friday, December 5, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5T_t *
+H5T_create (H5T_class_t type, size_t size)
{
- h5_datatype_t *dt; /* new data-type object to create */
- hbool_t ret_value = BTRUE;
-
- FUNC_ENTER(H5Tis_field_atomic, H5T_init_interface, BFAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
- /* Check the base type of the datatype */
- if(H5T_COMPOUND!=dt->dt.base)
- HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
-
- /* Check if the compound information has been initialized */
- if(NULL==dt->ci)
- HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, FAIL);
-
- /* Check if the field is valid*/
- if(fidx>=dt->ci->n)
- HGOTO_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL);
-
- /* Check the base type of the field */
- if(H5T_COMPOUND==dt->ci->flist[fidx].dt.base || H5P_SCALAR!=dt->ci->flist[fidx].dim_id)
- ret_value=BFALSE;
-
-done:
- if(ret_value == BFAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tis_field_atomic() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5T_is_atomic
- PURPOSE
- Check if a datatype is atomic (internal)
- USAGE
- hbool_t H5Tis_atomic(type)
- h5_datatype_t *type; IN: Ptr to datatype object to query
- RETURNS
- BFAIL/BTRUE/BFALSE
- DESCRIPTION
- This function checks the basic type of a user-defined datatype. BTRUE
- is returned if the datatype is atomic (i.e. not compound), BFALSE is
- returned if the datatype is compound, BFAIL on error.
---------------------------------------------------------------------------*/
-hbool_t H5T_is_atomic(h5_datatype_t *type)
+ H5T_t *dt = NULL;
+
+ FUNC_ENTER (H5T_create, NULL);
+
+ assert (size>0);
+
+ switch (type) {
+ case H5T_FIXED:
+ /* Default type is a native `int' */
+ if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_INT)))) {
+ /* Can't derive type from native int */
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL);
+ }
+ break;
+
+ case H5T_FLOAT:
+ /* Default type is a native `double' */
+ if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_DOUBLE)))) {
+ /* Can't derive type from native double */
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL);
+ }
+ break;
+
+ case H5T_DATE:
+ case H5T_STRING:
+ case H5T_BITFIELD:
+ case H5T_OPAQUE:
+ assert ("not implemented yet" && 0);
+ HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, NULL);
+
+ case H5T_COMPOUND:
+ dt = H5MM_xcalloc (1, sizeof(H5T_t));
+ dt->type = type;
+ break;
+
+ default:
+ /* Unknown data type class */
+ HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, NULL);
+ }
+
+ dt->size = size;
+ FUNC_LEAVE (dt);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tget_num_members
+ *
+ * Purpose: Determines how many members compound data type TYPE_ID has.
+ *
+ * Return: Success: Number of members defined in a compound data
+ * type.
+ *
+ * Failure: FAIL
+ *
+ * Errors:
+ *
+ * Programmer: Robb Matzke
+ * Monday, December 8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5Tget_num_members (hid_t type_id)
{
- hbool_t ret_value = BTRUE;
-
- FUNC_ENTER(H5T_is_atomic, H5T_init_interface, BFAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- assert (type);
- /* Check the base type of the datatype */
- if(H5T_COMPOUND==type->dt.base)
- ret_value=BFALSE;
-
-#ifdef LATER
-done:
-#endif /* LATER */
- if(ret_value == BFAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5T_is_atomic() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5Tis_atomic
- PURPOSE
- Check if a datatype is atomic (API)
- USAGE
- hbool_t H5Tis_atomic(tid)
- hid_t tid; IN: Datatype object to query
- RETURNS
- BFAIL/BTRUE/BFALSE
- DESCRIPTION
- This function checks the basic type of a user-defined datatype. BTRUE
- is returned if the datatype is atomic (i.e. not compound), BFALSE is
- returned if the datatype is compound, BFAIL on error.
---------------------------------------------------------------------------*/
-hbool_t H5Tis_atomic(hid_t tid)
+
+ H5T_t *dt = NULL;
+
+ FUNC_ENTER (H5Tget_num_members, FAIL);
+ H5ECLEAR;
+
+ /* Check args */
+ if (H5_DATATYPE!=H5Aatom_group (type_id) ||
+ NULL==(dt=H5Aatom_object (type_id)) ||
+ H5T_COMPOUND!=dt->type) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a compound data type*/
+ }
+
+ FUNC_LEAVE (dt->u.compnd.nmembs);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tget_class
+ *
+ * Purpose: Returns the data type class identifier for data type TYPE_ID.
+ *
+ * Return: Success: One of the non-negative data type class
+ * constants.
+ *
+ * Failure: H5T_NO_CLASS (-1)
+ *
+ * Programmer: Robb Matzke
+ * Monday, December 8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5T_class_t
+H5Tget_class (hid_t type_id)
{
- h5_datatype_t *dt; /* new data-type object to create */
- hbool_t ret_value = BTRUE;
-
- FUNC_ENTER(H5Tis_atomic, H5T_init_interface, BFAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
- if(H5Aatom_group(tid)!=H5_DATATYPE)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
- /* Check the base type of the datatype */
- ret_value=H5T_is_atomic(dt);
-
-done:
- if(ret_value == BFAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tis_atomic() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5Tset_type
- PURPOSE
- Set the base type of a user-defined datatype
- USAGE
- herr_t H5Tset_type(tid, base, len, arch)
- hid_t tid; IN: Datatype object to modify
- hid_t base; IN: Base type to set the datatype to
- uint8 len; IN: Length of the object in bytes
- uint8 arch; IN: Architecture format to store type with
- RETURNS
- SUCCEED/FAIL
- DESCRIPTION
- This function sets the basic type of a user-defined datatype. Each
- datatype is either an atomic type (i.e. has no further divisions of the
- type) or is a compound type (like a C structure). If the datatype is set
- to a compound type, the 'len' argument is not used.
---------------------------------------------------------------------------*/
-herr_t H5Tset_type(hid_t tid,hid_t base,uint8 len,uint8 arch)
+ H5T_t *dt = NULL;
+
+ FUNC_ENTER (H5Tget_class, FAIL);
+ H5ECLEAR;
+
+ /* Check args */
+ if (H5_DATATYPE!=H5Aatom_group (type_id) ||
+ NULL==(dt=H5Aatom_object (type_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+ }
+
+ FUNC_LEAVE (dt->type);
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tget_size
+ *
+ * Purpose: Determines the total size of a data type in bytes.
+ *
+ * Return: Success: Size of the data type in bytes. The size of
+ * data type is the size of an instance of that
+ * data type.
+ *
+ * Failure: 0 (valid data types are never zero size)
+ *
+ * Programmer: Robb Matzke
+ * Monday, December 8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5Tget_size (hid_t type_id)
{
- h5_datatype_t *dt; /* new data-type object to create */
- herr_t ret_value = SUCCEED;
-
- FUNC_ENTER(H5Tset_type, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
- if(base<H5T_CHAR || base>H5T_COMPOUND)
- HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
- if(dt->dt.base!=0)
- HGOTO_ERROR(H5E_FUNC, H5E_ALREADYINIT, FAIL);
-
- /* Set the basic datatype information */
- dt->dt.base=base;
- dt->dt.len=len;
- dt->dt.arch=arch;
-
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tset_type() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5Tget_type
- PURPOSE
- Get the base type of a datatype
- USAGE
- herr_t H5Tget_type(tid, base, len, arch)
- hid_t tid; IN: Datatype object to modify
- hid_t *base; IN: Base type of the datatype
- uint8 *len; IN: Length of the object in bytes
- uint8 *arch; IN: Architecture format type stored with
- RETURNS
- SUCCEED/FAIL
- DESCRIPTION
- This function gets the basic type of a user-defined datatype. Each
- datatype is either an atomic type (i.e. has no further divisions of the
- type) or is a compound type (like a C structure). If the datatype is
- to a compound type, the 'len' argument is not used.
---------------------------------------------------------------------------*/
-herr_t H5Tget_type(hid_t tid,hid_t *base,uint8 *len,uint8 *arch)
+ H5T_t *dt = NULL;
+ size_t size;
+
+ FUNC_ENTER (H5Tget_size, 0);
+ H5ECLEAR;
+
+ /* Check args */
+ if (H5_DATATYPE!=H5Aatom_group (type_id) ||
+ NULL==(dt=H5Aatom_object (type_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+ }
+
+ /* size */
+ size = H5T_get_size (dt);
+
+ FUNC_LEAVE (size);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5T_get_size
+ *
+ * Purpose: Determines the total size of a data type in bytes.
+ *
+ * Return: Success: Size of the data type in bytes. The size of
+ * the data type is the size of an instance of
+ * that data type.
+ *
+ * Failure: 0 (valid data types are never zero size)
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5T_get_size (const H5T_t *dt)
{
- h5_datatype_t *dt; /* new data-type object to create */
- herr_t ret_value = SUCCEED;
-
- FUNC_ENTER(H5Tget_type, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
- if(H5Aatom_group(tid)!=H5_DATATYPE)
- HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
- if(dt->dt.base==0)
- HGOTO_ERROR(H5E_FUNC, H5E_UNINITIALIZED, FAIL);
-
- /* Set the basic datatype information */
- if(base!=NULL)
- *base=dt->dt.base;
- if(len!=NULL)
- *len=dt->dt.len;
- if(arch!=NULL)
- *arch=dt->dt.arch;
-
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tget_type() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5Tadd_field
- PURPOSE
- Add a field to a compound datatype
- USAGE
- herr_t H5Tadd_field(tid, name, base, len, arch, space)
- hid_t tid; IN: Datatype object to query
- const char *fidx; IN: Field name
- hid_t base; IN: Field's base type, either an atom ID for
- an existing compound type, or an atomic
- base type
- uint8 len; IN: Length of an atomic base type
- uint8 arch; IN: Architecture format of an atomic base type
- hid_t space; IN: The dimensionality of the field to add
- RETURNS
- SUCCEED/FAIL
- DESCRIPTION
- This function adds a field to a user-defined compound datatype. The
- field can either be a base/len/arch triplet or an existing compound type
- (passed in the base argument). The space parameter is either H5P_SCALAR
- (to indicate a scalar field) or the atom of a datatype for more complex
- dimensionality fields.
---------------------------------------------------------------------------*/
-herr_t H5Tadd_field(hid_t tid, const char *name, hid_t base, uint8 len, uint8 arch, hid_t space)
+ FUNC_ENTER (H5T_get_size, 0);
+
+ /* check args */
+ assert (dt);
+
+ FUNC_LEAVE (dt->size);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tinsert_member
+ *
+ * Purpose: Adds another member to the compound data type PARENT_ID. The
+ * new member has a NAME which must be unique within the
+ * compound data type. The OFFSET argument defines the start of
+ * the member in an instance of the compound data type, and
+ * MEMBER_ID is the type of the new member.
+ *
+ * Note: All members of a compound data type must be atomic; a
+ * compound data type cannot have a member which is a compound
+ * data type.
+ *
+ * Return: Success: SUCCEED, the PARENT_ID compound data type is
+ * modified to include a copy of the member type
+ * MEMBER_ID.
+ *
+ * Failure: FAIL
+ *
+ * Errors:
+ *
+ * Programmer: Robb Matzke
+ * Monday, December 8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Tinsert_member (hid_t parent_id, const char *name, off_t offset,
+ hid_t member_id)
{
- h5_field_info_t *new_field; /* pointer to new field to add */
- h5_datatype_t *dt; /* data-type object to manipulate */
- herr_t ret_value = SUCCEED;
-
- FUNC_ENTER(H5Tadd_field, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
- /* Check the base type of the datatype */
- if(H5T_COMPOUND!=dt->dt.base)
- HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
-
- /* Check if the compound information has been initialized */
- if(NULL==dt->ci)
- {
- if(NULL==(dt->ci=HDmalloc(sizeof(h5_compound_info_t))))
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
- dt->ci->n=0; /* Set the number of fields to 0 */
- dt->ci->mem_size=0; /* Set the size of the structure */
- dt->ci->disk_size=0; /* Set the size of the structure */
- dt->ci->flist=NULL; /* No field information yet */
- } /* end if */
-
- if(NULL==(new_field=HDrealloc(dt->ci->flist,(dt->ci->n+1)*sizeof(h5_field_info_t))))
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
- dt->ci->n++; /* increment the number of fields */
- dt->ci->flist=new_field; /* save the pointer to the increased array of fields */
- new_field=&dt->ci->flist[dt->ci->n-1]; /* get a "convenience" pointer to the new field */
-
- new_field->name=HDstrdup(name); /* copy the name */
- new_field->name_off=0; /* name isn't stored yet */
- new_field->struct_off=dt->ci->disk_size; /* Set the offset of the field on disk */
- new_field->dim_id=H5Mcopy(space); /* Make a copy of the dimension space for the field */
- if((H5Ais_reserved(base)==BTRUE) && base!=H5T_COMPOUND) /* Check if this is a "simple" datatype */
- {
- new_field->dt.base=base; /* Make a copy of the datatype for the field */
- new_field->dt.len=len;
- new_field->dt.arch=arch;
- } /* end if */
- else
- {
- new_field->dt.base=H5Mcopy(base); /* Make a copy of the datatype for the field */
- new_field->dt.len=H5Tsize(base,BTRUE);
- new_field->dt.arch=arch;
- } /* end else */
-
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tadd_field() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5T_size
- PURPOSE
- Determine the size of a datatype (internal)
- USAGE
- uintn H5T_size(dt, mem_flag)
- h5_datatype_t *dt; IN: Pointer to Datatype object to query
- hbool_t mem_flag; IN: Whether the memory or disk size is desired
- RETURNS
- The size of the datatype on success or UFAIL on failure.
- DESCRIPTION
- Ths function returns the size of the datatype in bytes as it is stored
- on disk or in memory, depending on the mem_flag. Setting the mem_flag to
- BTRUE returns the size in memory, BFALSE returns the size on disk.
---------------------------------------------------------------------------*/
-uintn H5T_size(h5_datatype_t *dt, hbool_t mem_flag)
+ H5T_t *parent = NULL; /*the compound parent data type */
+ H5T_t *member = NULL; /*the atomic member type */
+
+ FUNC_ENTER (H5Tinsert_member, FAIL);
+ H5ECLEAR;
+
+ /* Check args */
+ if (H5_DATATYPE!=H5Aatom_group (parent_id) ||
+ NULL==(parent=H5Aatom_object (parent_id)) ||
+ H5T_COMPOUND!=parent->type) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a compound data type*/
+ }
+ if (parent->locked) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*parent is locked*/
+ }
+ if (!name || !*name) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no member name*/
+ }
+ if (H5_DATATYPE!=H5Aatom_group (member_id) ||
+ NULL==(member=H5Aatom_object (member_id)) ||
+ H5T_COMPOUND==member->type) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not an atomic data type*/
+ }
+
+ if (H5T_insert_member (parent, name, offset, member)<0) {
+ /* Can't insert member. */
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL);
+ }
+
+ FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5T_insert_member
+ *
+ * Purpose: Adds a new MEMBER to the compound data type PARENT. The new
+ * member will have a NAME that is unique within PARENT and an
+ * instance of PARENT will have the member begin at byte offset
+ * OFFSET from the beginning.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Monday, December 8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5T_insert_member (H5T_t *parent, const char *name, off_t offset,
+ const H5T_t *member)
{
- uintn ret_value = UFAIL;
-
- FUNC_ENTER(H5T_size, H5T_init_interface, UFAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- assert(dt);
-
- if(dt->dt.base==H5T_COMPOUND)
- {
- intn i; /* local counting variable */
-
- /* Check the base type of the datatype */
- if(H5T_COMPOUND!=dt->dt.base)
- HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
-
- /* Check if the compound information has been initialized */
- if(NULL==dt->ci)
- HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, FAIL);
-
- /* Grab the number of fields */
- for(i=0; i<=dt->ci->n; i++)
- ret_value+=H5Tsize(dt->ci->flist[i].dt.base,mem_flag)*H5Pnelem(dt->ci->flist[i].dim_id);
- } /* end if */
- else
- { /* Simple, user-defined datatypes */
- switch(dt->dt.base)
- {
- case H5T_CHAR:
- case H5T_INT:
- case H5T_FLOAT: /* All three of thes types use the length as the number of bytes */
- ret_value=dt->dt.len;
- break;
-
- case H5T_DATE:
- ret_value=8; /* Number of characters for ISO 8601 format */
- break;
-
- case H5T_TIME:
- ret_value=6; /* Number of characters for ISO 8601 format */
- break;
-
- case H5T_SPTR:
- HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, UFAIL);
- break;
-
- case H5T_PPTR:
- HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, UFAIL);
- break;
-
- default:
- HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, UFAIL);
- } /* end switch */
- } /* end else */
-
-done:
- if(ret_value == UFAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5T_size() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5Tsize
- PURPOSE
- Determine the size of a datatype
- USAGE
- uintn H5Tsize(tid, mem_flag)
- hid_t tid; IN: Datatype object to query
- hbool_t mem_flag; IN: Whether the memory or disk size is desired
- RETURNS
- The size of the datatype on success or UFAIL on failure.
- DESCRIPTION
- This function returns the size of the datatype in bytes as it is stored
- on disk or in memory, depending on the mem_flag. Setting the mem_flag to
- BTRUE returns the size in memory, BFALSE returns the size on disk.
- NOTE:
- This function does not compute the number of bytes for a predefined
- library type (ie. H5T_CHAR, H5T_INT) which has not been "named" by the
- user as field or new type.
---------------------------------------------------------------------------*/
-uintn H5Tsize(hid_t tid, hbool_t mem_flag)
+ intn i;
+ H5T_t *tmp = NULL;
+
+ FUNC_ENTER (H5T_insert_member, FAIL);
+
+ /* check args */
+ assert (parent && H5T_COMPOUND==parent->type);
+ assert (!parent->locked);
+ assert (member && H5T_COMPOUND!=member->type);
+ assert (name && *name);
+
+ /* Does NAME already exist in PARENT? */
+ for (i=0; i<parent->u.compnd.nmembs; i++) {
+ if (!HDstrcmp (parent->u.compnd.memb[i].name, name)) {
+ /* Member name is not unique */
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL);
+ }
+ }
+
+ /* Increase member array if necessary */
+ if (parent->u.compnd.nmembs>=parent->u.compnd.nalloc) {
+ parent->u.compnd.nalloc += H5T_COMPND_INC;
+ parent->u.compnd.memb = H5MM_xrealloc (parent->u.compnd.memb,
+ (parent->u.compnd.nalloc*
+ sizeof(H5T_member_t)));
+ }
+
+ /* Add member to end of member array */
+ i = parent->u.compnd.nmembs;
+ parent->u.compnd.memb[i].name = H5MM_xstrdup (name);
+ parent->u.compnd.memb[i].offset = offset;
+ parent->u.compnd.memb[i].ndims = 0; /*defaults to scalar*/
+
+ tmp = H5T_copy (member);
+ parent->u.compnd.memb[i].type = *tmp;
+ H5MM_xfree (tmp);
+
+ FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tcopy
+ *
+ * Purpose: Copies a data type. The resulting data type is not locked.
+ *
+ * Return: Success: The ID of a new data type.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Tcopy (hid_t type_id)
{
- uintn ret_value = UFAIL;
-
- FUNC_ENTER(H5Tsize, H5T_init_interface, UFAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- if((H5Ais_reserved(tid)==BTRUE) && tid!=H5T_COMPOUND) /* Check if this is a "simple" datatype */
- {
-#ifdef LATER
- switch(tid)
- {
- case H5T_CHAR:
- case H5T_INT:
- case H5T_FLOAT: /* All three of thes types use the length as the number of bytes */
- ret_value=len;
- break;
-
- case H5T_DATE:
- ret_value=8; /* Number of characters for ISO 8601 format */
- break;
-
- case H5T_TIME:
- ret_value=6; /* Number of characters for ISO 8601 format */
- break;
-
- case H5T_SPTR:
- HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, UFAIL);
- break;
-
- case H5T_PPTR:
- HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, UFAIL);
- break;
-
- default:
- HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, UFAIL);
- } /* end switch */
-#endif /* LATER */
- HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, UFAIL);
- } /* end if */
- else
- {
- h5_datatype_t *dt; /* datatype pointer */
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
- ret_value=H5T_size(dt,mem_flag);
- } /* end else */
-
-done:
- if(ret_value == UFAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tsize() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5T_arch
- PURPOSE
- Determine the architecture of a datatype (internal)
- USAGE
- uintn H5T_arch(dt)
- h5_datatype_t *dt; IN: Pointer to Datatype object to query
- RETURNS
- The architure type of the datatype on success or FAIL on failure.
- DESCRIPTION
- Ths function returns the architure type of the datatype.
---------------------------------------------------------------------------*/
-intn H5T_arch(h5_datatype_t *dt)
+ H5T_t *dt = NULL;
+ H5T_t *new_dt = NULL;
+ hid_t ret_value = FAIL;
+
+ FUNC_ENTER (H5Tcopy, FAIL);
+ H5ECLEAR;
+
+ /* check args */
+ if (H5_DATATYPE!=H5Aatom_group (type_id) ||
+ NULL==(dt=H5Aatom_object (type_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+ }
+
+ /* copy */
+ if (NULL==(new_dt = H5T_copy (dt))) {
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL); /*can't copy*/
+ }
+
+ /* atomize result */
+ if ((ret_value=H5Aregister_atom (H5_DATATYPE, new_dt))<0) {
+ H5T_close (new_dt);
+ /* Can't register data type atom */
+ HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL);
+ }
+
+ FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5T_copy
+ *
+ * Purpose: Copies datatype OLD_DT. The resulting data type is not
+ * locked.
+ *
+ * Return: Success: Pointer to a new copy of the OLD_DT argument.
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Thursday, December 4, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5T_t *
+H5T_copy (const H5T_t *old_dt)
{
- intn ret_value = FAIL;
-
- FUNC_ENTER(H5T_arch, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- assert(dt);
-
- ret_value=dt->dt.arch;
-
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
+ H5T_t *new_dt = NULL;
+ intn i;
+ char *s;
+
+ FUNC_ENTER (H5T_copy, NULL);
- FUNC_LEAVE(ret_value);
-} /* end H5T_arch() */
+ /* check args */
+ assert (old_dt);
-/*--------------------------------------------------------------------------
- NAME
- H5Tarch
- PURPOSE
- Determine the architecture of a datatype
- USAGE
- intn H5Tarch(tid)
- hid_t tid; IN: Datatype object to query
- RETURNS
- The architecture of the datatype on success or FAIL on failure.
- DESCRIPTION
- Ths function returns the architecture of the datatype.
---------------------------------------------------------------------------*/
-intn H5Tarch(hid_t tid)
+ /* copy */
+ new_dt = H5MM_xcalloc (1, sizeof(H5T_t));
+ *new_dt = *old_dt;
+ new_dt->locked = FALSE;
+
+ if (H5T_COMPOUND==new_dt->type) {
+ new_dt->u.compnd.memb = H5MM_xmalloc (new_dt->u.compnd.nmembs *
+ sizeof(H5T_member_t));
+ HDmemcpy (new_dt->u.compnd.memb, old_dt->u.compnd.memb,
+ new_dt->u.compnd.nmembs * sizeof(H5T_member_t));
+ for (i=0; i<new_dt->u.compnd.nmembs; i++) {
+ s = new_dt->u.compnd.memb[i].name;
+ new_dt->u.compnd.memb[i].name = H5MM_xstrdup (s);
+ }
+ }
+
+ FUNC_LEAVE (new_dt);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tclose
+ *
+ * Purpose: Frees a data type and all associated memory.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Tclose (hid_t type_id)
{
- h5_datatype_t *dt; /* datatype pointer */
- intn ret_value = FAIL;
-
- FUNC_ENTER(H5Tarch, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- /* Go get the object */
- if((dt=H5Aatom_object(tid))==NULL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
- ret_value=H5T_arch(dt);
-
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tarch() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5Tget_fields
- PURPOSE
- Determine the size of a datatype
- USAGE
- herr_t H5Tget_fields(tid, field_list)
- hid_t tid; IN: Datatype object to query
- hoid_t *field_list; IN: Array to store list of fields
- RETURNS
- SUCCEED/FAIL
- DESCRIPTION
- Ths function returns a list of OIDs for the fields in a compound
- datatype. Atomic fields are returned in the list of OIDs, but have special
- OID values which cannot be further dereferenced.
---------------------------------------------------------------------------*/
-herr_t H5Tget_fields(hid_t tid, hid_t *field_list)
+ H5T_t *dt = NULL;
+
+ FUNC_ENTER (H5Tclose, FAIL);
+ H5ECLEAR;
+
+ /* check args */
+ if (H5_DATATYPE!=H5Aatom_group (type_id) ||
+ NULL==(dt=H5Aatom_object (type_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+ }
+ if (dt->locked) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*predefined data type*/
+ }
+
+ /* When the reference count reaches zero the resources are freed */
+ if (H5A_dec_ref (type_id)<0) {
+ HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*problem freeing id*/
+ }
+
+ FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5T_close
+ *
+ * Purpose: Frees a data type and all associated memory.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Monday, December 8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5T_close (H5T_t *dt)
{
- herr_t ret_value = FAIL;
-
- FUNC_ENTER(H5Tget_fields, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
- if(H5Aatom_group(tid)!=H5_DATATYPE)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
- if(field_list==NULL)
- HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
-
-done:
- if(ret_value == UFAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5Tget_fields() */
-
-/*--------------------------------------------------------------------------
- NAME
- H5T_destroy
- PURPOSE
- Private function to destroy datatype objects.
- USAGE
- void H5T_destroy(datatype)
- void *datatype; IN: Pointer to datatype object to destroy
- RETURNS
- none
- DESCRIPTION
- This function releases whatever memory is used by a datatype object.
- It should only be called from the atom manager when the reference count
- for a datatype drops to zero.
---------------------------------------------------------------------------*/
-void H5T_destroy(void *datatype)
+ intn i;
+
+ FUNC_ENTER (H5T_close, FAIL);
+
+ assert (dt);
+ assert (!dt->locked);
+
+ if (dt && H5T_COMPOUND==dt->type) {
+ for (i=0; i<dt->u.compnd.nmembs; i++) {
+ H5MM_xfree (dt->u.compnd.memb[i].name);
+ }
+ H5MM_xfree (dt->u.compnd.memb);
+ H5MM_xfree (dt);
+
+ } else if (dt) {
+ H5MM_xfree (dt);
+ }
+
+ FUNC_LEAVE (SUCCEED);
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Tequal
+ *
+ * Purpose: Determines if two data types are equal.
+ *
+ * Return: Success: TRUE if equal, FALSE if unequal
+ *
+ * Failure: FAIL
+ *
+ * Errors:
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, December 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hbool_t
+H5Tequal (hid_t type1_id, hid_t type2_id)
{
- h5_datatype_t *dt=(h5_datatype_t *)datatype; /* data-type object to destroy */
-
- /* Don't call standard init/leave code, this is a private void function */
- /* FUNC_ENTER(H5T_destroy, H5T_init_interface, FAIL); */
-
- if(dt->name!=NULL)
- HDfree(dt->name);
- if(dt->ci!=NULL)
- {
- } /* end if */
- HDfree(dt);
-
-#ifdef LATER
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
- FUNC_LEAVE(ret_value);
-#endif /* LATER */
-
-} /* H5T_destroy */
-
-/*--------------------------------------------------------------------------
- NAME
- H5T_release
- PURPOSE
- Release access to an HDF5 datatype object.
- USAGE
- herr_t H5T_release(oid)
- hid_t oid; IN: Object to release access to
- RETURNS
- SUCCEED/FAIL
- DESCRIPTION
- This function releases a datatype from active use by a user.
---------------------------------------------------------------------------*/
-herr_t H5T_release(hid_t oid)
+ const H5T_t *dt1 = NULL;
+ const H5T_t *dt2 = NULL;
+ hbool_t ret_value = FAIL;
+
+ FUNC_ENTER (H5Tequal, FAIL);
+
+ /* check args */
+ if (H5_DATATYPE!=H5Aatom_group (type1_id) ||
+ NULL==(dt1=H5Aatom_object (type1_id)) ||
+ H5_DATATYPE!=H5Aatom_group (type2_id) ||
+ NULL==(dt2=H5Aatom_object (type2_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+ }
+
+ ret_value = (0==H5T_cmp (dt1, dt2));
+
+ FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5T_cmp
+ *
+ * Purpose: Compares two data types.
+ *
+ * Return: Success: 0 if DT1 and DT2 are equal.
+ * <0 if DT1 is less than DT2.
+ * >0 if DT1 is greater than DT2.
+ *
+ * Failure: 0, never fails
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, December 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5T_cmp (const H5T_t *dt1, const H5T_t *dt2)
{
- herr_t ret_value = SUCCEED;
-
- FUNC_ENTER(H5T_release, H5T_init_interface, FAIL);
-
- /* Clear errors and check args and all the boring stuff. */
- H5ECLEAR;
-
- /* Chuck the object! :-) */
- if(H5Adec_ref(oid)==FAIL)
- HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
-done:
- if(ret_value == FAIL)
- { /* Error condition cleanup */
-
- } /* end if */
-
- /* Normal function cleanup */
-
- FUNC_LEAVE(ret_value);
-} /* end H5T_release() */
+ intn *idx1=NULL, *idx2=NULL;
+ intn ret_value = 0;
+ intn i, j, tmp;
+ hbool_t swapped;
+
+ FUNC_ENTER (H5T_equal, 0);
+
+ /* check args */
+ assert (dt1);
+ assert (dt2);
+
+ /* the easy case */
+ if (dt1==dt2) HGOTO_DONE (0);
+
+ /* compare */
+ if (dt1->type < dt2->type) HGOTO_DONE (-1);
+ if (dt1->type > dt2->type) HGOTO_DONE (1);
+
+ if (dt1->size < dt2->size) HGOTO_DONE (-1);
+ if (dt1->size > dt2->size) HGOTO_DONE (1);
+
+ if (H5T_COMPOUND==dt1->type) {
+ /*
+ * Compound data types...
+ */
+ if (dt1->u.compnd.nmembs < dt2->u.compnd.nmembs) HGOTO_DONE (-1);
+ if (dt1->u.compnd.nmembs > dt2->u.compnd.nmembs) HGOTO_DONE (1);
+
+ /* Build an index for each type so the names are sorted */
+ idx1 = H5MM_xmalloc (dt1->u.compnd.nmembs * sizeof(intn));
+ idx2 = H5MM_xmalloc (dt1->u.compnd.nmembs * sizeof(intn));
+ for (i=0; i<dt1->u.compnd.nmembs; i++) idx1[i] = idx2[i] = i;
+ for (i=dt1->u.compnd.nmembs-1, swapped=TRUE; swapped && i>=0; --i) {
+ for (j=0, swapped=FALSE; j<i; j++) {
+ if (HDstrcmp (dt1->u.compnd.memb[idx1[j]].name,
+ dt1->u.compnd.memb[idx1[j+1]].name)>0) {
+ tmp = idx1[j];
+ idx1[j] = idx1[j+1];
+ idx1[j+1] = tmp;
+ swapped = TRUE;
+ }
+ }
+ }
+ for (i=dt1->u.compnd.nmembs-1, swapped=TRUE; swapped && i>=0; --i) {
+ for (j=0, swapped=FALSE; j<i; j++) {
+ if (HDstrcmp (dt2->u.compnd.memb[idx2[j]].name,
+ dt2->u.compnd.memb[idx2[j+1]].name)>0) {
+ tmp = idx2[j];
+ idx2[j] = idx2[j+1];
+ idx2[j+1] = tmp;
+ swapped = TRUE;
+ }
+ }
+ }
+
+#ifndef NDEBUG
+ for (i=0; i<dt1->u.compnd.nmembs; i++) {
+ assert (HDstrcmp (dt1->u.compnd.memb[idx1[i]].name,
+ dt1->u.compnd.memb[idx1[i+1]].name));
+ assert (HDstrcmp (dt2->u.compnd.memb[idx2[i]].name,
+ dt2->u.compnd.memb[idx2[i+1]].name));
+ }
+#endif
+ /* Compare the members */
+ for (i=0; i<dt1->u.compnd.nmembs; i++) {
+ tmp = HDstrcmp (dt1->u.compnd.memb[idx1[i]].name,
+ dt2->u.compnd.memb[idx2[i]].name);
+ if (tmp<0) HGOTO_DONE (-1);
+ if (tmp>0) HGOTO_DONE (1);
+
+ if (dt1->u.compnd.memb[idx1[i]].offset <
+ dt2->u.compnd.memb[idx2[i]].offset) HGOTO_DONE (-1);
+ if (dt1->u.compnd.memb[idx1[i]].offset >
+ dt2->u.compnd.memb[idx2[i]].offset) HGOTO_DONE (1);
+
+ if (dt1->u.compnd.memb[idx1[i]].ndims <
+ dt2->u.compnd.memb[idx2[i]].ndims) HGOTO_DONE (-1);
+ if (dt1->u.compnd.memb[idx1[i]].ndims >
+ dt2->u.compnd.memb[idx2[i]].ndims) HGOTO_DONE (1);
+
+ for (j=0; j<dt1->u.compnd.memb[idx1[i]].ndims; j++) {
+ if (dt1->u.compnd.memb[idx1[i]].dim[j] <
+ dt2->u.compnd.memb[idx2[i]].dim[j]) HGOTO_DONE (-1);
+ if (dt1->u.compnd.memb[idx1[i]].dim[j] >
+ dt2->u.compnd.memb[idx2[i]].dim[j]) HGOTO_DONE (1);
+ }
+
+ for (j=0; j<dt1->u.compnd.memb[idx1[i]].ndims; j++) {
+ if (dt1->u.compnd.memb[idx1[i]].perm[j] <
+ dt2->u.compnd.memb[idx2[i]].perm[j]) HGOTO_DONE (-1);
+ if (dt1->u.compnd.memb[idx1[i]].perm[j] >
+ dt2->u.compnd.memb[idx2[i]].perm[j]) HGOTO_DONE (1);
+ }
+
+ tmp = H5T_cmp (&(dt1->u.compnd.memb[idx1[i]].type),
+ &(dt2->u.compnd.memb[idx2[i]].type));
+ if (tmp<0) HGOTO_DONE (-1);
+ if (tmp>0) HGOTO_DONE (1);
+ }
+
+ } else {
+ /*
+ * Atomic data types...
+ */
+ if (dt1->u.atomic.order < dt2->u.atomic.order) HGOTO_DONE (-1);
+ if (dt1->u.atomic.order > dt2->u.atomic.order) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.prec < dt2->u.atomic.prec) HGOTO_DONE (-1);
+ if (dt1->u.atomic.prec > dt2->u.atomic.prec) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.offset < dt2->u.atomic.offset) HGOTO_DONE (-1);
+ if (dt1->u.atomic.offset > dt2->u.atomic.offset) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.lo_pad < dt2->u.atomic.lo_pad) HGOTO_DONE (-1);
+ if (dt1->u.atomic.lo_pad > dt2->u.atomic.lo_pad) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.hi_pad < dt2->u.atomic.hi_pad) HGOTO_DONE (-1);
+ if (dt1->u.atomic.hi_pad > dt2->u.atomic.hi_pad) HGOTO_DONE (1);
+
+ switch (dt1->type) {
+ case H5T_FIXED:
+ if (dt1->u.atomic.u.i.sign < dt2->u.atomic.u.i.sign) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.i.sign > dt2->u.atomic.u.i.sign) HGOTO_DONE (1);
+ break;
+
+ case H5T_FLOAT:
+ if (dt1->u.atomic.u.f.sign < dt2->u.atomic.u.f.sign) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.sign > dt2->u.atomic.u.f.sign) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.f.epos < dt2->u.atomic.u.f.epos) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.epos > dt2->u.atomic.u.f.epos) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.f.esize <
+ dt2->u.atomic.u.f.esize) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.esize >
+ dt2->u.atomic.u.f.esize) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.f.ebias <
+ dt2->u.atomic.u.f.ebias) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.ebias >
+ dt2->u.atomic.u.f.ebias) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.f.mpos < dt2->u.atomic.u.f.mpos) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.mpos > dt2->u.atomic.u.f.mpos) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.f.msize <
+ dt2->u.atomic.u.f.msize) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.msize >
+ dt2->u.atomic.u.f.msize) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.f.norm < dt2->u.atomic.u.f.norm) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.norm > dt2->u.atomic.u.f.norm) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.f.pad < dt2->u.atomic.u.f.pad) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.f.pad > dt2->u.atomic.u.f.pad) HGOTO_DONE (1);
+
+ break;
+
+ case H5T_DATE:
+ /*void*/
+ break;
+
+ case H5T_STRING:
+ if (dt1->u.atomic.u.s.cset < dt1->u.atomic.u.s.cset) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.s.cset > dt1->u.atomic.u.s.cset) HGOTO_DONE (1);
+
+ if (dt1->u.atomic.u.s.spad < dt1->u.atomic.u.s.spad) HGOTO_DONE (-1);
+ if (dt1->u.atomic.u.s.spad > dt1->u.atomic.u.s.spad) HGOTO_DONE (1);
+
+ break;
+
+ case H5T_BITFIELD:
+ /*void*/
+ break;
+
+ case H5T_OPAQUE:
+ /*void*/
+ break;
+
+ default:
+ assert ("not implemented yet" && 0);
+ }
+ }
+
+ done:
+ H5MM_xfree (idx1);
+ H5MM_xfree (idx2);
+
+ FUNC_LEAVE (ret_value);
+}
+