mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-27 02:10:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r108] Changed all hatom_t types to hid_t. (Isn't 'sed' nifty.. :-)

Browse Source
This commit is contained in:
Quincey Koziol 1997-09-24 10:32:46 -05:00
parent 5fdfe1b206
commit de68722fb9
28 changed files with 257 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/H5A.c
View File

@ -74,7 +74,7 @@ static int interface_initialize_g = FALSE;
#ifdef ATOMS_ARE_CACHED
/* Array of pointers to atomic groups */
static hatom_t atom_id_cache[ATOM_CACHE_SIZE]={-1,-1,-1,-1};
static hid_t atom_id_cache[ATOM_CACHE_SIZE]={-1,-1,-1,-1};
static VOIDP atom_obj_cache[ATOM_CACHE_SIZE]={NULL};
#endif
@ -85,7 +85,7 @@ static atom_group_t *atom_group_list[MAXGROUP]={NULL};
static atom_info_t *atom_free_list=NULL;
/*--------------------- Local function prototypes ---------------------------*/
static atom_info_t *H5A_find_atom(hatom_t atm);
static atom_info_t *H5A_find_atom(hid_t atm);
static atom_info_t *H5A_get_atom_node(void);
static herr_t H5A_release_atom_node(atom_info_t *atm);
static herr_t H5A_init_interface(void);
@ -273,15 +273,15 @@ done:
Returns atom if successful and FAIL otherwise
*******************************************************************************/
hatom_t H5Aregister_atom(group_t grp, /* IN: Group to register the object in */
hid_t H5Aregister_atom(group_t grp, /* IN: Group to register the object in */
const VOIDP object /* IN: Object to attach to atom */
)
{
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
atom_info_t *atm_ptr=NULL; /* ptr to the new atom */
hatom_t atm_id; /* new atom ID */
hid_t atm_id; /* new atom ID */
uintn hash_loc; /* new item's hash table location */
hatom_t ret_value=SUCCEED;
hid_t ret_value=SUCCEED;
FUNC_ENTER (H5Aregister_atom, H5A_init_interface, FAIL);
@ -324,7 +324,7 @@ hatom_t H5Aregister_atom(group_t grp, /* IN: Group to register the object in
grp_ptr->nextid=grp_ptr->reserved; /* re-start the ID counter */
} /* end if */
do {
hatom_t next_atom=MAKE_ATOM(grp,grp_ptr->nextid); /* new atom to check for */
hid_t next_atom=MAKE_ATOM(grp,grp_ptr->nextid); /* new atom to check for */
atom_info_t *curr_atm; /* ptr to the current atom */
curr_atm=grp_ptr->atom_list[(uintn)ATOM_TO_LOC(grp_ptr->nextid,grp_ptr->hash_size)];
@ -368,7 +368,7 @@ done:
Returns object ptr if successful and NULL otherwise
*******************************************************************************/
VOIDP H5Aatom_object(hatom_t atm /* IN: Atom to retrieve object for */
VOIDP H5Aatom_object(hid_t atm /* IN: Atom to retrieve object for */
)
{
#ifdef ATOMS_ARE_CACHED
@ -387,7 +387,7 @@ VOIDP H5Aatom_object(hatom_t atm /* IN: Atom to retrieve object for */
ret_value=atom_obj_cache[i];
if(i>0)
{ /* Implement a simple "move forward" caching scheme */
hatom_t t_atom=atom_id_cache[i-1];
hid_t t_atom=atom_id_cache[i-1];
VOIDP t_obj=atom_obj_cache[i-1];
atom_id_cache[i-1]=atom_id_cache[i];
@ -428,7 +428,7 @@ done:
Returns group if successful and BADGROUP otherwise
*******************************************************************************/
group_t H5Aatom_group(hatom_t atm /* IN: Atom to retrieve group for */
group_t H5Aatom_group(hid_t atm /* IN: Atom to retrieve group for */
)
{
group_t ret_value=BADGROUP;
@ -460,7 +460,7 @@ done:
Returns atom's object if successful and NULL otherwise
*******************************************************************************/
VOIDP H5Aremove_atom(hatom_t atm /* IN: Atom to remove */
VOIDP H5Aremove_atom(hid_t atm /* IN: Atom to remove */
)
{
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
@ -601,7 +601,7 @@ done:
Returns BTRUE/BFALSE/BFAIL
*******************************************************************************/
intn H5Ais_reserved(hatom_t atm /* IN: Group to search for the object in */
intn H5Ais_reserved(hid_t atm /* IN: Group to search for the object in */
)
{
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
@ -645,7 +645,7 @@ done:
Returns atom ptr if successful and NULL otherwise
*******************************************************************************/
static atom_info_t *H5A_find_atom(hatom_t atm /* IN: Atom to retrieve atom for */
static atom_info_t *H5A_find_atom(hid_t atm /* IN: Atom to retrieve atom for */
)
{
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */

8
src/H5Aprivate.h
View File

@ -41,19 +41,19 @@
#endif
/* Map an atom to a Group number */
#define ATOM_TO_GROUP(a) ((group_t)((((hatom_t)(a))>>((sizeof(hatom_t)*8)-GROUP_BITS))&GROUP_MASK))
#define ATOM_TO_GROUP(a) ((group_t)((((hid_t)(a))>>((sizeof(hid_t)*8)-GROUP_BITS))&GROUP_MASK))
#ifdef HASH_SIZE_POWER_2
/*
* Map an atom to a hash location (assumes s is a power of 2 and smaller
* than the ATOM_MASK constant).
*/
# define ATOM_TO_LOC(a,s) ((hatom_t)(a)&((s)-1))
# define ATOM_TO_LOC(a,s) ((hid_t)(a)&((s)-1))
#else
/*
* Map an atom to a hash location.
*/
# define ATOM_TO_LOC(a,s) (((hatom_t)(a)&ATOM_MASK)%(s))
# define ATOM_TO_LOC(a,s) (((hid_t)(a)&ATOM_MASK)%(s))
#endif
/* Default sizes of the hash-tables for various atom groups */
@ -67,7 +67,7 @@
/* Atom information structure used */
typedef struct atom_info_struct_tag {
hatom_t id; /* atom ID for this info */
hid_t id; /* atom ID for this info */
VOIDP *obj_ptr; /* pointer associated with the atom */
struct atom_info_struct_tag *next; /* link to next atom (in case of hash-clash) */
}atom_info_t;

16
src/H5Apublic.h
View File

@ -36,7 +36,7 @@ typedef enum {
} group_t;
/* Type of atoms to return to users */
typedef int32 hatom_t;
typedef int32 hid_t;
/* Type of the function to compare objects & keys */
typedef intn (*H5Asearch_func_t)(const VOIDP obj, const VOIDP key);
@ -46,11 +46,11 @@ typedef intn (*H5Asearch_func_t)(const VOIDP obj, const VOIDP key);
#define GROUP_MASK 0x0F
/* # of bits to use for the Atom index in each atom (assumes 8-bit bytes) */
#define ATOM_BITS ((sizeof(hatom_t)*8)-GROUP_BITS)
#define ATOM_BITS ((sizeof(hid_t)*8)-GROUP_BITS)
#define ATOM_MASK 0x0FFFFFFF
/* Combine a Group number and an atom index into an atom */
#define MAKE_ATOM(g,i) ((((hatom_t)(g)&GROUP_MASK)<<((sizeof(hatom_t)*8)-GROUP_BITS))|((hatom_t)(i)&ATOM_MASK))
#define MAKE_ATOM(g,i) ((((hid_t)(g)&GROUP_MASK)<<((sizeof(hid_t)*8)-GROUP_BITS))|((hid_t)(i)&ATOM_MASK))
#ifdef __cplusplus
extern "C" {
@ -108,7 +108,7 @@ intn H5Adestroy_group(group_t grp /* IN: Group to destroy */
Returns atom if successful and FAIL otherwise
*******************************************************************************/
hatom_t H5Aregister_atom(group_t grp, /* IN: Group to register the object in */
hid_t H5Aregister_atom(group_t grp, /* IN: Group to register the object in */
const VOIDP object /* IN: Object to attach to atom */
);
@ -123,7 +123,7 @@ hatom_t H5Aregister_atom(group_t grp, /* IN: Group to register the object in
Returns object ptr if successful and NULL otherwise
*******************************************************************************/
VOIDP H5Aatom_object(hatom_t atm /* IN: Atom to retrieve object for */
VOIDP H5Aatom_object(hid_t atm /* IN: Atom to retrieve object for */
);
/******************************************************************************
@ -137,7 +137,7 @@ VOIDP H5Aatom_object(hatom_t atm /* IN: Atom to retrieve object for */
Returns group if successful and FAIL otherwise
*******************************************************************************/
group_t H5Aatom_group(hatom_t atm /* IN: Atom to retrieve group for */
group_t H5Aatom_group(hid_t atm /* IN: Atom to retrieve group for */
);
/******************************************************************************
@ -151,7 +151,7 @@ group_t H5Aatom_group(hatom_t atm /* IN: Atom to retrieve group for */
Returns atom's object if successful and FAIL otherwise
*******************************************************************************/
VOIDP H5Aremove_atom(hatom_t atm /* IN: Atom to remove */
VOIDP H5Aremove_atom(hid_t atm /* IN: Atom to remove */
);
/******************************************************************************
@ -185,7 +185,7 @@ VOIDP H5Asearch_atom(group_t grp, /* IN: Group to search for the object i
Returns BTRUE/BFALSE/BFAIL
*******************************************************************************/
intn H5Ais_reserved(hatom_t atm /* IN: Group to search for the object in */
intn H5Ais_reserved(hid_t atm /* IN: Group to search for the object in */
);
/******************************************************************************

38
src/H5C.c
View File

@ -59,7 +59,7 @@ const file_create_temp_t default_file_create={
HDF5_OBJECTDIR_VERSION, /* Current Object Directory info version # */
HDF5_SHAREDHEADER_VERSION /* Current Shared-Header format version # */
};
static hatom_t default_file_id=FAIL; /* Atom for the default file-creation template */
static hid_t default_file_id=FAIL; /* Atom for the default file-creation template */
/*--------------------- Local function prototypes ----------------------------*/
static herr_t H5C_init_interface(void);
@ -118,7 +118,7 @@ void H5C_term_interface (void)
PURPOSE
Retrive an atom for a default HDF5 template.
USAGE
hatom_t H5C_create(type)
hid_t H5C_create(type)
hobjtype_t type; IN: Type of object to retrieve default template of
RETURNS
Returns template ID (atom) of the default object for a template type on
@ -132,9 +132,9 @@ void H5C_term_interface (void)
The `FUNC' auto variable was changed from `H5C_create' to
`H5C_get_default_atom'.
--------------------------------------------------------------------------*/
hatom_t H5C_get_default_atom(hobjtype_t type)
hid_t H5C_get_default_atom(hobjtype_t type)
{
hatom_t ret_value = FAIL;
hid_t ret_value = FAIL;
FUNC_ENTER(H5C_get_default_atom, H5C_init_interface, FAIL);
@ -174,7 +174,7 @@ done:
Initialize a new HDF5 template with a copy of an existing template.
USAGE
herr_t H5C_init(dst_atm, src)
hatom_t dst_atm; IN: Atom for the template to initialize
hid_t dst_atm; IN: Atom for the template to initialize
file_create_temp_t *src; IN: Template to use to initialize with
RETURNS
SUCCEED/FAIL
@ -182,7 +182,7 @@ done:
This function copies the contents of the source template into the
newly created destination template.
--------------------------------------------------------------------------*/
herr_t H5C_init(hatom_t dst_atm, const file_create_temp_t *src)
herr_t H5C_init(hid_t dst_atm, const file_create_temp_t *src)
{
file_create_temp_t *dst; /* destination template */
herr_t ret_value = SUCCEED; /* return value */
@ -218,8 +218,8 @@ done:
PURPOSE
Create a new HDF5 template.
USAGE
hatom_t H5C_create(owner_id, type, name)
hatom_t owner_id; IN: Group/file which owns this template
hid_t H5C_create(owner_id, type, name)
hid_t owner_id; IN: Group/file which owns this template
hobjtype_t type; IN: Type of template to create
const char *name; IN: Name of the template to create
RETURNS
@ -228,9 +228,9 @@ done:
This is the primary function for creating different HDF5 templates.
Currently the name of template is not used and may be NULL.
--------------------------------------------------------------------------*/
hatom_t H5C_create(hatom_t owner_id, hobjtype_t type, const char *name)
hid_t H5C_create(hid_t owner_id, hobjtype_t type, const char *name)
{
hatom_t ret_value = FAIL; /* atom for template object to return */
hid_t ret_value = FAIL; /* atom for template object to return */
FUNC_ENTER(H5C_create, H5C_init_interface, FAIL);
@ -272,13 +272,13 @@ done:
Release access to a template object.
USAGE
herr_t H5C_release(oid)
hatom_t oid; IN: Template object to release access to
hid_t oid; IN: Template object to release access to
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function releases access to a template object
--------------------------------------------------------------------------*/
herr_t H5C_release(hatom_t oid)
herr_t H5C_release(hid_t oid)
{
file_create_temp_t *template; /* template to destroy */
herr_t ret_value = SUCCEED;
@ -311,7 +311,7 @@ done:
Get a parameter from a template
USAGE
herr_t H5Cgetparm(tid, parm, buf)
hatom_t tid; IN: Template object to retrieve parameter from
hid_t tid; IN: Template object to retrieve parameter from
file_create_param_t parm; IN: Paramter to retrieve
VOIDP buf; OUT: Pointer to buffer to store parameter in
RETURNS
@ -325,7 +325,7 @@ done:
Removed H5_BTREE_SIZE and replaced it with H5_SYM_LEAF_K and
H5_SYM_INTERN_K.
--------------------------------------------------------------------------*/
herr_t H5Cgetparm(hatom_t tid, file_create_param_t parm, VOIDP buf)
herr_t H5Cgetparm(hid_t tid, file_create_param_t parm, VOIDP buf)
{
file_create_temp_t *template; /* template to query */
herr_t ret_value = SUCCEED;
@ -408,7 +408,7 @@ done:
Set a parameter from a template
USAGE
herr_t H5Csetparm(tid, parm, buf)
hatom_t tid; IN: Template object to store parameter in
hid_t tid; IN: Template object to store parameter in
file_create_param_t parm; IN: Parameter to store
const VOIDP buf; IN: Pointer to parameter buffer
RETURNS
@ -431,7 +431,7 @@ done:
Robb Matzke, 15 Sep 1997
Fixed the power-of-two test to work with any size integer.
--------------------------------------------------------------------------*/
herr_t H5Csetparm(hatom_t tid, file_create_param_t parm, const VOIDP buf)
herr_t H5Csetparm(hid_t tid, file_create_param_t parm, const VOIDP buf)
{
file_create_temp_t *template; /* template to query */
herr_t ret_value = SUCCEED;
@ -537,15 +537,15 @@ done:
PURPOSE
Copy a template
USAGE
hatom_t H5C_copy(tid)
hatom_t tid; IN: Template object to copy
hid_t H5C_copy(tid)
hid_t tid; IN: Template object to copy
RETURNS
Returns template ID (atom) on success, FAIL on failure
DESCRIPTION
This function creates a new copy of a template with all the same parameter
settings.
--------------------------------------------------------------------------*/
hatom_t H5C_copy(hatom_t tid)
hid_t H5C_copy(hid_t tid)
{
file_create_temp_t *template, *new_template; /* template to query */
herr_t ret_value = SUCCEED;

10
src/H5Cprivate.h
View File

@ -43,10 +43,10 @@
0 /* unused */ \
}
hatom_t H5C_create(hatom_t owner_id, hobjtype_t type, const char *name);
hatom_t H5C_copy(hatom_t tid);
herr_t H5C_release(hatom_t oid);
hatom_t H5C_get_default_atom(hobjtype_t type);
herr_t H5C_init(hatom_t dst_atm, const file_create_temp_t *src);
hid_t H5C_create(hid_t owner_id, hobjtype_t type, const char *name);
hid_t H5C_copy(hid_t tid);
herr_t H5C_release(hid_t oid);
hid_t H5C_get_default_atom(hobjtype_t type);
herr_t H5C_init(hid_t dst_atm, const file_create_temp_t *src);
#endif

4
src/H5Cpublic.h
View File

@ -45,8 +45,8 @@ typedef enum {
typedef group_t hobjtype_t; /* Map the object in the "meta" interface to atom groups */
/* Functions in H5C.c */
herr_t H5Cgetparm(hatom_t tid, file_create_param_t parm, VOIDP buf);
herr_t H5Csetparm(hatom_t tid, file_create_param_t parm, const VOIDP buf);
herr_t H5Cgetparm(hid_t tid, file_create_param_t parm, VOIDP buf);
herr_t H5Csetparm(hid_t tid, file_create_param_t parm, const VOIDP buf);
void H5C_term_interface (void);
#ifdef __cplusplus

50
src/H5D.c
View File

@ -115,8 +115,8 @@ void H5D_term_interface (void)
PURPOSE
Create a new HDF5 dataset object
USAGE
hatom_t H5D_create(owner_id, type, name)
hatom_t owner_id; IN: Group/file which owns this object
hid_t H5D_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
@ -125,10 +125,10 @@ void H5D_term_interface (void)
This function actually creates a dataset object in a file (of course,
output might not happen for some time).
--------------------------------------------------------------------------*/
hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name)
hid_t H5D_create(hid_t owner_id, hobjtype_t type, const char *name)
{
H5D_t *new_dset; /* new dataset object to create */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
hdf5_file_t *file = NULL;
FUNC_ENTER(H5D_create, H5D_init_interface, FAIL);
@ -179,7 +179,7 @@ done:
Get the OID for accessing an existing HDF5 dataset object
USAGE
hoid_t H5D_find_name(grp_id, type, name)
hatom_t grp_id; IN: Atom for directory to search for dataset
hid_t grp_id; IN: Atom for directory to search for dataset
hobjtype_t type; IN: Type of object to search for (dataset in
this case)
const char *name; IN: Name of the object to search for
@ -188,11 +188,11 @@ done:
DESCRIPTION
This function finds for a dataset by name in a directory.
--------------------------------------------------------------------------*/
hatom_t H5D_find_name(hatom_t grp_id, hobjtype_t type, const char *name)
hid_t H5D_find_name(hid_t grp_id, hobjtype_t type, const char *name)
{
hdf5_file_t *file; /* Pointer to the file-store of this object */
H5D_t *dset = NULL; /* The dataset */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
H5O_std_store_t store;
FUNC_ENTER(H5D_find_name, H5D_init_interface, FAIL);
@ -266,15 +266,15 @@ done:
Set the type and dimensionality of a dataset.
USAGE
herr_t H5Dset_info(oid)
hatom_t oid; IN: Dataset object to modify
hatom_t tid; IN: Datatype object to use as node element
hatom_t did; IN: Dimensionality object to use as dataspace
hid_t oid; IN: Dataset object to modify
hid_t tid; IN: Datatype object to use as node element
hid_t did; IN: Dimensionality object to use as dataspace
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function sets the datatype and dataspace of a dataset.
--------------------------------------------------------------------------*/
herr_t H5Dset_info(hatom_t oid, hatom_t tid, hatom_t did)
herr_t H5Dset_info(hid_t oid, hid_t tid, hid_t did)
{
H5D_t *dataset = NULL; /* dataset object to modify */
herr_t ret_value = SUCCEED;
@ -318,9 +318,9 @@ done:
Get the type and dimensionality of a dataset.
USAGE
herr_t H5Dget_info(oid, tid, sid)
hatom_t oid; IN: Dataset object to query
hatom_t *tid; OUT: Datatype object to use as node element
hatom_t *sid; OUT: Dimensionality object to use as dataspace
hid_t oid; IN: Dataset object to query
hid_t *tid; OUT: Datatype object to use as node element
hid_t *sid; OUT: Dimensionality object to use as dataspace
RETURNS
SUCCEED/FAIL
DESCRIPTION
@ -328,7 +328,7 @@ done:
existing dataset. H5Mendaccess must be called to release the datatype and
dataspace returned from this function.
--------------------------------------------------------------------------*/
herr_t H5Dget_info(hatom_t oid, hatom_t *tid, hatom_t *sid)
herr_t H5Dget_info(hid_t oid, hid_t *tid, hid_t *sid)
{
H5D_t *dataset; /* dataset object to query */
herr_t ret_value = SUCCEED;
@ -372,8 +372,8 @@ done:
Read data from a dataset
USAGE
herr_t H5Dread(oid)
hatom_t oid; IN: Dataset to read
hatom_t did; IN: Dimensionality object to use as dataspace for I/O
hid_t oid; IN: Dataset to read
hid_t did; IN: Dimensionality object to use as dataspace for I/O
VOIDP buf; IN: Buffer to fill with data from the file
RETURNS
SUCCEED/FAIL
@ -384,7 +384,7 @@ done:
to be written out. (For datasets which have a scalar dataspace for the
entire dataset, this is somewhat redundant.... :-)
--------------------------------------------------------------------------*/
herr_t H5Dread(hatom_t oid, hatom_t did, VOIDP buf)
herr_t H5Dread(hid_t oid, hid_t did, VOIDP buf)
{
H5D_t *dataset; /* dataset object to do I/O on */
void *readbuf=NULL; /* pointer to buffer to write out */
@ -456,8 +456,8 @@ done:
Write data for a dataset
USAGE
herr_t H5Dwrite(oid)
hatom_t oid; IN: Dataset object to modify
hatom_t did; IN: Dimensionality object to use as dataspace for I/O
hid_t oid; IN: Dataset object to modify
hid_t did; IN: Dimensionality object to use as dataspace for I/O
VOIDP buf; IN: Buffer with data to write to the file
RETURNS
SUCCEED/FAIL
@ -468,7 +468,7 @@ done:
to be written out. (For datasets which have a scalar dataspace for the
entire dataset, this is somewhat redundant.... :-)
--------------------------------------------------------------------------*/
herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf)
herr_t H5Dwrite(hid_t oid, hid_t did, VOIDP buf)
{
H5D_t *dataset; /* dataset object to do I/O on */
uintn towrite; /* number of bytes to write out */
@ -544,7 +544,7 @@ done:
Flush an an HDF5 dataset object to disk.
USAGE
herr_t H5D_flush(oid)
hatom_t oid; IN: Object to flush to disk
hid_t oid; IN: Object to flush to disk
RETURNS
SUCCEED/FAIL
DESCRIPTION
@ -553,7 +553,7 @@ done:
any changes on disk) This function is primarily called from H5Mflush, but
internal library routines may call it also.
--------------------------------------------------------------------------*/
herr_t H5D_flush(hatom_t oid)
herr_t H5D_flush(hid_t oid)
{
H5D_t *dataset; /* dataset object to release */
herr_t ret_value = SUCCEED;
@ -635,13 +635,13 @@ done:
Release access to an HDF5 dataset object.
USAGE
herr_t H5D_release(oid)
hatom_t oid; IN: Object to release access to
hid_t oid; IN: Object to release access to
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function releases a dataset from active use by a user.
--------------------------------------------------------------------------*/
herr_t H5D_release(hatom_t oid)
herr_t H5D_release(hid_t oid)
{
H5D_t *dataset; /* dataset object to release */
herr_t ret_value = SUCCEED;

10
src/H5Dprivate.h
View File

@ -34,11 +34,11 @@
#define H5D_MINHDR_SIZE 512
/*-----------------_-- Local function prototypes ----------------------------*/
hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name);
hatom_t H5D_access_by_name (hatom_t owner_id, const char *name);
hatom_t H5D_find_name(hatom_t owner_id, hobjtype_t type, const char *name);
herr_t H5D_flush(hatom_t oid);
herr_t H5D_release(hatom_t oid);
hid_t H5D_create(hid_t owner_id, hobjtype_t type, const char *name);
hid_t H5D_access_by_name (hid_t owner_id, const char *name);
hid_t H5D_find_name(hid_t owner_id, hobjtype_t type, const char *name);
herr_t H5D_flush(hid_t oid);
herr_t H5D_release(hid_t oid);
/* in H5Dconv.c */
herr_t H5D_convert_buf(void *dst,const void *src,uintn len,uintn size);

8
src/H5Dpublic.h
View File

@ -28,10 +28,10 @@ extern "C" {
#endif
/* Functions in H5D.c */
herr_t H5Dset_info(hatom_t oid, hatom_t tid, hatom_t did);
herr_t H5Dget_info(hatom_t oid, hatom_t *tid, hatom_t *sid);
herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf);
herr_t H5Dread(hatom_t oid, hatom_t did, VOIDP buf);
herr_t H5Dset_info(hid_t oid, hid_t tid, hid_t did);
herr_t H5Dget_info(hid_t oid, hid_t *tid, hid_t *sid);
herr_t H5Dwrite(hid_t oid, hid_t did, VOIDP buf);
herr_t H5Dread(hid_t oid, hid_t did, VOIDP buf);
void H5D_term_interface (void);
#ifdef __cplusplus

32
src/H5F.c
View File

@ -234,8 +234,8 @@ H5F_compare_filename (const VOIDP _obj, const VOIDP _key)
Get an atom for a copy of the file-creation template for this file
USAGE
hatom_t H5Fget_create_template(fid)
hatom_t fid; IN: File ID
hid_t H5Fget_create_template(fid)
hid_t fid; IN: File ID
ERRORS
ATOM BADATOM Can't get file struct.
@ -249,10 +249,10 @@ H5F_compare_filename (const VOIDP _obj, const VOIDP _key)
This function returns an atom with a copy of the template parameters
used to create a file.
--------------------------------------------------------------------------*/
hatom_t H5Fget_create_template(hatom_t fid)
hid_t H5Fget_create_template(hid_t fid)
{
hdf5_file_t *file=NULL; /* file struct for file to close */
hatom_t ret_value = FAIL;
hid_t ret_value = FAIL;
FUNC_ENTER(H5Fget_create_template, H5F_init_interface, FAIL);
@ -456,8 +456,8 @@ H5F_dest (hdf5_file_t *f)
int32 H5Fcreate(filename, flags, create_temp, access_temp)
const char *filename; IN: Name of the file to create
uintn flags; IN: Flags to indicate various options.
hatom_t create_temp; IN: File-creation template ID
hatom_t access_temp; IN: File-access template ID
hid_t create_temp; IN: File-creation template ID
hid_t access_temp; IN: File-access template ID
ERRORS
ARGS BADVALUE Invalid file name.
@ -500,13 +500,13 @@ H5F_dest (hdf5_file_t *f)
Robb Matzke, 29 Aug 1997
Moved creation of the boot block to H5F_flush().
--------------------------------------------------------------------------*/
hatom_t H5Fcreate(const char *filename, uintn flags, hatom_t create_temp, hatom_t access_temp)
hid_t H5Fcreate(const char *filename, uintn flags, hid_t create_temp, hid_t access_temp)
{
hdf5_file_t *new_file=NULL; /* file struct for new file */
hdf_file_t f_handle=H5F_INVALID_FILE; /* file handle */
const file_create_temp_t *f_create_parms; /* pointer to the parameters to use when creating the file */
intn file_exists=0; /* flag to indicate that file exists already */
hatom_t ret_value = FAIL;
hid_t ret_value = FAIL;
FUNC_ENTER(H5Fcreate, H5F_init_interface, FAIL);
@ -607,10 +607,10 @@ done:
Open an existing HDF5 file.
USAGE
hatom_t H5Fopen(filename, flags, access_temp)
hid_t H5Fopen(filename, flags, access_temp)
const char *filename; IN: Name of the file to create
uintn flags; IN: Flags to indicate various options.
hatom_t access_temp; IN: File-access template
hid_t access_temp; IN: File-access template
ERRORS
ARGS BADRANGE Invalid file name.
@ -647,16 +647,16 @@ done:
File struct creation and destruction is through H5F_new() H5F_dest().
Reading the root symbol table entry is done with H5G_decode().
--------------------------------------------------------------------------*/
hatom_t H5Fopen(const char *filename, uintn flags, hatom_t access_temp)
hid_t H5Fopen(const char *filename, uintn flags, hid_t access_temp)
{
hdf5_file_t *new_file=NULL; /* file struct for new file */
hdf_file_t f_handle=H5F_INVALID_FILE; /* file handle */
hatom_t create_temp; /* file-creation template ID */
hid_t create_temp; /* file-creation template ID */
const file_create_temp_t *f_create_parms; /* pointer to the parameters to use when creating the file */
uint8 temp_buf[2048], *p; /* temporary buffer for encoding header */
haddr_t curr_off=0; /* The current offset to check in the file */
size_t file_len=0; /* The length of the file we are checking */
hatom_t ret_value = FAIL;
hid_t ret_value = FAIL;
size_t variable_size; /*size of the variable part of the bb */
FUNC_ENTER(H5Fopen, H5F_init_interface, FAIL);
@ -819,7 +819,7 @@ done:
USAGE
herr_t H5Fclose(fid, invalidate)
hatom_t fid; IN: File ID of file to close.
hid_t fid; IN: File ID of file to close.
hbool_t invalidate; IN: Invalidate all of the cache?
ERRORS
@ -838,7 +838,7 @@ done:
MODIFICATIONS:
--------------------------------------------------------------------------*/
herr_t
H5Fflush (hatom_t fid, hbool_t invalidate)
H5Fflush (hid_t fid, hbool_t invalidate)
{
hdf5_file_t *file = NULL;
@ -978,7 +978,7 @@ H5F_flush (hdf5_file_t *f, hbool_t invalidate)
The file boot block is flushed to disk since it's contents may have
changed.
--------------------------------------------------------------------------*/
herr_t H5Fclose(hatom_t fid)
herr_t H5Fclose(hid_t fid)
{
hdf5_file_t *file=NULL; /* file struct for file to close */
herr_t ret_value = SUCCEED;

10
src/H5Fpublic.h
View File

@ -33,11 +33,11 @@ extern "C" {
/* Functions in H5F.c */
hbool_t H5Fis_hdf5(const char *filename);
hatom_t H5Fcreate(const char *filename, uintn flags, hatom_t create_template, hatom_t access_template);
hatom_t H5Fopen(const char *filename, uintn flags, hatom_t access_template);
herr_t H5Fclose(hatom_t fid);
herr_t H5Fflush (hatom_t fid, hbool_t invalidate);
hatom_t H5Fget_create_template(hatom_t fid);
hid_t H5Fcreate(const char *filename, uintn flags, hid_t create_template, hid_t access_template);
hid_t H5Fopen(const char *filename, uintn flags, hid_t access_template);
herr_t H5Fclose(hid_t fid);
herr_t H5Fflush (hid_t fid, hbool_t invalidate);
hid_t H5Fget_create_template(hid_t fid);
void H5F_term_interface (void);
#ifdef __cplusplus

88
src/H5M.c
View File

@ -208,8 +208,8 @@ done:
PURPOSE
Create a new HDF5 object.
USAGE
hatom_t H5Mcreate(owner_id, type, name)
hatom_t owner_id; IN: Group/file which owns this object
hid_t H5Mcreate(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
@ -218,10 +218,10 @@ done:
This function re-directs the object's creation into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Mcreate(hatom_t owner_id, hobjtype_t type, const char *name)
hid_t H5Mcreate(hid_t owner_id, hobjtype_t type, const char *name)
{
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5Mcreate, H5M_init_interface, FAIL);
@ -252,19 +252,19 @@ done:
PURPOSE
Start access to an existing HDF5 object.
USAGE
hatom_t H5Maccess(owner_id)
hatom_t oid; IN: OID of the object to access.
hid_t H5Maccess(owner_id)
hid_t oid; IN: OID of the object to access.
RETURNS
Returns ID (atom) on success, FAIL on failure
DESCRIPTION
This function re-directs the object's access into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Maccess(hatom_t oid)
hid_t H5Maccess(hid_t oid)
{
group_t group;
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5Maccess, H5M_init_interface, FAIL);
@ -298,15 +298,15 @@ done:
PURPOSE
Copy an HDF5 object.
USAGE
hatom_t H5Mcopy(oid)
hatom_t oid; IN: Object to copy
hid_t H5Mcopy(oid)
hid_t oid; IN: Object to copy
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function re-directs the object's copy into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Mcopy(hatom_t oid)
hid_t H5Mcopy(hid_t oid)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
@ -341,8 +341,8 @@ done:
PURPOSE
Find an HDF5 object by name.
USAGE
hatom_t H5Mfind_name(owner_id, type, name)
hatom_t owner_id; IN: Group/file in which to search
hid_t H5Mfind_name(owner_id, type, name)
hid_t owner_id; IN: Group/file in which to search
hobjtype_t type; IN: Type of object to search names of
const char *name; IN: Name of the object to search for
RETURNS
@ -351,13 +351,13 @@ done:
This function re-directs the object's "find name" into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Mfind_name(hatom_t owner_id, hobjtype_t type, const char *name)
hid_t H5Mfind_name(hid_t owner_id, hobjtype_t type, const char *name)
{
#ifdef OLD_WAY
group_t group=H5Aatom_group(owner_id); /* Atom group for incoming object */
#endif /* OLD_WAY */
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5Mfind_name, H5M_init_interface, FAIL);
@ -396,14 +396,14 @@ done:
Determine the length of the name of an HDF5 object.
USAGE
uint32 H5Mname_len(oid)
hatom_t oid; IN: Object to get name's length
hid_t oid; IN: Object to get name's length
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function re-directs the object's "name length" into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
uint32 H5Mname_len(hatom_t oid)
uint32 H5Mname_len(hid_t oid)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
@ -439,7 +439,7 @@ done:
Get the name of an HDF5 object.
USAGE
herr_t H5Mget_name(oid, name)
hatom_t oid; IN: Object to retreive name of
hid_t oid; IN: Object to retreive name of
char *name; OUT: Buffer to place object's name in
RETURNS
SUCCEED/FAIL
@ -447,11 +447,11 @@ done:
This function re-directs the object's "get name" into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
herr_t H5Mget_name(hatom_t oid, char *name)
herr_t H5Mget_name(hid_t oid, char *name)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5Mget_name, H5M_init_interface, FAIL);
@ -483,7 +483,7 @@ done:
Set the name of an HDF5 object.
USAGE
herr_t H5Mget_name(oid, name)
hatom_t oid; IN: Object to set name of
hid_t oid; IN: Object to set name of
const char *name; IN: Name to use for object
RETURNS
SUCCEED/FAIL
@ -491,11 +491,11 @@ done:
This function re-directs the object's "set name" into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
herr_t H5Mset_name(hatom_t oid, const char *name)
herr_t H5Mset_name(hid_t oid, const char *name)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5Mset_name, H5M_init_interface, FAIL);
@ -526,8 +526,8 @@ done:
PURPOSE
Wildcard search for an HDF5 object by name.
USAGE
hatom_t H5Mfind_name(owner_id, type, name)
hatom_t owner_id; IN: Group/file in which to search
hid_t H5Mfind_name(owner_id, type, name)
hid_t owner_id; IN: Group/file in which to search
hobjtype_t type; IN: Type of object to search names of
const char *name; IN: Name of the object to search for
RETURNS
@ -536,11 +536,11 @@ done:
This function re-directs the object's "search" into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Msearch(hatom_t oid, hobjtype_t type, const char *name)
hid_t H5Msearch(hid_t oid, hobjtype_t type, const char *name)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5Msearch, H5M_init_interface, FAIL);
@ -571,8 +571,8 @@ done:
PURPOSE
Get an HDF5 object by index.
USAGE
hatom_t H5Mindex(oid, type, idx)
hatom_t oid; IN: Group/file in which to find items
hid_t H5Mindex(oid, type, idx)
hid_t oid; IN: Group/file in which to find items
hobjtype_t type; IN: Type of object to get
uint32 idx; IN: Index of the object to get
RETURNS
@ -581,11 +581,11 @@ done:
This function re-directs the object's "index" into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Mindex(hatom_t oid, hobjtype_t type, uint32 idx)
hid_t H5Mindex(hid_t oid, hobjtype_t type, uint32 idx)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5Mindex, H5M_init_interface, FAIL);
@ -616,15 +616,15 @@ done:
PURPOSE
Flush an HDF5 object out to a file.
USAGE
hatom_t H5Mflush(oid)
hatom_t oid; IN: Object to flush
hid_t H5Mflush(oid)
hid_t oid; IN: Object to flush
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function re-directs the object's flush into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Mflush(hatom_t oid)
hid_t H5Mflush(hid_t oid)
{
group_t group; /* Atom group for incoming object */
intn i; /* local counting variable */
@ -662,7 +662,7 @@ done:
Delete an HDF5 object from a file.
USAGE
herr_t H5Mdelete(oid)
hatom_t oid; IN: Object to delete
hid_t oid; IN: Object to delete
RETURNS
SUCCEED/FAIL
DESCRIPTION
@ -670,7 +670,7 @@ done:
interface, as defined by the function pointers in hdf5fptr.h. Deleting
an object implicitly ends access to it.
--------------------------------------------------------------------------*/
herr_t H5Mdelete(hatom_t oid)
herr_t H5Mdelete(hid_t oid)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
@ -705,15 +705,15 @@ done:
PURPOSE
Get the parent ID an HDF5 object.
USAGE
hatom_t H5Mget_parent(oid)
hatom_t oid; IN: Object to query
hid_t H5Mget_parent(oid)
hid_t oid; IN: Object to query
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function re-directs the object's query into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Mget_parent(hatom_t oid)
hid_t H5Mget_parent(hid_t oid)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
@ -748,15 +748,15 @@ done:
PURPOSE
Get the file ID an HDF5 object.
USAGE
hatom_t H5Mget_file(oid)
hatom_t oid; IN: Object to query
hid_t H5Mget_file(oid)
hid_t oid; IN: Object to query
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function re-directs the object's query into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
hatom_t H5Mget_file(hatom_t oid)
hid_t H5Mget_file(hid_t oid)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
@ -792,14 +792,14 @@ done:
Release access to an HDF5 object.
USAGE
herr_t H5Mrelease(oid)
hatom_t oid; IN: Object to release access to
hid_t oid; IN: Object to release access to
RETURNS
SUCCEED/FAIL
DESCRIPTION
This function re-directs the object's release into the appropriate
interface, as defined by the function pointers in hdf5fptr.h
--------------------------------------------------------------------------*/
herr_t H5Mrelease(hatom_t oid)
herr_t H5Mrelease(hid_t oid)
{
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */

28
src/H5Mprivate.h
View File

@ -30,20 +30,20 @@
typedef struct meta_func_t
{
hobjtype_t type; /* Object type this interface is for */
hatom_t (*create) (hatom_t , hobjtype_t, const char *); /* Object creation function */
hatom_t (*access) (hatom_t ); /* Object access function */
hatom_t (*copy) (hatom_t ); /* Object copy function */
hatom_t (*find_name) (hatom_t , hobjtype_t, const char *); /* Find first object */
uint32 (*name_len) (hatom_t ); /* Get length of object name */
herr_t (*get_name) (hatom_t , char *); /* Get object name */
herr_t (*set_name) (hatom_t , const char *); /* Set object name */
hatom_t (*search) (hatom_t , hobjtype_t, const char *); /* Search for list of objects */
hatom_t (*index) (hatom_t , hobjtype_t, uint32); /* Get the OID for the n'th object */
herr_t (*flush) (hatom_t ); /* Flush the object to disk */
herr_t (*delete) (hatom_t ); /* Delete an object from file */
hatom_t (*get_parent) (hatom_t ); /* Get the parent object of an object */
hatom_t (*get_file) (hatom_t ); /* Get the file ID of an object */
herr_t (*release) (hatom_t ); /* End access to an object */
hid_t (*create) (hid_t , hobjtype_t, const char *); /* Object creation function */
hid_t (*access) (hid_t ); /* Object access function */
hid_t (*copy) (hid_t ); /* Object copy function */
hid_t (*find_name) (hid_t , hobjtype_t, const char *); /* Find first object */
uint32 (*name_len) (hid_t ); /* Get length of object name */
herr_t (*get_name) (hid_t , char *); /* Get object name */
herr_t (*set_name) (hid_t , const char *); /* Set object name */
hid_t (*search) (hid_t , hobjtype_t, const char *); /* Search for list of objects */
hid_t (*index) (hid_t , hobjtype_t, uint32); /* Get the OID for the n'th object */
herr_t (*flush) (hid_t ); /* Flush the object to disk */
herr_t (*delete) (hid_t ); /* Delete an object from file */
hid_t (*get_parent) (hid_t ); /* Get the parent object of an object */
hid_t (*get_file) (hid_t ); /* Get the file ID of an object */
herr_t (*release) (hid_t ); /* End access to an object */
}
meta_func_t;

28
src/H5Mpublic.h
View File

@ -29,20 +29,20 @@ extern "C" {
#endif
/* Functions in H5M.c */
hatom_t H5Mcreate(hatom_t owner_id, hobjtype_t type, const char *name);
hatom_t H5Maccess(hatom_t oid);
hatom_t H5Mcopy(hatom_t oid);
hatom_t H5Mfind_name(hatom_t oid, hobjtype_t type, const char *name);
uint32 H5Mname_len(hatom_t oid);
herr_t H5Mget_name(hatom_t oid, char *name);
herr_t H5Mset_name(hatom_t oid, const char *name);
hatom_t H5Msearch(hatom_t oid, hobjtype_t type, const char *name);
hatom_t H5Mindex(hatom_t oid, hobjtype_t type, uint32 idx);
hatom_t H5Mflush(hatom_t oid);
herr_t H5Mdelete(hatom_t oid);
hatom_t H5Mget_file(hatom_t oid);
hatom_t H5Mget_parent(hatom_t oid);
herr_t H5Mrelease(hatom_t oid);
hid_t H5Mcreate(hid_t owner_id, hobjtype_t type, const char *name);
hid_t H5Maccess(hid_t oid);
hid_t H5Mcopy(hid_t oid);
hid_t H5Mfind_name(hid_t oid, hobjtype_t type, const char *name);
uint32 H5Mname_len(hid_t oid);
herr_t H5Mget_name(hid_t oid, char *name);
herr_t H5Mset_name(hid_t oid, const char *name);
hid_t H5Msearch(hid_t oid, hobjtype_t type, const char *name);
hid_t H5Mindex(hid_t oid, hobjtype_t type, uint32 idx);
hid_t H5Mflush(hid_t oid);
herr_t H5Mdelete(hid_t oid);
hid_t H5Mget_file(hid_t oid);
hid_t H5Mget_parent(hid_t oid);
herr_t H5Mrelease(hid_t oid);
#ifdef __cplusplus
}

20
src/H5P.c
View File

@ -97,8 +97,8 @@ void H5P_term_interface (void)
PURPOSE
Create a new HDF5 dimensionality object
USAGE
hatom_t H5P_create(owner_id, type, name)
hatom_t owner_id; IN: Group/file which owns this object
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
@ -106,10 +106,10 @@ void H5P_term_interface (void)
DESCRIPTION
This function actually creates the dimensionality object.
--------------------------------------------------------------------------*/
hatom_t H5P_create(hatom_t owner_id, hobjtype_t type, const char *name)
hid_t H5P_create(hid_t owner_id, hobjtype_t type, const char *name)
{
H5P_dim_t *new_dim; /* new dimensionality object to create */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5P_create, H5P_init_interface, FAIL);
@ -229,7 +229,7 @@ done:
Determine the size of a dataspace
USAGE
herr_t H5Pset_space(sid, rank, dims)
hatom_t sid; IN: Dataspace object to query
hid_t sid; IN: Dataspace object to query
uint32 rank; IN: # of dimensions for the dataspace
uint32 *dims; IN: Size of each dimension for the dataspace
RETURNS
@ -243,7 +243,7 @@ done:
expand. Currently, only the first dimension in the array (the slowest) may
be unlimited in size.
--------------------------------------------------------------------------*/
herr_t H5Pset_space(hatom_t sid, uint32 rank, uint32 *dims)
herr_t H5Pset_space(hid_t sid, uint32 rank, uint32 *dims)
{
H5P_dim_t *space=NULL; /* dataspace to modify */
uintn u; /* local counting variable */
@ -395,7 +395,7 @@ done:
Return the number of elements in a dataspace
USAGE
uintn H5Pnelem(sid)
hatom_t sid; IN: Dataspace object to query
hid_t sid; IN: Dataspace object to query
RETURNS
The number of elements in a dataspace on success, UFAIL on failure
DESCRIPTION
@ -404,7 +404,7 @@ done:
2, 3 and 4 would have 24 elements.
UFAIL is returned on an error, otherwise the number of elements is returned.
--------------------------------------------------------------------------*/
uintn H5Pnelem(hatom_t sid)
uintn H5Pnelem(hid_t sid)
{
H5P_dim_t *space=NULL; /* dataspace to modify */
uintn ret_value = UFAIL;
@ -442,13 +442,13 @@ done:
Release access to an HDF5 dimensionality object.
USAGE
herr_t H5P_release(oid)
hatom_t oid; IN: Object to release access to
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(hatom_t oid)
herr_t H5P_release(hid_t oid)
{
H5P_dim_t *dim; /* dimensionality object to release */
herr_t ret_value = SUCCEED;

4
src/H5Pprivate.h
View File

@ -39,10 +39,10 @@ typedef struct H5P_sdim_t {
#define H5P_RESERVED_ATOMS 1
/* Private functions */
hatom_t H5P_create(hatom_t owner_id, hobjtype_t type, const char *name);
hid_t H5P_create(hid_t owner_id, hobjtype_t type, const char *name);
uint32 H5P_get_lrank(H5P_sdim_t *sdim);
hbool_t H5P_is_simple(H5P_dim_t *sdim);
uintn H5P_nelem(H5P_dim_t *space);
herr_t H5P_release(hatom_t oid);
herr_t H5P_release(hid_t oid);
#endif

4
src/H5Ppublic.h
View File

@ -41,8 +41,8 @@ extern "C" {
#endif
/* Functions in H5P.c */
uintn H5Pnelem(hatom_t dim_id);
herr_t H5Pset_space(hatom_t sid, uint32 rank, uint32 *dims);
uintn H5Pnelem(hid_t dim_id);
herr_t H5Pset_space(hid_t sid, uint32 rank, uint32 *dims);
void H5P_term_interface (void);
#ifdef __cplusplus

52
src/H5T.c
View File

@ -108,8 +108,8 @@ void H5T_term_interface (void)
PURPOSE
Create a new HDF5 data-type object
USAGE
hatom_t H5T_create(owner_id, type, name)
hatom_t owner_id; IN: Group/file which owns this object
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
@ -117,10 +117,10 @@ void H5T_term_interface (void)
DESCRIPTION
This function actually creates the data-type object.
--------------------------------------------------------------------------*/
hatom_t H5T_create(hatom_t owner_id, hobjtype_t type, const char *name)
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 */
hatom_t ret_value = SUCCEED;
hid_t ret_value = SUCCEED;
FUNC_ENTER(H5T_create, H5T_init_interface, FAIL);
@ -158,7 +158,7 @@ done:
Return the number of fields in a compound datatype
USAGE
uint32 H5Tget_num_fields(tid)
hatom_t tid; IN: Datatype object to query
hid_t tid; IN: Datatype object to query
RETURNS
The number of fields in a compound datatype on success, UFAIL on failure
DESCRIPTION
@ -166,7 +166,7 @@ done:
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(hatom_t tid)
uint32 H5Tget_num_fields(hid_t tid)
{
h5_datatype_t *dt; /* new data-type object to create */
uint32 ret_value = UFAIL;
@ -209,7 +209,7 @@ done:
Check if a field in a compound datatype is atomic
USAGE
hbool_t H5Tis_field_atomic(tid, fidx)
hatom_t tid; IN: Datatype object to query
hid_t tid; IN: Datatype object to query
uintn fidx; IN: Index of the field to query
RETURNS
BFAIL/BTRUE/BFALSE
@ -218,7 +218,7 @@ done:
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(hatom_t tid, uintn fidx)
hbool_t H5Tis_field_atomic(hid_t tid, uintn fidx)
{
h5_datatype_t *dt; /* new data-type object to create */
hbool_t ret_value = BTRUE;
@ -308,7 +308,7 @@ done:
Check if a datatype is atomic (API)
USAGE
hbool_t H5Tis_atomic(tid)
hatom_t tid; IN: Datatype object to query
hid_t tid; IN: Datatype object to query
RETURNS
BFAIL/BTRUE/BFALSE
DESCRIPTION
@ -316,7 +316,7 @@ done:
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(hatom_t tid)
hbool_t H5Tis_atomic(hid_t tid)
{
h5_datatype_t *dt; /* new data-type object to create */
hbool_t ret_value = BTRUE;
@ -353,8 +353,8 @@ done:
Set the base type of a user-defined datatype
USAGE
herr_t H5Tset_type(tid, base, len, arch)
hatom_t tid; IN: Datatype object to modify
hatom_t base; IN: Base type to set the datatype to
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
@ -365,7 +365,7 @@ done:
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(hatom_t tid,hatom_t base,uint8 len,uint8 arch)
herr_t H5Tset_type(hid_t tid,hid_t base,uint8 len,uint8 arch)
{
h5_datatype_t *dt; /* new data-type object to create */
herr_t ret_value = SUCCEED;
@ -406,8 +406,8 @@ done:
Get the base type of a datatype
USAGE
herr_t H5Tget_type(tid, base, len, arch)
hatom_t tid; IN: Datatype object to modify
hatom_t *base; IN: Base type of the datatype
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
@ -418,7 +418,7 @@ done:
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(hatom_t tid,hatom_t *base,uint8 *len,uint8 *arch)
herr_t H5Tget_type(hid_t tid,hid_t *base,uint8 *len,uint8 *arch)
{
h5_datatype_t *dt; /* new data-type object to create */
herr_t ret_value = SUCCEED;
@ -462,14 +462,14 @@ done:
Add a field to a compound datatype
USAGE
herr_t H5Tadd_field(tid, name, base, len, arch, space)
hatom_t tid; IN: Datatype object to query
hid_t tid; IN: Datatype object to query
const char *fidx; IN: Field name
hatom_t base; IN: Field's base type, either an atom ID for
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
hatom_t space; IN: The dimensionality of the field to add
hid_t space; IN: The dimensionality of the field to add
RETURNS
SUCCEED/FAIL
DESCRIPTION
@ -479,7 +479,7 @@ done:
(to indicate a scalar field) or the atom of a datatype for more complex
dimensionality fields.
--------------------------------------------------------------------------*/
herr_t H5Tadd_field(hatom_t tid, const char *name, hatom_t base, uint8 len, uint8 arch, hatom_t space)
herr_t H5Tadd_field(hid_t tid, const char *name, hid_t base, uint8 len, uint8 arch, hid_t space)
{
h5_field_info_t *new_field; /* pointer to new field to add */
h5_datatype_t *dt; /* data-type object to manipulate */
@ -636,7 +636,7 @@ done:
Determine the size of a datatype
USAGE
uintn H5Tsize(tid, mem_flag)
hatom_t tid; IN: Datatype object to query
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.
@ -645,7 +645,7 @@ done:
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 H5Tsize(hatom_t tid, uint8 len, uint8 arch, hbool_t mem_flag)
uintn H5Tsize(hid_t tid, uint8 len, uint8 arch, hbool_t mem_flag)
{
uintn ret_value = UFAIL;
@ -713,7 +713,7 @@ done:
Determine the size of a datatype
USAGE
herr_t H5Tget_fields(tid, field_list)
hatom_t tid; IN: Datatype object to query
hid_t tid; IN: Datatype object to query
hoid_t *field_list; IN: Array to store list of fields
RETURNS
SUCCEED/FAIL
@ -722,7 +722,7 @@ done:
datatype. Atomic fields are returned in the list of OIDs, but have special
OID values which cannot be further dereferenced.
--------------------------------------------------------------------------*/
herr_t H5Tget_fields(hatom_t tid, hatom_t *field_list)
herr_t H5Tget_fields(hid_t tid, hid_t *field_list)
{
herr_t ret_value = FAIL;
@ -753,13 +753,13 @@ done:
Release access to an HDF5 datatype object.
USAGE
herr_t H5T_release(oid)
hatom_t oid; IN: Object to release access to
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(hatom_t oid)
herr_t H5T_release(hid_t oid)
{
h5_datatype_t *dt; /* new data-type object to create */
herr_t ret_value = SUCCEED;

6
src/H5Tprivate.h
View File

@ -32,7 +32,7 @@ typedef struct {
uintn name_off; /* Offset of name in global small-data heap */
uintn struct_off; /* Offset of field within structure */
h5_atomic_type_t dt; /* Datatype of the field */
hatom_t dim_id; /* dimensionality ID of the field */
hid_t dim_id; /* dimensionality ID of the field */
} h5_field_info_t;
/* Structure for storing information about a compound datatype */
@ -51,9 +51,9 @@ typedef struct {
} h5_datatype_t;
/* Private functions */
hatom_t H5T_create(hatom_t owner_id, hobjtype_t type, const char *name);
hid_t H5T_create(hid_t owner_id, hobjtype_t type, const char *name);
hbool_t H5T_is_atomic(h5_datatype_t *type);
uintn H5T_size(h5_datatype_t *dt, hbool_t mem_flag);
herr_t H5T_release(hatom_t oid);
herr_t H5T_release(hid_t oid);
#endif

20
src/H5Tpublic.h
View File

@ -55,7 +55,7 @@ WARNING!
#endif /* WORDS_BIGENDIAN */
typedef struct {
hatom_t base; /* Basic datatype */
hid_t base; /* Basic datatype */
uint8 len; /* Length of base-type, in bytes */
uint8 arch; /* Architecture of the base-type */
} h5_atomic_type_t;
@ -65,15 +65,15 @@ extern "C" {
#endif
/* Functions in H5T.c */
uint32 H5Tget_num_fields(hatom_t tid);
hbool_t H5Tis_field_atomic(hatom_t tid,uintn fidx);
hbool_t H5Tis_atomic(hatom_t tid);
herr_t H5Tset_type(hatom_t tid,hatom_t base,uint8 len,uint8 arch);
herr_t H5Tget_type(hatom_t tid,hatom_t *base,uint8 *len,uint8 *arch);
uintn H5Tsize(hatom_t tid, uint8 len, uint8 arch, hbool_t mem_flag);
herr_t H5Tadd_field (hatom_t tid, const char *name, hatom_t base, uint8 len,
uint8 arch, hatom_t space);
herr_t H5Tget_fields(hatom_t tid, hatom_t *field_list);
uint32 H5Tget_num_fields(hid_t tid);
hbool_t H5Tis_field_atomic(hid_t tid,uintn fidx);
hbool_t H5Tis_atomic(hid_t tid);
herr_t H5Tset_type(hid_t tid,hid_t base,uint8 len,uint8 arch);
herr_t H5Tget_type(hid_t tid,hid_t *base,uint8 *len,uint8 *arch);
uintn H5Tsize(hid_t tid, uint8 len, uint8 arch, hbool_t mem_flag);
herr_t H5Tadd_field (hid_t tid, const char *name, hid_t base, uint8 len,
uint8 arch, hid_t space);
herr_t H5Tget_fields(hid_t tid, hid_t *field_list);
void H5T_term_interface (void);
#ifdef __cplusplus

2
src/debug.c
View File

@ -45,7 +45,7 @@
int
main (int argc, char *argv[])
{
hatom_t fid;
hid_t fid;
hdf5_file_t *f;
haddr_t addr = 0;
uint8 sig[16];

8
test/tfile.c
View File

@ -61,8 +61,8 @@ static const uintn btree_k_default_g[] = H5C_BTREE_K_DEFAULT;
****************************************************************/
static void test_file_create(void)
{
hatom_t fid1,fid2,fid3; /* HDF5 File IDs */
hatom_t tmpl1,tmpl2; /* File creation templates */
hid_t fid1,fid2,fid3; /* HDF5 File IDs */
hid_t tmpl1,tmpl2; /* File creation templates */
uintn parm; /* File-creation parameters */
uint8 parm2; /* File-creation parameters */
herr_t ret; /* Generic return value */
@ -240,8 +240,8 @@ static void test_file_create(void)
****************************************************************/
static void test_file_open(void)
{
hatom_t fid1; /* HDF5 File IDs */
hatom_t tmpl1; /* File creation templates */
hid_t fid1; /* HDF5 File IDs */
hid_t tmpl1; /* File creation templates */
uintn parm; /* File-creation parameters */
uint8 parm2; /* File-creation parameters */
herr_t ret; /* Generic return value */

26
test/th5d.c
View File

@ -76,14 +76,14 @@ float64 data2[SPACE2_DIM1][SPACE2_DIM2][SPACE2_DIM3][SPACE2_DIM4]=
****************************************************************/
static void test_h5d_basic_write(void)
{
hatom_t fid1; /* HDF5 File IDs */
hatom_t did1; /* Dataset ID */
hatom_t tid1; /* Datatype ID */
hatom_t sid1; /* Dataspace ID */
hid_t fid1; /* HDF5 File IDs */
hid_t did1; /* Dataset ID */
hid_t tid1; /* Datatype ID */
hid_t sid1; /* Dataspace ID */
uint32 dims1[]={SPACE1_DIM1,SPACE1_DIM2,SPACE1_DIM3}; /* dataspace dim sizes */
hatom_t did2; /* Dataset ID */
hatom_t tid2; /* Datatype ID */
hatom_t sid2; /* Dataspace ID */
hid_t did2; /* Dataset ID */
hid_t tid2; /* Datatype ID */
hid_t sid2; /* Dataspace ID */
uint32 dims2[]={SPACE2_DIM1,SPACE2_DIM2,SPACE2_DIM3,SPACE2_DIM4}; /* dataspace dim sizes */
herr_t ret; /* Generic return value */
@ -166,16 +166,16 @@ static void test_h5d_basic_write(void)
****************************************************************/
static void test_h5d_basic_read(void)
{
hatom_t fid1; /* HDF5 File IDs */
hid_t fid1; /* HDF5 File IDs */
#if 0
hatom_t oid1; /* Dataset OID */
hid_t oid1; /* Dataset OID */
#endif
hatom_t did1; /* Dataset ID */
hatom_t tid1; /* Datatype ID */
hatom_t sid1; /* Dataspace ID */
hid_t did1; /* Dataset ID */
hid_t tid1; /* Datatype ID */
hid_t sid1; /* Dataspace ID */
void *buf; /* space for the buffer read */
uint32 buf_size; /* size of the buffer to read */
hatom_t type; /* Datatype's base type */
hid_t type; /* Datatype's base type */
uint8 len, arch; /* Datatype's length and architecture */
uintn n; /* number of dataspace elements */
herr_t ret; /* Generic return value */

4
test/th5p.c
View File

@ -55,8 +55,8 @@ static char RcsId[] = "$Revision$";
****************************************************************/
static void test_h5p_basic(void)
{
hatom_t fid1; /* HDF5 File IDs */
hatom_t sid1,sid2; /* Dataspace ID */
hid_t fid1; /* HDF5 File IDs */
hid_t sid1,sid2; /* Dataspace ID */
uint32 dims1[]={SPACE1_DIM1,SPACE1_DIM2,SPACE1_DIM3}, /* dataspace dim sizes */
dims2[]={SPACE2_DIM1,SPACE2_DIM2,SPACE2_DIM3,SPACE2_DIM4};
uintn n; /* number of dataspace elements */

6
test/th5t.c
View File

@ -50,9 +50,9 @@ static char RcsId[] = "$Revision$";
****************************************************************/
static void test_h5t_basic(void)
{
hatom_t fid1; /* HDF5 File IDs */
hatom_t tid1,tid2; /* Datatype ID */
hatom_t type; /* Datatype's base type */
hid_t fid1; /* HDF5 File IDs */
hid_t tid1,tid2; /* Datatype ID */
hid_t type; /* Datatype's base type */
uint8 len, arch; /* Datatype's length and architecture */
herr_t ret; /* Generic return value */

2
test/theap.c
View File

@ -43,7 +43,7 @@ void
test_heap (void)
{
int i, j;
hatom_t fid;
hid_t fid;
hdf5_file_t *f;
off_t heap;
char buf[NOBJS+8];

2
test/tohdr.c
View File

@ -47,7 +47,7 @@
void
test_ohdr (void)
{
hatom_t fid;
hid_t fid;
hdf5_file_t *f;
haddr_t oh;
H5O_stab_t stab, ro;

4
test/tstab.c
View File

@ -49,7 +49,7 @@
static void
test_1 (void)
{
hatom_t fid;
hid_t fid;
hdf5_file_t *f;
H5G_entry_t *obj1=NULL, *obj2=NULL;
H5G_entry_t ent1, dir_ent;
@ -223,7 +223,7 @@ test_1 (void)
static void
test_2 (void)
{
hatom_t fid;
hid_t fid;
hdf5_file_t *f;
H5G_entry_t cwd, sub;
H5G_entry_t *obj1=NULL;