diff options
Diffstat (limited to 'src/H5P.c')
| -rw-r--r-- | src/H5P.c | 915 |
1 files changed, 549 insertions, 366 deletions
@@ -16,34 +16,21 @@ static char RcsId[] = "@(#)$Revision$"; /* $Id$ */ -/*LINTLIBRARY */ -/*+ - FILE - H5P.c - HDF5 Data-space routines - EXPORTED ROUTINES - H5Pcreate -- Create a data-space - H5Prelease -- Release access to a data-space - - LIBRARY-SCOPED ROUTINES - - LOCAL ROUTINES - H5P_init_interface -- initialize the interface - + */ - -#include <H5private.h> /* Generic Functions */ -#include <H5Aprivate.h> /* Atom Functions */ -#include <H5Eprivate.h> /* Error handling */ -#include <H5MMprivate.h> /* Memory Management functions */ -#include <H5Pprivate.h> /* Data-space functions */ +#include <H5private.h> /* Generic Functions */ +#include <H5Aprivate.h> /* Atom Functions */ +#include <H5Eprivate.h> /* Error handling */ +#include <H5MMprivate.h> /* Memory Management functions */ +#include <H5Oprivate.h> /*object headers */ +#include <H5Pprivate.h> /* Data-space functions */ #define PABLO_MASK H5P_mask -/*--------------------- Locally scoped variables -----------------------------*/ - -/* Whether we've installed the library termination function yet for this interface */ +/* Interface initialization */ static intn interface_initialize_g = FALSE; +#define INTERFACE_INIT H5P_init_interface +static herr_t H5P_init_interface (void); +static void H5P_term_interface (void); /*-------------------------------------------------------------------------- NAME @@ -57,40 +44,21 @@ DESCRIPTION Initializes any interface-specific data or routines. --------------------------------------------------------------------------*/ -static herr_t H5P_init_interface(void) +static herr_t +H5P_init_interface (void) { - herr_t ret_value = SUCCEED; - FUNC_ENTER (H5P_init_interface, NULL, FAIL); + herr_t ret_value = SUCCEED; + FUNC_ENTER (H5P_init_interface, FAIL); - /* Initialize the atom group for the file IDs */ - if((ret_value=H5Ainit_group(H5_DATASPACE,H5A_DATASPACEID_HASHSIZE,H5P_RESERVED_ATOMS,H5P_destroy))!=FAIL) - ret_value=H5_add_exit(&H5P_term_interface); + /* Initialize the atom group for the file IDs */ + if ((ret_value=H5Ainit_group (H5_DATASPACE, H5A_DATASPACEID_HASHSIZE, + H5P_RESERVED_ATOMS, + (herr_t (*)(void*))H5P_close))!=FAIL) { + ret_value=H5_add_exit(&H5P_term_interface); + } - FUNC_LEAVE(ret_value); -} /* H5P_init_interface */ - -/*-------------------------------------------------------------------------- -NAME - H5P_init -- Make certain that the interface has been initialized -USAGE - herr_t H5P_init() - -RETURNS - SUCCEED/FAIL -DESCRIPTION - Library public routine to make certain the H5P interface has been properly - initialized. - ---------------------------------------------------------------------------*/ -herr_t H5P_init(void) -{ - herr_t ret_value = SUCCEED; - FUNC_ENTER (H5P_init, H5P_init_interface, FAIL); - - /* Actual work is done in the FUNC_ENTER macro */ - - FUNC_LEAVE(ret_value); -} /* H5P_init */ + FUNC_LEAVE (ret_value); +} /*-------------------------------------------------------------------------- NAME @@ -109,58 +77,470 @@ herr_t H5P_init(void) EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ -void H5P_term_interface (void) +static void +H5P_term_interface (void) +{ + H5Adestroy_group (H5_DATASPACE); +} + + +/*------------------------------------------------------------------------- + * Function: H5Pcreate + * + * Purpose: Creates a new data space object and opens it for access. + * + * Return: Success: The ID for the new data space object. + * + * Failure: FAIL + * + * Errors: + * + * Programmer: Robb Matzke + * Tuesday, December 9, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +hid_t +H5Pcreate (H5P_class_t type) { - H5Adestroy_group(H5_DATASPACE); -} /* end H5P_term_interface() */ + H5P_t *ds = NULL; + hid_t ret_value = FAIL; + + FUNC_ENTER (H5Pcreate, FAIL); + H5ECLEAR; -/*-------------------------------------------------------------------------- - NAME - H5P_create - PURPOSE - Create a new HDF5 dimensionality object - USAGE - hid_t H5P_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 dimensionality object. ---------------------------------------------------------------------------*/ -hid_t H5P_create(hid_t owner_id, hobjtype_t type, const char *name) + ds = H5MM_xcalloc (1, sizeof(H5P_t)); + ds->type = type; + + switch (type) { + case H5P_SCALAR: + /*void*/ + break; + + case H5P_SIMPLE: + ds->u.simple.rank = 0; + break; + + case H5P_COMPLEX: + /* Complex types are not supported yet */ + HGOTO_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL); + + default: + /* Unknown data space type */ + HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); + } + + /* Register the new data space and get an ID for it */ + if ((ret_value = H5Aregister_atom (H5_DATASPACE, ds))<0) { + HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL); + } + + done: + if (ret_value<0) { + H5MM_xfree (ds); + } + + FUNC_LEAVE (ret_value); +} + + +/*------------------------------------------------------------------------- + * Function: H5Pclose + * + * Purpose: Release access to a data space object. + * + * Return: Success: SUCCEED + * + * Failure: FAIL + * + * Errors: + * + * Programmer: Robb Matzke + * Tuesday, December 9, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +herr_t +H5Pclose (hid_t space_id) +{ + FUNC_ENTER (H5Pclose, FAIL); + H5ECLEAR; + + /* check args */ + if (H5_DATASPACE!=H5Aatom_group (space_id) || + NULL==H5Aatom_object (space_id)) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space*/ + } + + /* When the reference count reaches zero the resources are freed */ + if (H5A_dec_ref (space_id)<0) { + HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*problem freeing id*/ + } + + FUNC_LEAVE (SUCCEED); +} + + +/*------------------------------------------------------------------------- + * Function: H5P_close + * + * Purpose: Releases all memory associated with a data space. + * + * Return: Success: SUCCEED + * + * Failure: FAIL + * + * Programmer: Robb Matzke + * Tuesday, December 9, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +herr_t +H5P_close (H5P_t *ds) +{ + FUNC_ENTER (H5P_close, FAIL); + + assert (ds); + + switch (ds->type) { + case H5P_SCALAR: + /*void*/ + break; + + case H5P_SIMPLE: + H5MM_xfree (ds->u.simple.size); + H5MM_xfree (ds->u.simple.max); + H5MM_xfree (ds->u.simple.perm); + break; + + case H5P_COMPLEX: + /* nothing */ + break; + + default: + assert ("unknown data space type" && 0); + break; + } + H5MM_xfree (ds); + + FUNC_LEAVE (SUCCEED); +} + + +/*------------------------------------------------------------------------- + * Function: H5P_copy + * + * Purpose: Copies a data space. + * + * Return: Success: A pointer to a new copy of SRC + * + * Failure: NULL + * + * Programmer: Robb Matzke + * Thursday, December 4, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +H5P_t * +H5P_copy (const H5P_t *src) +{ + H5P_t *dst = NULL; + int i; + + FUNC_ENTER (H5P_copy, NULL); + + dst = H5MM_xmalloc (sizeof(H5P_t)); + *dst = *src; + + switch (dst->type) { + case H5P_SCALAR: + /*void*/ + break; + + case H5P_SIMPLE: + if (dst->u.simple.size) { + dst->u.simple.size = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn)); + for (i=0; i<dst->u.simple.rank; i++) { + dst->u.simple.size[i] = src->u.simple.size[i]; + } + } + if (dst->u.simple.max) { + dst->u.simple.max = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn)); + for (i=0; i<dst->u.simple.rank; i++) { + dst->u.simple.max[i] = src->u.simple.max[i]; + } + } + if (dst->u.simple.perm) { + dst->u.simple.perm = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn)); + for (i=0; i<dst->u.simple.rank; i++) { + dst->u.simple.perm[i] = src->u.simple.perm[i]; + } + } + break; + + case H5P_COMPLEX: + /*void*/ + break; + + default: + assert ("unknown data space type" && 0); + break; + } + + FUNC_LEAVE (dst); +} + + +/*------------------------------------------------------------------------- + * Function: H5Pget_npoints + * + * Purpose: Determines how many data points a data set has. + * + * Return: Success: Number of data points in the data set. + * + * Failure: 0 + * + * Programmer: Robb Matzke + * Tuesday, December 9, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +size_t +H5Pget_npoints (hid_t space_id) +{ + H5P_t *ds = NULL; + size_t ret_value = 0; + + FUNC_ENTER(H5Pget_npoints, 0); + H5ECLEAR; + + /* check args */ + if (H5_DATASPACE!=H5Aatom_group (space_id) || + NULL==(ds=H5Aatom_object (space_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0); /*not a data space*/ + } + + ret_value = H5P_get_npoints (ds); + + FUNC_LEAVE (ret_value); +} + + +/*------------------------------------------------------------------------- + * Function: H5P_get_npoints + * + * Purpose: Determines how many data points a data set has. + * + * Return: Success: Number of data points in the data set. + * + * Failure: 0 + * + * Programmer: Robb Matzke + * Tuesday, December 9, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +size_t +H5P_get_npoints (const H5P_t *ds) { - H5P_dim_t *new_dim; /* new dimensionality object to create */ - hid_t ret_value = SUCCEED; + size_t ret_value = 0; + intn i; + + FUNC_ENTER(H5P_get_npoints, 0); - FUNC_ENTER(H5P_create, H5P_init_interface, FAIL); + /* check args */ + assert (ds); - /* Clear errors and check args and all the boring stuff. */ - H5ECLEAR; + switch (ds->type) { + case H5P_SCALAR: + ret_value = 1; + break; - /* Allocate space for the new data-type */ - if((new_dim=HDcalloc(1,sizeof(H5P_dim_t)))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL); - - /* Initialize the dimensionality object */ - new_dim->type=H5P_TYPE_UNKNOWN; - new_dim->s=NULL; + case H5P_SIMPLE: + for (ret_value=1, i=0; i<ds->u.simple.rank; i++) { + ret_value *= ds->u.simple.size[i]; + } + break; + + case H5P_COMPLEX: + /* complex data spaces are not supported yet */ + HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0); + + default: + /* unknown data space class */ + HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0); + } + + FUNC_LEAVE (ret_value); +} + + +/*------------------------------------------------------------------------- + * Function: H5P_modify + * + * Purpose: Updates a data space by writing a message to an object + * header. + * + * Return: Success: SUCCEED + * + * Failure: FAIL + * + * Programmer: Robb Matzke + * Tuesday, December 9, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +herr_t +H5P_modify (H5F_t *f, H5G_entry_t *ent, const H5P_t *ds) +{ + FUNC_ENTER (H5O_modify, FAIL); - /* Register the new datatype and get an ID for it */ - if((ret_value=H5Aregister_atom(H5_DATASPACE, (const VOIDP)new_dim))==FAIL) - HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL); + assert (f); + assert (ent); + assert (ds); -done: - if(ret_value == FAIL) - { /* Error condition cleanup */ + switch (ds->type) { + case H5P_SCALAR: + /* Scalar data spaces are not implemented yet */ + HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL); - } /* end if */ + case H5P_SIMPLE: + if (H5O_modify (f, NO_ADDR, ent, H5O_SDSPACE, 0, &(ds->u.simple))<0) { + /* Can't update simple data space message */ + HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL); + } + break; + + case H5P_COMPLEX: + /* Complex data spaces are not implemented yet */ + HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL); + + default: + assert ("unknown data space class" && 0); + break; + } + + FUNC_LEAVE (SUCCEED); +} + + +/*------------------------------------------------------------------------- + * Function: H5P_read + * + * Purpose: Reads the data space from an object header. + * + * Return: Success: Pointer to a new data space. + * + * Failure: NULL + * + * Programmer: Robb Matzke + * Tuesday, December 9, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +H5P_t * +H5P_read (H5F_t *f, H5G_entry_t *ent) +{ + H5P_t *ds = NULL; + + FUNC_ENTER (H5P_read, NULL); + + /* check args */ + assert (f); + assert (ent); + + ds = H5MM_xcalloc (1, sizeof(H5P_t)); + + if (H5O_read (f, NO_ADDR, ent, H5O_SDSPACE, 0, &(ds->u.simple))) { + ds->type = H5P_SIMPLE; + + } else { + ds->type = H5P_SCALAR; + } + + FUNC_LEAVE (ds); +} + + + +/*------------------------------------------------------------------------- + * Function: H5P_cmp + * + * Purpose: Compares two data spaces. + * + * Return: Success: 0 if DS1 and DS2 are the same. + * <0 if DS1 is less than DS2. + * >0 if DS1 is greater than DS2. + * + * Failure: 0, never fails + * + * Programmer: Robb Matzke + * Wednesday, December 10, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +intn +H5P_cmp (const H5P_t *ds1, const H5P_t *ds2) +{ + intn i; + + FUNC_ENTER (H5P_cmp, 0); - /* Normal function cleanup */ + /* check args */ + assert (ds1); + assert (ds2); - FUNC_LEAVE(ret_value); -} /* end H5P_create() */ + /* compare */ + if (ds1->type < ds2->type) HRETURN (-1); + if (ds1->type > ds2->type) HRETURN (1); + + switch (ds1->type) { + case H5P_SIMPLE: + if (ds1->u.simple.rank < ds2->u.simple.rank) HRETURN (-1); + if (ds1->u.simple.rank > ds2->u.simple.rank) HRETURN (1); + + /* don't compare flags */ + + for (i=0; i<ds1->u.simple.rank; i++) { + if (ds1->u.simple.size[i] < ds2->u.simple.size[i]) HRETURN (-1); + if (ds1->u.simple.size[i] > ds2->u.simple.size[i]) HRETURN (1); + } + + /* don't compare max dimensions */ + + for (i=0; i<ds1->u.simple.rank; i++) { + if ((ds1->u.simple.perm?ds1->u.simple.perm[i]:i) < + (ds2->u.simple.perm?ds2->u.simple.perm[i]:i)) HRETURN (-1); + if ((ds1->u.simple.perm?ds2->u.simple.perm[i]:i) > + (ds2->u.simple.perm?ds2->u.simple.perm[i]:i)) HRETURN (1); + } + + break; + + default: + assert ("not implemented yet" && 0); + } + + FUNC_LEAVE (0); +} /*-------------------------------------------------------------------------- NAME @@ -168,8 +548,8 @@ done: PURPOSE Return the logical rank of a dataspace (internal) USAGE - uint32 H5P_get_lrank(sdim) - H5P_sdim_t *sdim; IN: Pointer to dataspace object to query + intn H5P_get_lrank(sdim) + H5P_t *sdim; IN: Pointer to dataspace object to query RETURNS The logical rank of a dataspace on success, UFAIL on failure DESCRIPTION @@ -178,11 +558,12 @@ done: dataspace, not the dimensionality of the space its embedded in. UFAIL is returned on an error, otherwise the rank is returned. --------------------------------------------------------------------------*/ -uint32 H5P_get_lrank(const H5P_sdim_t *sdim) +intn +H5P_get_lrank (const H5P_simple_t *sdim) { - uint32 ret_value = UFAIL; + intn ret_value = UFAIL; - FUNC_ENTER(H5P_get_lrank, H5P_init_interface, UFAIL); + FUNC_ENTER(H5P_get_lrank, UFAIL); /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; @@ -201,7 +582,7 @@ done: /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5P_get_lrank() */ +} /*-------------------------------------------------------------------------- NAME @@ -209,7 +590,7 @@ done: PURPOSE Return the logical rank of a dataspace USAGE - uint32 H5P_get_lrank(sid) + intn H5P_get_lrank(sid) hid_t sid; IN: ID of dataspace object to query RETURNS The logical rank of a dataspace on success, UFAIL on failure @@ -219,12 +600,13 @@ done: dataspace, not the dimensionality of the space its embedded in. UFAIL is returned on an error, otherwise the rank is returned. --------------------------------------------------------------------------*/ -uint32 H5Pget_lrank(hid_t sid) +intn +H5Pget_lrank (hid_t sid) { - H5P_dim_t *space=NULL; /* dataspace to modify */ - uint32 ret_value = UFAIL; + H5P_t *space=NULL; /* dataspace to modify */ + intn ret_value = UFAIL; - FUNC_ENTER(H5Pget_lrank, H5P_init_interface, UFAIL); + FUNC_ENTER(H5Pget_lrank, UFAIL); /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; @@ -232,7 +614,7 @@ uint32 H5Pget_lrank(hid_t sid) if((space=H5Aatom_object(sid))==NULL) HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL); - ret_value=H5P_get_lrank(space->s); + ret_value=H5P_get_lrank(&(space->u.simple)); done: if(ret_value == UFAIL) @@ -243,7 +625,7 @@ done: /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5Pget_lrank() */ +} /*-------------------------------------------------------------------------- NAME @@ -252,8 +634,8 @@ done: Return the logical dimensions of a dataspace (internal) USAGE herr_t H5P_get_ldims(sdim, dims) - H5P_sdim_t *sdim; IN: Pointer to dataspace object to query - uint32 *dims; OUT: Pointer to array to store dimensions in + H5P_simple_t *sdim; IN: Pointer to dataspace object to query + intn *dims; OUT: Pointer to array to store dimensions in RETURNS SUCCEED/FAIL DESCRIPTION @@ -261,18 +643,19 @@ done: dataspace. The logical dimensions are the actual sizes of the dataspace, not the size of the space it is embedded in. --------------------------------------------------------------------------*/ -herr_t H5P_get_ldims(const H5P_sdim_t *sdim, uint32 *dims) +herr_t +H5P_get_ldims (const H5P_simple_t *sdim, intn *dims) { herr_t ret_value = FAIL; - FUNC_ENTER(H5P_get_ldims, H5P_init_interface, UFAIL); + FUNC_ENTER(H5P_get_ldims, UFAIL); /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; assert(sdim); assert(dims); - HDmemcpy(dims, sdim->size,sdim->rank*sizeof(uint32)); + HDmemcpy(dims, sdim->size,sdim->rank*sizeof(intn)); ret_value=SUCCEED; #ifdef LATER @@ -286,7 +669,7 @@ done: /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5P_get_ldims() */ +} /*-------------------------------------------------------------------------- NAME @@ -296,7 +679,7 @@ done: USAGE herr_t H5P_get_ldims(sdim, dims) hid_t sid; IN: ID of dataspace object to query - uint32 *dims; OUT: Pointer to array to store dimensions in + intn *dims; OUT: Pointer to array to store dimensions in RETURNS SUCCEED/FAIL DESCRIPTION @@ -304,12 +687,12 @@ done: dataspace. The logical dimensions are the actual sizes of the dataspace, not the size of the space it is embedded in. --------------------------------------------------------------------------*/ -herr_t H5Pget_ldims(hid_t sid, uint32 *dims) +herr_t H5Pget_ldims(hid_t sid, intn *dims) { - H5P_dim_t *space=NULL; /* dataspace to modify */ - uint32 ret_value = UFAIL; + H5P_t *space=NULL; /* dataspace to modify */ + intn ret_value = UFAIL; - FUNC_ENTER(H5Pget_lrank, H5P_init_interface, UFAIL); + FUNC_ENTER(H5Pget_lrank, UFAIL); /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; @@ -320,7 +703,7 @@ herr_t H5Pget_ldims(hid_t sid, uint32 *dims) if(dims==NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL); - ret_value=H5P_get_ldims(space->s,dims); + ret_value=H5P_get_ldims(&(space->u.simple),dims); done: if(ret_value == FAIL) @@ -331,7 +714,7 @@ done: /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5Pget_ldims() */ +} /*-------------------------------------------------------------------------- NAME @@ -340,40 +723,29 @@ done: Check if a dataspace is simple (internal) USAGE hbool_t H5P_is_simple(sdim) - H5P_sdim_t *sdim; IN: Pointer to dataspace object to query + H5P_t *sdim; IN: Pointer to dataspace object to query RETURNS BTRUE/BFALSE/BFAIL DESCRIPTION This function determines the if a dataspace is "simple". ie. if it has orthogonal, evenly spaced dimensions. --------------------------------------------------------------------------*/ -hbool_t H5P_is_simple(const H5P_dim_t *sdim) +hbool_t +H5P_is_simple (const H5P_t *sdim) { hbool_t ret_value = BFAIL; - FUNC_ENTER(H5P_is_simple, H5P_init_interface, UFAIL); + FUNC_ENTER(H5P_is_simple, UFAIL); /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; assert(sdim); - if(sdim->type==H5P_TYPE_UNKNOWN) - { - HGOTO_ERROR (H5E_INTERNAL, H5E_UNINITIALIZED, FAIL); - } - else - ret_value=sdim->type==H5P_TYPE_SIMPLE ? BTRUE : BFALSE; /* Currently all dataspaces are simple, but check anyway */ + ret_value=sdim->type==H5P_SIMPLE ? BTRUE : BFALSE; /* Currently all dataspaces are simple, but check anyway */ -done: - if(ret_value == BFAIL) - { /* Error condition cleanup */ - - } /* end if */ - - /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5P_is_simple() */ +} /*-------------------------------------------------------------------------- NAME @@ -391,10 +763,10 @@ done: --------------------------------------------------------------------------*/ hbool_t H5Pis_simple(hid_t sid) { - H5P_dim_t *space=NULL; /* dataspace to modify */ + H5P_t *space=NULL; /* dataspace to modify */ hbool_t ret_value = BFAIL; - FUNC_ENTER(H5Pis_simple, H5P_init_interface, BFAIL); + FUNC_ENTER(H5Pis_simple, BFAIL); /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; @@ -413,7 +785,7 @@ done: /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5Pis_simple() */ +} /*-------------------------------------------------------------------------- NAME @@ -423,8 +795,8 @@ done: USAGE herr_t H5Pset_space(sid, rank, dims) hid_t sid; IN: Dataspace object to query - uint32 rank; IN: # of dimensions for the dataspace - const uint32 *dims; IN: Size of each dimension for the dataspace + intn rank; IN: # of dimensions for the dataspace + const intn *dims; IN: Size of each dimension for the dataspace RETURNS SUCCEED/FAIL DESCRIPTION @@ -436,13 +808,13 @@ done: expand. Currently, only the first dimension in the array (the slowest) may be unlimited in size. --------------------------------------------------------------------------*/ -herr_t H5Pset_space(hid_t sid, uint32 rank, const uint32 *dims) +herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims) { - H5P_dim_t *space=NULL; /* dataspace to modify */ - uintn u; /* local counting variable */ + H5P_t *space=NULL; /* dataspace to modify */ + intn u; /* local counting variable */ herr_t ret_value = SUCCEED; - FUNC_ENTER(H5Pset_space, H5P_init_interface, FAIL); + FUNC_ENTER(H5Pset_space, FAIL); /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; @@ -456,64 +828,62 @@ herr_t H5Pset_space(hid_t sid, uint32 rank, const uint32 *dims) /* shift out of the previous state to a "simple" dataspace */ switch(space->type) { - case H5P_TYPE_UNKNOWN: - if((space->s=HDcalloc(sizeof(H5P_sdim_t),1))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL); - break; - - case H5P_TYPE_SIMPLE: + case H5P_SIMPLE: /* do nothing */ break; - case H5P_TYPE_COMPLEX: - /* eventually this will destroy whatever "complex" dataspace info is retained, right now it's an error */ + case H5P_COMPLEX: + /* + * eventually this will destroy whatever "complex" dataspace info + * is retained, right now it's an error + */ /* Fall through to report error */ default: HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL); } /* end switch */ - space->type=H5P_TYPE_SIMPLE; + space->type=H5P_SIMPLE; if(rank==0) { /* scalar variable */ - space->s->rank=0; /* set to scalar rank */ - space->s->dim_flags=0; /* no maximum dimensions or dimension permutations */ - if(space->s->size!=NULL) - space->s->size=H5MM_xfree(space->s->size); - if(space->s->max!=NULL) - space->s->max=H5MM_xfree(space->s->max); - if(space->s->perm!=NULL) - space->s->max=H5MM_xfree(space->s->perm); + space->u.simple.rank=0; /* set to scalar rank */ + space->u.simple.dim_flags=0; /* no maximum dimensions or dimension permutations */ + if(space->u.simple.size!=NULL) + space->u.simple.size=H5MM_xfree(space->u.simple.size); + if(space->u.simple.max!=NULL) + space->u.simple.max=H5MM_xfree(space->u.simple.max); + if(space->u.simple.perm!=NULL) + space->u.simple.max=H5MM_xfree(space->u.simple.perm); } /* end if */ else { /* Reset the dataspace flags */ - space->s->dim_flags=0; + space->u.simple.dim_flags=0; /* Free the old space for now */ - if(space->s->size!=NULL) - space->s->size=H5MM_xfree(space->s->size); - if(space->s->max!=NULL) - space->s->max=H5MM_xfree(space->s->max); - if(space->s->perm!=NULL) - space->s->perm=H5MM_xfree(space->s->perm); + if(space->u.simple.size!=NULL) + space->u.simple.size=H5MM_xfree(space->u.simple.size); + if(space->u.simple.max!=NULL) + space->u.simple.max=H5MM_xfree(space->u.simple.max); + if(space->u.simple.perm!=NULL) + space->u.simple.perm=H5MM_xfree(space->u.simple.perm); /* Set the rank and copy the dims */ - space->s->rank=rank; - if((space->s->size=HDcalloc(sizeof(uint32),rank))==NULL) + space->u.simple.rank=rank; + if((space->u.simple.size=HDcalloc(sizeof(intn),rank))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL); - HDmemcpy(space->s->size,dims,sizeof(uint32)*rank); + HDmemcpy(space->u.simple.size,dims,sizeof(intn)*rank); /* check if there are unlimited dimensions and create the maximum dims array */ - for(u=0; u<(uintn)rank; u++) + for(u=0; u<rank; u++) if(dims[u]==0) { if(u>0) /* sanity check for unlimited dimensions not in the lowest dimensionality */ HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL); - if((space->s->max=HDcalloc(sizeof(uint32),rank))==NULL) + if((space->u.simple.max=HDcalloc(sizeof(intn),rank))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL); - HDmemcpy(space->s->max,dims,sizeof(uint32)*rank); - space->s->dim_flags|=H5P_VALID_MAX; + HDmemcpy(space->u.simple.max,dims,sizeof(intn)*rank); + space->u.simple.dim_flags|=H5P_VALID_MAX; break; } /* end if */ } /* end else */ @@ -527,191 +897,4 @@ done: /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5Pset_space() */ - -/*-------------------------------------------------------------------------- - NAME - H5P_nelem - PURPOSE - Return the number of elements in a dataspace (internal) - USAGE - uintn H5P_nelem(space) - const H5P_dim_t *space; IN: Pointer to the dataspace object to query - RETURNS - The number of elements in a dataspace on success, UFAIL on failure - DESCRIPTION - This function determines the number of dataset elements in a - dataspace. For example, a simple 3-dimensional dataspace with dimensions - 2, 3 and 4 would have 24 elements. - UFAIL is returned on an error, otherwise the number of elements is returned. ---------------------------------------------------------------------------*/ -uintn H5P_nelem(const H5P_dim_t *space) -{ - uintn u; /* local counting variable */ - uintn ret_value = UFAIL; - - FUNC_ENTER(H5P_nelem, H5P_init_interface, UFAIL); - - /* Clear errors and check args and all the boring stuff. */ - H5ECLEAR; - - assert(space); - - /* Check for anything but simple dataspaces for now */ - if(space->type!=H5P_TYPE_SIMPLE) - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL); - - /* Check for other form of scalar dataspaces */ - if(space->s->rank==0) - ret_value=1; - else - { - for(ret_value=1, u=0; u<(uintn)space->s->rank; u++) - ret_value*=space->s->size[u]; - } /* end else */ - -done: - if(ret_value == UFAIL) - { /* Error condition cleanup */ - - } /* end if */ - - /* Normal function cleanup */ - - FUNC_LEAVE(ret_value); -} /* end H5P_nelem() */ - -/*-------------------------------------------------------------------------- - NAME - H5Pnelem - PURPOSE - Return the number of elements in a dataspace - USAGE - uintn H5Pnelem(sid) - hid_t sid; IN: Dataspace object to query - RETURNS - The number of elements in a dataspace on success, UFAIL on failure - DESCRIPTION - This function determines the number of dataset elements in a - dataspace. For example, a simple 3-dimensional dataspace with dimensions - 2, 3 and 4 would have 24 elements. - UFAIL is returned on an error, otherwise the number of elements is returned. ---------------------------------------------------------------------------*/ -uintn H5Pnelem(hid_t sid) -{ - H5P_dim_t *space=NULL; /* dataspace to modify */ - uintn ret_value = UFAIL; - - FUNC_ENTER(H5Pnelem, H5P_init_interface, UFAIL); - - /* Clear errors and check args and all the boring stuff. */ - H5ECLEAR; - - if(sid==H5P_SCALAR) - ret_value=1; - else - { - if((space=H5Aatom_object(sid))==NULL) - HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL); - - ret_value=H5P_nelem(space); - } /* end else */ - -done: - if(ret_value == UFAIL) - { /* Error condition cleanup */ - - } /* end if */ - - /* Normal function cleanup */ - - FUNC_LEAVE(ret_value); -} /* end H5Pnelem() */ - -/*-------------------------------------------------------------------------- - NAME - H5P_destroy - PURPOSE - Private function to destroy dataspace objects. - USAGE - void H5P_destroy(dataspace) - void *dataspace; IN: Pointer to dataspace object to destroy - RETURNS - none - DESCRIPTION - This function releases whatever memory is used by a dataspace object. - It should only be called from the atom manager when the reference count - for a dataspace drops to zero. ---------------------------------------------------------------------------*/ -void H5P_destroy(void *dataspace) -{ - H5P_dim_t *dim=(H5P_dim_t *)dataspace; /* dimensionality object to release */ - - /* Don't call standard init/leave code, this is a private void function */ - /* FUNC_ENTER(H5T_destroy, H5T_init_interface, FAIL); */ - - if(dim->type==H5P_TYPE_SIMPLE) - { - if(dim->s!=NULL) - { - if(dim->s->size!=NULL) - HDfree(dim->s->size); - if(dim->s->max!=NULL) - HDfree(dim->s->max); - if(dim->s->perm!=NULL) - HDfree(dim->s->perm); - HDfree(dim->s); - } /* end if */ - } /* end if */ - HDfree(dim); - -#ifdef LATER -done: - if(ret_value == FAIL) - { /* Error condition cleanup */ - - } /* end if */ - - /* Normal function cleanup */ - FUNC_LEAVE(ret_value); -#endif /* LATER */ - -} /* H5P_destroy */ - -/*-------------------------------------------------------------------------- - NAME - H5P_release - PURPOSE - Release access to an HDF5 dimensionality object. - USAGE - herr_t H5P_release(oid) - hid_t oid; IN: Object to release access to - RETURNS - SUCCEED/FAIL - DESCRIPTION - This function releases a dimensionality from active use by a user. ---------------------------------------------------------------------------*/ -herr_t H5P_release(hid_t oid) -{ - herr_t ret_value = SUCCEED; - - FUNC_ENTER(H5P_release, H5P_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 H5P_release() */ - +} |