/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include "H5LTprivate.h"
#include "H5private.h"
/* For Lex and Yacc */
#define COL 3
#define LIMIT 512
#define INCREMENT 1024
#define TMP_LEN 256
#define MAX(a,b) (((a)>(b)) ? (a) : (b))
int input_len;
char *myinput;
size_t indent = 0;
/*-------------------------------------------------------------------------
*
* internal functions
*
*-------------------------------------------------------------------------
*/
static herr_t H5LT_get_attribute_mem(hid_t loc_id,
const char *obj_name,
const char *attr_name,
hid_t mem_type_id,
void *data);
/*-------------------------------------------------------------------------
* Function: H5LT_make_dataset
*
* Purpose: Creates and writes a dataset of a type tid
*
* Return: Success: 0, Failure: -1
*
* Programmer: Quincey Koziol, koziol@hdfgroup.org
*
* Date: October 10, 2007
*
*-------------------------------------------------------------------------
*/
static herr_t
H5LT_make_dataset_numerical( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
hid_t tid,
const void *data )
{
hid_t did = -1, sid = -1;
/* Create the data space for the dataset. */
if((sid = H5Screate_simple(rank, dims, NULL)) < 0)
return -1;
/* Create the dataset. */
if((did = H5Dcreate2(loc_id, dset_name, tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto out;
/* Write the dataset only if there is data to write */
if(data)
if(H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, data) < 0)
goto out;
/* End access to the dataset and release resources used by it. */
if(H5Dclose(did) < 0)
return -1;
/* Terminate access to the data space. */
if(H5Sclose(sid) < 0)
return -1;
return 0;
out:
H5E_BEGIN_TRY {
H5Dclose(did);
H5Sclose(sid);
} H5E_END_TRY;
return -1;
}
/*-------------------------------------------------------------------------
*
* Public functions
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset
*
* Purpose: Creates and writes a dataset of a type tid
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 19, 2001
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
hid_t tid,
const void *data )
{
return(H5LT_make_dataset_numerical(loc_id, dset_name, rank, dims, tid, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset_char
*
* Purpose: Creates and writes a dataset of H5T_NATIVE_CHAR type
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 14, 2001
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset_char( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
const char *data )
{
return(H5LT_make_dataset_numerical(loc_id, dset_name, rank, dims, H5T_NATIVE_CHAR, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset_short
*
* Purpose: Creates and writes a dataset of H5T_NATIVE_SHORT type
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 14, 2001
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset_short( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
const short *data )
{
return(H5LT_make_dataset_numerical(loc_id, dset_name, rank, dims, H5T_NATIVE_SHORT, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset_int
*
* Purpose: Creates and writes a dataset of H5T_NATIVE_INT type
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 14, 2001
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset_int( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
const int *data )
{
return(H5LT_make_dataset_numerical(loc_id, dset_name, rank, dims, H5T_NATIVE_INT, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset_long
*
* Purpose: Creates and writes a dataset of H5T_NATIVE_LONG type
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 14, 2001
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset_long( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
const long *data )
{
return(H5LT_make_dataset_numerical(loc_id, dset_name, rank, dims, H5T_NATIVE_LONG, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset_float
*
* Purpose: Creates and writes a dataset of H5T_NATIVE_FLOAT type
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 14, 2001
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset_float( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
const float *data )
{
return(H5LT_make_dataset_numerical(loc_id, dset_name, rank, dims, H5T_NATIVE_FLOAT, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset_double
*
* Purpose: Creates and writes a dataset of H5T_NATIVE_DOUBLE type
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 14, 2001
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset_double( hid_t loc_id,
const char *dset_name,
int rank,
const hsize_t *dims,
const double *data )
{
return(H5LT_make_dataset_numerical(loc_id, dset_name, rank, dims, H5T_NATIVE_DOUBLE, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTmake_dataset_string
*
* Purpose: Creates and writes a dataset of H5T_C_S1 type
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: October 05, 2004
*
* Comments:
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
herr_t H5LTmake_dataset_string(hid_t loc_id,
const char *dset_name,
const char *buf )
{
hid_t did = -1;
hid_t sid = -1;
hid_t tid = -1;
size_t size;
/* create a string data type */
if((tid = H5Tcopy(H5T_C_S1)) < 0 )
goto out;
size = strlen(buf) + 1; /* extra null term */
if(H5Tset_size(tid, size) < 0)
goto out;
if(H5Tset_strpad(tid, H5T_STR_NULLTERM) < 0)
goto out;
/* Create the data space for the dataset. */
if((sid = H5Screate(H5S_SCALAR)) < 0)
goto out;
/* Create the dataset. */
if((did = H5Dcreate2(loc_id, dset_name, tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto out;
/* Write the dataset only if there is data to write */
if(buf)
if(H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
goto out;
/* close*/
if(H5Dclose(did) < 0)
return -1;
if(H5Sclose(sid) < 0)
return -1;
if(H5Tclose(tid) < 0)
goto out;
return 0;
out:
H5E_BEGIN_TRY {
H5Dclose(did);
H5Tclose(tid);
H5Sclose(sid);
} H5E_END_TRY;
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LT_read_dataset
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Quincey Koziol, koziol@hdfgroup.org
*
* Date: October 8, 2007
*
*-------------------------------------------------------------------------
*/
static herr_t
H5LT_read_dataset_numerical(hid_t loc_id, const char *dset_name, hid_t tid, void *data)
{
hid_t did;
/* Open the dataset. */
if((did = H5Dopen2(loc_id, dset_name, H5P_DEFAULT)) < 0)
return -1;
/* Read */
if(H5Dread(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, data) < 0)
goto out;
/* End access to the dataset and release resources used by it. */
if(H5Dclose(did))
return -1;
return 0;
out:
H5Dclose(did);
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: June 13, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset(hid_t loc_id,
const char *dset_name,
hid_t tid,
void *data)
{
return(H5LT_read_dataset_numerical(loc_id, dset_name, tid, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset_char
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 5, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset_char( hid_t loc_id,
const char *dset_name,
char *data )
{
return(H5LT_read_dataset_numerical(loc_id, dset_name, H5T_NATIVE_CHAR, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset_short
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 5, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset_short( hid_t loc_id,
const char *dset_name,
short *data )
{
return(H5LT_read_dataset_numerical(loc_id, dset_name, H5T_NATIVE_SHORT, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset_int
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 5, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset_int( hid_t loc_id,
const char *dset_name,
int *data )
{
return(H5LT_read_dataset_numerical(loc_id, dset_name, H5T_NATIVE_INT, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset_long
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 5, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset_long( hid_t loc_id,
const char *dset_name,
long *data )
{
return(H5LT_read_dataset_numerical(loc_id, dset_name, H5T_NATIVE_LONG, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset_float
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 5, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset_float( hid_t loc_id,
const char *dset_name,
float *data )
{
return(H5LT_read_dataset_numerical(loc_id, dset_name, H5T_NATIVE_FLOAT, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset_double
*
* Purpose: Reads a dataset from disk.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 5, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset_double( hid_t loc_id,
const char *dset_name,
double *data )
{
return(H5LT_read_dataset_numerical(loc_id, dset_name, H5T_NATIVE_DOUBLE, data));
}
/*-------------------------------------------------------------------------
* Function: H5LTread_dataset_string
*
* Purpose: Reads a dataset
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: October 05, 2004
*
*-------------------------------------------------------------------------
*/
herr_t H5LTread_dataset_string( hid_t loc_id,
const char *dset_name,
char *buf )
{
hid_t did = -1;
hid_t tid = -1;
/* Open the dataset. */
if((did = H5Dopen2(loc_id, dset_name, H5P_DEFAULT)) < 0)
return -1;
if((tid = H5Dget_type(did)) < 0)
goto out;
/* Read */
if(H5Dread(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
goto out;
/* close */
if(H5Dclose(did))
goto out;
if(H5Tclose(tid))
return -1;
return 0;
out:
H5E_BEGIN_TRY {
H5Dclose(did);
H5Tclose(tid);
} H5E_END_TRY;
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_dataset_ndims
*
* Purpose: Gets the dimensionality of a dataset.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 4, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_dataset_ndims( hid_t loc_id,
const char *dset_name,
int *rank )
{
hid_t did = -1;
hid_t sid = -1;
/* Open the dataset. */
if((did = H5Dopen2(loc_id, dset_name, H5P_DEFAULT)) < 0)
return -1;
/* Get the dataspace handle */
if((sid = H5Dget_space(did)) < 0)
goto out;
/* Get rank */
if((*rank = H5Sget_simple_extent_ndims(sid)) < 0)
goto out;
/* Terminate access to the dataspace */
if(H5Sclose(sid) < 0)
goto out;
/* End access to the dataset */
if(H5Dclose(did))
return -1;
return 0;
out:
H5E_BEGIN_TRY {
H5Dclose(did);
H5Sclose(sid);
} H5E_END_TRY;
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_dataset_info
*
* Purpose: Gets information about a dataset.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 4, 2001
* Modified: February 28, 2006: checked for NULL parameters
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_dataset_info( hid_t loc_id,
const char *dset_name,
hsize_t *dims,
H5T_class_t *type_class,
size_t *type_size )
{
hid_t did = -1;
hid_t tid = -1;
hid_t sid = -1;
/* open the dataset. */
if((did = H5Dopen2(loc_id, dset_name, H5P_DEFAULT)) < 0)
return -1;
/* get an identifier for the datatype. */
tid = H5Dget_type(did);
/* get the class. */
if(type_class != NULL)
*type_class = H5Tget_class(tid);
/* get the size. */
if(type_size!=NULL)
*type_size = H5Tget_size(tid);
if(dims != NULL) {
/* get the dataspace handle */
if((sid = H5Dget_space(did)) < 0)
goto out;
/* get dimensions */
if(H5Sget_simple_extent_dims(sid, dims, NULL) < 0)
goto out;
/* terminate access to the dataspace */
if(H5Sclose(sid) < 0)
goto out;
} /* end if */
/* release the datatype. */
if(H5Tclose(tid))
return -1;
/* end access to the dataset */
if(H5Dclose(did))
return -1;
return 0;
out:
H5E_BEGIN_TRY {
H5Tclose(tid);
H5Sclose(sid);
H5Dclose(did);
} H5E_END_TRY;
return -1;
}
/*-------------------------------------------------------------------------
* Function: find_dataset
*
* Purpose: operator function used by H5LTfind_dataset
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: June 21, 2001
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
find_dataset(hid_t loc_id, const char *name, const H5L_info_t *linfo, void *op_data)
{
/* Define a default zero value for return. This will cause the iterator to continue if
* the dataset is not found yet.
*/
int ret = 0;
/* Shut the compiler up */
loc_id = loc_id;
linfo = linfo;
/* Define a positive value for return value if the dataset was found. This will
* cause the iterator to immediately return that positive value,
* indicating short-circuit success
*/
if(strcmp(name, (char *)op_data) == 0)
ret = 1;
return ret;
}
/*-------------------------------------------------------------------------
* Function: H5LTfind_dataset
*
* Purpose: Inquires if a dataset named dset_name exists attached
* to the object loc_id.
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: July 15, 2001
*
* Return:
* Success: The return value of the first operator that
* returns non-zero, or zero if all members were
* processed with no operator returning non-zero.
*
* Failure: Negative if something goes wrong within the
* library, or the negative value returned by one
* of the operators.
*
*-------------------------------------------------------------------------
*/
herr_t
H5LTfind_dataset( hid_t loc_id, const char *dset_name )
{
return H5Literate(loc_id, H5_INDEX_NAME, H5_ITER_INC, 0, find_dataset, (void *)dset_name);
}
/*-------------------------------------------------------------------------
*
* Set attribute functions
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_string
*
* Purpose: Creates and writes a string attribute named attr_name and attaches
* it to the object specified by the name obj_name.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: July 23, 2001
*
* Comments: If the attribute already exists, it is overwritten
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_string( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const char *attr_data )
{
hid_t attr_type;
hid_t attr_space_id;
hid_t attr_id;
hid_t obj_id;
int has_attr;
size_t attr_size;
/* Open the object */
if ((obj_id = H5Oopen(loc_id, obj_name, H5P_DEFAULT)) < 0)
return -1;
/* Create the attribute */
if ( (attr_type = H5Tcopy( H5T_C_S1 )) < 0 )
goto out;
attr_size = strlen( attr_data ) + 1; /* extra null term */
if ( H5Tset_size( attr_type, (size_t)attr_size) < 0 )
goto out;
if ( H5Tset_strpad( attr_type, H5T_STR_NULLTERM ) < 0 )
goto out;
if ( (attr_space_id = H5Screate( H5S_SCALAR )) < 0 )
goto out;
/* Verify if the attribute already exists */
has_attr = H5LT_find_attribute(obj_id, attr_name);
/* The attribute already exists, delete it */
if(has_attr == 1)
if(H5Adelete(obj_id, attr_name) < 0)
goto out;
/* Create and write the attribute */
if((attr_id = H5Acreate2(obj_id, attr_name, attr_type, attr_space_id, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto out;
if(H5Awrite(attr_id, attr_type, attr_data) < 0)
goto out;
if(H5Aclose(attr_id) < 0)
goto out;
if(H5Sclose(attr_space_id) < 0)
goto out;
if(H5Tclose(attr_type) < 0)
goto out;
/* Close the object */
if(H5Oclose(obj_id) < 0)
return -1;
return 0;
out:
H5Oclose(obj_id);
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LT_set_attribute_numerical
*
* Purpose: Private function used by H5LTset_attribute_int and H5LTset_attribute_float
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: July 25, 2001
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LT_set_attribute_numerical( hid_t loc_id,
const char *obj_name,
const char *attr_name,
size_t size,
hid_t tid,
const void *data )
{
hid_t obj_id, sid, attr_id;
hsize_t dim_size=size;
int has_attr;
/* Open the object */
if ((obj_id = H5Oopen(loc_id, obj_name, H5P_DEFAULT)) < 0)
return -1;
/* Create the data space for the attribute. */
if ( (sid = H5Screate_simple( 1, &dim_size, NULL )) < 0 )
goto out;
/* Verify if the attribute already exists */
has_attr = H5LT_find_attribute(obj_id, attr_name);
/* The attribute already exists, delete it */
if(has_attr == 1)
if(H5Adelete(obj_id, attr_name) < 0)
goto out;
/* Create the attribute. */
if((attr_id = H5Acreate2(obj_id, attr_name, tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto out;
/* Write the attribute data. */
if(H5Awrite(attr_id, tid, data) < 0)
goto out;
/* Close the attribute. */
if(H5Aclose(attr_id) < 0)
goto out;
/* Close the dataspace. */
if(H5Sclose(sid) < 0)
goto out;
/* Close the object */
if(H5Oclose(obj_id) < 0)
return -1;
return 0;
out:
H5Oclose(obj_id);
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_char
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 7, 2001
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_char( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const char *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_CHAR, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_uchar
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_uchar( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const unsigned char *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_UCHAR, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_short
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 7, 2001
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_short( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const short *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_SHORT, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_ushort
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_ushort( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const unsigned short *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_USHORT, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_int
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 7, 2001
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_int( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const int *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_INT, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_uint
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_uint( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const unsigned int *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_UINT, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_long
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 7, 2001
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_long( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const long *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_LONG, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_long_long
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Elena Pourmal, epourmal@ncsa.uiuc.edu
*
* Date: June 17, 2005
*
* Comments: This function was added to support attributes of type long long
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_long_long( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const long long *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_LLONG, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_ulong
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_ulong( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const unsigned long *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_ULONG, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_float
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: July 25, 2001
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_float( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const float *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_FLOAT, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTset_attribute_double
*
* Purpose: Create and write an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: November 7, 2001
*
* Comments:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTset_attribute_double( hid_t loc_id,
const char *obj_name,
const char *attr_name,
const double *data,
size_t size )
{
if ( H5LT_set_attribute_numerical( loc_id, obj_name, attr_name, size,
H5T_NATIVE_DOUBLE, data ) < 0 )
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: find_attr
*
* Purpose: operator function used by H5LT_find_attribute
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: June 21, 2001
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
find_attr(hid_t loc_id, const char *name, const H5A_info_t *ainfo,
void *op_data)
{
int ret = H5_ITER_CONT;
/* Shut compiler up */
loc_id = loc_id; ainfo = ainfo;
/* Define a positive value for return value if the attribute was found. This will
* cause the iterator to immediately return that positive value,
* indicating short-circuit success
*/
if(strcmp(name, (char *)op_data) == 0)
ret = H5_ITER_STOP;
return ret;
}
/*-------------------------------------------------------------------------
* Function: H5LTfind_attribute
*
* Purpose: Inquires if an attribute named attr_name exists attached to
* the object loc_id.
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: May 17, 2006
*
* Comments:
* Calls the private version of the function
*
*-------------------------------------------------------------------------
*/
herr_t H5LTfind_attribute( hid_t loc_id, const char* attr_name )
{
return H5LT_find_attribute(loc_id,attr_name);
}
/*-------------------------------------------------------------------------
* Function: H5LT_find_attribute
*
* Purpose: Inquires if an attribute named attr_name exists attached to the object loc_id.
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: June 21, 2001
*
* Comments:
* The function uses H5Aiterate2 with the operator function find_attr
*
* Return:
* Success: The return value of the first operator that
* returns non-zero, or zero if all members were
* processed with no operator returning non-zero.
*
* Failure: Negative if something goes wrong within the
* library, or the negative value returned by one
* of the operators.
*
*-------------------------------------------------------------------------
*/
herr_t
H5LT_find_attribute( hid_t loc_id, const char* attr_name )
{
return H5Aiterate2(loc_id, H5_INDEX_NAME, H5_ITER_INC, NULL, find_attr, (void *)attr_name);
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_ndims
*
* Purpose: Gets the dimensionality of an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 4, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_ndims( hid_t loc_id,
const char *obj_name,
const char *attr_name,
int *rank )
{
hid_t attr_id;
hid_t sid;
hid_t obj_id;
/* Open the object */
if((obj_id = H5Oopen(loc_id, obj_name, H5P_DEFAULT)) < 0)
return -1;
/* Open the attribute. */
if((attr_id = H5Aopen(obj_id, attr_name, H5P_DEFAULT)) < 0)
{
H5Oclose(obj_id);
return -1;
}
/* Get the dataspace handle */
if((sid = H5Aget_space(attr_id)) < 0)
goto out;
/* Get rank */
if((*rank = H5Sget_simple_extent_ndims(sid)) < 0)
goto out;
/* Terminate access to the attribute */
if ( H5Sclose( sid ) < 0 )
goto out;
/* End access to the attribute */
if ( H5Aclose( attr_id ) )
goto out;;
/* Close the object */
if(H5Oclose(obj_id) < 0 )
return -1;
return 0;
out:
H5Aclose( attr_id );
H5Oclose(obj_id);
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_info
*
* Purpose: Gets information about an attribute.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 4, 2001
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_info( hid_t loc_id,
const char *obj_name,
const char *attr_name,
hsize_t *dims,
H5T_class_t *type_class,
size_t *type_size )
{
hid_t attr_id;
hid_t tid;
hid_t sid;
hid_t obj_id;
/* Open the object */
if((obj_id = H5Oopen(loc_id, obj_name, H5P_DEFAULT)) < 0)
return -1;
/* Open the attribute. */
if((attr_id = H5Aopen(obj_id, attr_name, H5P_DEFAULT)) < 0)
{
H5Oclose(obj_id);
return -1;
}
/* Get an identifier for the datatype. */
tid = H5Aget_type(attr_id);
/* Get the class. */
*type_class = H5Tget_class(tid);
/* Get the size. */
*type_size = H5Tget_size( tid );
/* Get the dataspace handle */
if ( (sid = H5Aget_space( attr_id )) < 0 )
goto out;
/* Get dimensions */
if ( H5Sget_simple_extent_dims( sid, dims, NULL) < 0 )
goto out;
/* Terminate access to the dataspace */
if ( H5Sclose( sid ) < 0 )
goto out;
/* Release the datatype. */
if ( H5Tclose( tid ) )
goto out;
/* End access to the attribute */
if ( H5Aclose( attr_id ) )
goto out;
/* Close the object */
if(H5Oclose(obj_id) < 0 )
return -1;
return 0;
out:
H5Tclose(tid);
H5Aclose(attr_id);
H5Oclose(obj_id);
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LTtext_to_dtype
*
* Purpose: Convert DDL description to HDF5 data type.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Raymond Lu, slu@ncsa.uiuc.edu
*
* Date: October 6, 2004
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
hid_t H5LTtext_to_dtype(const char *text, H5LT_lang_t lang_type)
{
extern int H5LTyyparse(void);
hid_t type_id;
if(lang_type <= H5LT_LANG_ERR || lang_type >= H5LT_NO_LANG)
goto out;
if(lang_type != H5LT_DDL) {
fprintf(stderr, "only DDL is supported for now.\n");
goto out;
}
input_len = strlen(text);
myinput = strdup(text);
if((type_id = H5LTyyparse()) < 0)
goto out;
free(myinput);
input_len = 0;
return type_id;
out:
return -1;
}
/*-------------------------------------------------------------------------
* Function: realloc_and_append
*
* Purpose: Expand the buffer and append a string to it.
*
* Return: void
*
* Programmer: Raymond Lu, songyulu@hdfgroup.org
*
* Date: 29 September 2011
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char*
realloc_and_append(hbool_t _no_user_buf, size_t *len, char *buf, char *str_to_add)
{
if(_no_user_buf) {
/* If the buffer isn't big enough, reallocate it. Otherwise, go to do strcat. */
if(str_to_add && ((ssize_t)(*len - (strlen(buf) + strlen(str_to_add) + 1)) < LIMIT)) {
*len += ((strlen(buf) + strlen(str_to_add) + 1) / INCREMENT + 1) * INCREMENT;
buf = (char*)realloc(buf, *len);
} else if(!str_to_add && ((ssize_t)(*len - strlen(buf) - 1) < LIMIT)) {
*len += INCREMENT;
buf = (char*)realloc(buf, *len);
}
}
if(!buf)
goto out;
if(str_to_add)
strcat(buf, str_to_add);
return buf;
out:
return NULL;
}
/*-------------------------------------------------------------------------
* Function: indentation
*
* Purpose: Print spaces for indentation
*
* Return: void
*
* Programmer: Raymond Lu, slu@ncsa.uiuc.edu
*
* Date: December 6, 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char*
indentation(size_t x, char* str, hbool_t no_u_buf, size_t *s_len)
{
char tmp_str[TMP_LEN];
if (x < 80) {
memset(tmp_str, ' ', x);
tmp_str[x]='\0';
} else
HDsnprintf(tmp_str, TMP_LEN, "error: the indentation exceeds the number of cols.");
if(!(str = realloc_and_append(no_u_buf, s_len, str, tmp_str)))
goto out;
return str;
out:
return NULL;
}
/*-------------------------------------------------------------------------
* Function: print_enum
*
* Purpose: prints the enum data
*
* Return: Success: 0, Failure: -1
*
* Programmer: Raymond Lu
*
* Modifications:
*
*-----------------------------------------------------------------------*/
static char*
print_enum(hid_t type, char* str, size_t *str_len, hbool_t no_ubuf, size_t indt)
{
char **name = NULL; /*member names */
unsigned char *value = NULL; /*value array */
unsigned char *copy = NULL; /*a pointer to value array */
int nmembs; /*number of members */
char tmp_str[TMP_LEN];
int nchars; /*number of output characters */
hid_t super = -1; /*enum base integer type */
hid_t native = -1; /*native integer data type */
size_t super_size; /*enum base type size */
size_t dst_size; /*destination value type size */
int i;
if((nmembs = H5Tget_nmembers(type))==0)
goto out;
assert(nmembs>0);
if((super = H5Tget_super(type)) < 0)
goto out;
/* Use buffer of INT or UNSIGNED INT to print enum values because
* we don't expect these values to be so big that INT or UNSIGNED
* INT can't hold.
*/
if (H5T_SGN_NONE == H5Tget_sign(super)) {
native = H5T_NATIVE_UINT;
} else {
native = H5T_NATIVE_INT;
}
super_size = H5Tget_size(super);
dst_size = H5Tget_size(native);
/* Get the names and raw values of all members */
name = (char**)calloc((size_t)nmembs, sizeof(char *));
value = (unsigned char*)calloc((size_t)nmembs, MAX(dst_size, super_size));
for (i = 0; i < nmembs; i++) {
if((name[i] = H5Tget_member_name(type, (unsigned)i))==NULL)
goto out;
if(H5Tget_member_value(type, (unsigned)i, value + i * super_size) < 0)
goto out;
}
/* Convert values to native data type */
if (native > 0) {
if(H5Tconvert(super, native, (size_t)nmembs, value, NULL, H5P_DEFAULT) < 0)
goto out;
}
/*
* Sort members by increasing value
* ***not implemented yet***
*/
/* Print members */
for (i = 0; i < nmembs; i++) {
if(!(str = indentation(indt + COL, str, no_ubuf, str_len)))
goto out;
nchars = HDsnprintf(tmp_str, TMP_LEN, "\"%s\"", name[i]);
if(!(str = realloc_and_append(no_ubuf, str_len, str, tmp_str)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "%*s ", MAX(0, 16 - nchars), "");
if(!(str = realloc_and_append(no_ubuf, str_len, str, tmp_str)))
goto out;
/*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size"
*strangely, unless use another pointer "copy".*/
copy = value+i*dst_size;
if (H5T_SGN_NONE == H5Tget_sign(native))
HDsnprintf(tmp_str, TMP_LEN, "%u", *((unsigned int*)((void *)copy)));
else
HDsnprintf(tmp_str, TMP_LEN, "%d", *((int*)((void *)copy)));
if(!(str = realloc_and_append(no_ubuf, str_len, str, tmp_str)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, ";\n");
if(!(str = realloc_and_append(no_ubuf, str_len, str, tmp_str)))
goto out;
}
/* Release resources */
for(i = 0; i < nmembs; i++)
free(name[i]);
free(name);
free(value);
H5Tclose(super);
return str;
out:
if(0 == nmembs) {
HDsnprintf(tmp_str, TMP_LEN, "\n%*s <empty>", indt + 4, "");
str = realloc_and_append(no_ubuf, str_len, str, tmp_str);
} /* end if */
/* Release resources */
if(name) {
for(i = 0; i < nmembs; i++)
if(name[i])
free(name[i]);
free(name);
} /* end if */
if(value)
free(value);
if(super >= 0)
H5Tclose(super);
return NULL;
}
/*-------------------------------------------------------------------------
* Function: H5LTdtype_to_text
*
* Purpose: Convert HDF5 data type to DDL description.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Raymond Lu, slu@ncsa.uiuc.edu
*
* Date: December 6, 2005
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTdtype_to_text(hid_t dtype, char *str, H5LT_lang_t lang_type, size_t *len)
{
size_t str_len = INCREMENT;
char *text_str;
herr_t ret = SUCCEED;
if(lang_type <= H5LT_LANG_ERR || lang_type >= H5LT_NO_LANG)
goto out;
if(len && !str) {
text_str = (char*)calloc(str_len, sizeof(char));
text_str[0]='\0';
if(!(text_str = H5LT_dtype_to_text(dtype, text_str, lang_type, &str_len, 1)))
goto out;
*len = strlen(text_str) + 1;
if(text_str)
free(text_str);
text_str = NULL;
} else if(len && str) {
if(!(H5LT_dtype_to_text(dtype, str, lang_type, len, 0)))
goto out;
str[*len-1] = '\0';
}
return ret;
out:
return FAIL;
}
/*-------------------------------------------------------------------------
* Function: H5LT_dtype_to_text
*
* Purpose: Private function to convert HDF5 data type to DDL description.
*
* Return: Success: 0, Failure: -1
*
* Programmer: Raymond Lu, slu@ncsa.uiuc.edu
*
* Date: December 20, 2005
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
char* H5LT_dtype_to_text(hid_t dtype, char *dt_str, H5LT_lang_t lang, size_t *slen,
hbool_t no_user_buf)
{
H5T_class_t tcls;
char tmp_str[TMP_LEN];
int i;
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, NULL)))
goto out;
if(lang != H5LT_DDL) {
HDsnprintf(dt_str, *slen, "only DDL is supported for now");
goto out;
}
if((tcls = H5Tget_class(dtype)) < 0)
goto out;
switch (tcls) {
case H5T_INTEGER:
if (H5Tequal(dtype, H5T_STD_I8BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I8BE");
} else if (H5Tequal(dtype, H5T_STD_I8LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I8LE");
} else if (H5Tequal(dtype, H5T_STD_I16BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I16BE");
} else if (H5Tequal(dtype, H5T_STD_I16LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I16LE");
} else if (H5Tequal(dtype, H5T_STD_I32BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I32BE");
} else if (H5Tequal(dtype, H5T_STD_I32LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I32LE");
} else if (H5Tequal(dtype, H5T_STD_I64BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I64BE");
} else if (H5Tequal(dtype, H5T_STD_I64LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_I64LE");
} else if (H5Tequal(dtype, H5T_STD_U8BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U8BE");
} else if (H5Tequal(dtype, H5T_STD_U8LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U8LE");
} else if (H5Tequal(dtype, H5T_STD_U16BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U16BE");
} else if (H5Tequal(dtype, H5T_STD_U16LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U16LE");
} else if (H5Tequal(dtype, H5T_STD_U32BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U32BE");
} else if (H5Tequal(dtype, H5T_STD_U32LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U32LE");
} else if (H5Tequal(dtype, H5T_STD_U64BE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U64BE");
} else if (H5Tequal(dtype, H5T_STD_U64LE)) {
HDsnprintf(dt_str, *slen, "H5T_STD_U64LE");
} else if (H5Tequal(dtype, H5T_NATIVE_SCHAR)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_SCHAR");
} else if (H5Tequal(dtype, H5T_NATIVE_UCHAR)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_UCHAR");
} else if (H5Tequal(dtype, H5T_NATIVE_SHORT)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_SHORT");
} else if (H5Tequal(dtype, H5T_NATIVE_USHORT)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_USHORT");
} else if (H5Tequal(dtype, H5T_NATIVE_INT)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_INT");
} else if (H5Tequal(dtype, H5T_NATIVE_UINT)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_UINT");
} else if (H5Tequal(dtype, H5T_NATIVE_LONG)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_LONG");
} else if (H5Tequal(dtype, H5T_NATIVE_ULONG)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_ULONG");
} else if (H5Tequal(dtype, H5T_NATIVE_LLONG)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_LLONG");
} else if (H5Tequal(dtype, H5T_NATIVE_ULLONG)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_ULLONG");
} else {
HDsnprintf(dt_str, *slen, "undefined integer");
}
break;
case H5T_FLOAT:
if (H5Tequal(dtype, H5T_IEEE_F32BE)) {
HDsnprintf(dt_str, *slen, "H5T_IEEE_F32BE");
} else if (H5Tequal(dtype, H5T_IEEE_F32LE)) {
HDsnprintf(dt_str, *slen, "H5T_IEEE_F32LE");
} else if (H5Tequal(dtype, H5T_IEEE_F64BE)) {
HDsnprintf(dt_str, *slen, "H5T_IEEE_F64BE");
} else if (H5Tequal(dtype, H5T_IEEE_F64LE)) {
HDsnprintf(dt_str, *slen, "H5T_IEEE_F64LE");
} else if (H5Tequal(dtype, H5T_NATIVE_FLOAT)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_FLOAT");
} else if (H5Tequal(dtype, H5T_NATIVE_DOUBLE)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_DOUBLE");
#if H5_SIZEOF_LONG_DOUBLE !=0
} else if (H5Tequal(dtype, H5T_NATIVE_LDOUBLE)) {
HDsnprintf(dt_str, *slen, "H5T_NATIVE_LDOUBLE");
#endif
} else {
HDsnprintf(dt_str, *slen, "undefined float");
}
break;
case H5T_STRING:
{
/* Make a copy of type in memory in case when DTYPE is on disk, the size
* will be bigger than in memory. This makes it easier to compare
* types in memory. */
hid_t str_type;
H5T_order_t order;
hid_t tmp_type;
size_t size;
H5T_str_t str_pad;
H5T_cset_t cset;
htri_t is_vlstr;
if((tmp_type = H5Tcopy(dtype)) < 0)
goto out;
if((size = H5Tget_size(tmp_type))==0)
goto out;
if((str_pad = H5Tget_strpad(tmp_type)) < 0)
goto out;
if((cset = H5Tget_cset(tmp_type)) < 0)
goto out;
if((is_vlstr = H5Tis_variable_str(tmp_type)) < 0)
goto out;
/* Print lead-in */
HDsnprintf(dt_str, *slen, "H5T_STRING {\n");
indent += COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
if(is_vlstr)
HDsnprintf(tmp_str, TMP_LEN, "STRSIZE H5T_VARIABLE;\n");
else
HDsnprintf(tmp_str, TMP_LEN, "STRSIZE %d;\n", (int)size);
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
if (str_pad == H5T_STR_NULLTERM)
HDsnprintf(tmp_str, TMP_LEN, "STRPAD H5T_STR_NULLTERM;\n");
else if (str_pad == H5T_STR_NULLPAD)
HDsnprintf(tmp_str, TMP_LEN, "STRPAD H5T_STR_NULLPAD;\n");
else if (str_pad == H5T_STR_SPACEPAD)
HDsnprintf(tmp_str, TMP_LEN, "STRPAD H5T_STR_SPACEPAD;\n");
else
HDsnprintf(tmp_str, TMP_LEN, "STRPAD H5T_STR_ERROR;\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
if (cset == H5T_CSET_ASCII)
HDsnprintf(tmp_str, TMP_LEN, "CSET H5T_CSET_ASCII;\n");
else if (cset == H5T_CSET_UTF8)
HDsnprintf(tmp_str, TMP_LEN, "CSET H5T_CSET_UTF8;\n");
else
HDsnprintf(tmp_str, TMP_LEN, "CSET unknown;\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
/* Reproduce a C type string */
if((str_type = H5Tcopy(H5T_C_S1)) < 0)
goto out;
if(is_vlstr) {
if(H5Tset_size(str_type, H5T_VARIABLE) < 0)
goto out;
} else {
if(H5Tset_size(str_type, size) < 0)
goto out;
}
if(H5Tset_cset(str_type, cset) < 0)
goto out;
if(H5Tset_strpad(str_type, str_pad) < 0)
goto out;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
/* Check C variable-length string first. Are the two types equal? */
if (H5Tequal(tmp_type, str_type)) {
HDsnprintf(tmp_str, TMP_LEN, "CTYPE H5T_C_S1;\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
goto next;
}
/* Change the endianness and see if they're equal. */
if((order = H5Tget_order(tmp_type)) < 0)
goto out;
if(order==H5T_ORDER_LE) {
if(H5Tset_order(str_type, H5T_ORDER_LE) < 0)
goto out;
} else if(order==H5T_ORDER_BE) {
if(H5Tset_order(str_type, H5T_ORDER_BE) < 0)
goto out;
}
if (H5Tequal(tmp_type, str_type)) {
HDsnprintf(tmp_str, TMP_LEN, "CTYPE H5T_C_S1;\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
goto next;
}
/* If not equal to C variable-length string, check Fortran type.
* Actually H5Tequal can't tell difference between H5T_C_S1 and H5T_FORTRAN_S1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
if(H5Tclose(str_type) < 0)
goto out;
if((str_type = H5Tcopy(H5T_FORTRAN_S1)) < 0)
goto out;
if(H5Tset_cset(str_type, cset) < 0)
goto out;
if(H5Tset_size(str_type, size) < 0)
goto out;
if(H5Tset_strpad(str_type, str_pad) < 0)
goto out;
/* Are the two types equal? */
if (H5Tequal(tmp_type, str_type)) {
HDsnprintf(tmp_str, TMP_LEN, "CTYPE H5T_FORTRAN_S1;\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
goto next;
}
/* Change the endianness and see if they're equal. */
if((order = H5Tget_order(tmp_type)) < 0)
goto out;
if(order==H5T_ORDER_LE) {
if(H5Tset_order(str_type, H5T_ORDER_LE) < 0)
goto out;
} else if(order==H5T_ORDER_BE) {
if(H5Tset_order(str_type, H5T_ORDER_BE) < 0)
goto out;
}
/* Are the two types equal? */
if (H5Tequal(tmp_type, str_type)) {
HDsnprintf(tmp_str, TMP_LEN, "CTYPE H5T_FORTRAN_S1;\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
goto next;
}
/* Type doesn't match any of above. */
HDsnprintf(tmp_str, TMP_LEN, "CTYPE unknown_one_character_type;\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
next:
H5Tclose(str_type);
H5Tclose(tmp_type);
/* Print closing */
indent -= COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "}");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
break;
}
case H5T_OPAQUE:
{
char *tag = NULL;
/* Print lead-in */
HDsnprintf(dt_str, *slen, "H5T_OPAQUE {\n");
indent += COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "OPQ_SIZE %lu;\n", (unsigned long)H5Tget_size(dtype));
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
tag = H5Tget_tag(dtype);
if(tag) {
HDsnprintf(tmp_str, TMP_LEN, "OPQ_TAG \"%s\";\n", tag);
if(tag)
free(tag);
tag = NULL;
} else
HDsnprintf(tmp_str, TMP_LEN, "OPQ_TAG \"\";\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
/* Print closing */
indent -= COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "}");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
break;
}
case H5T_ENUM:
{
hid_t super;
size_t super_len;
char* stmp = NULL;
/* Print lead-in */
HDsnprintf(dt_str, *slen, "H5T_ENUM {\n");
indent += COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
if((super = H5Tget_super(dtype)) < 0)
goto out;
if(H5LTdtype_to_text(super, NULL, lang, &super_len) < 0)
goto out;
stmp = (char*)calloc(super_len, sizeof(char));
if(H5LTdtype_to_text(super, stmp, lang, &super_len) < 0)
goto out;
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, stmp)))
goto out;
if(stmp)
free(stmp);
stmp = NULL;
HDsnprintf(tmp_str, TMP_LEN, ";\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
H5Tclose(super);
if(!(dt_str = print_enum(dtype, dt_str, slen, no_user_buf, indent)))
goto out;
/* Print closing */
indent -= COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "}");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
break;
}
case H5T_VLEN:
{
hid_t super;
size_t super_len;
char* stmp = NULL;
/* Print lead-in */
HDsnprintf(dt_str, *slen, "H5T_VLEN {\n");
indent += COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
if((super = H5Tget_super(dtype)) < 0)
goto out;
if(H5LTdtype_to_text(super, NULL, lang, &super_len) < 0)
goto out;
stmp = (char*)calloc(super_len, sizeof(char));
if(H5LTdtype_to_text(super, stmp, lang, &super_len) < 0)
goto out;
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, stmp)))
goto out;
if(stmp)
free(stmp);
stmp = NULL;
HDsnprintf(tmp_str, TMP_LEN, "\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
H5Tclose(super);
/* Print closing */
indent -= COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "}");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
break;
}
case H5T_ARRAY:
{
hid_t super;
size_t super_len;
char* stmp = NULL;
hsize_t dims[H5S_MAX_RANK];
int ndims;
/* Print lead-in */
HDsnprintf(dt_str, *slen, "H5T_ARRAY {\n");
indent += COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
/* Get array information */
if((ndims = H5Tget_array_ndims(dtype)) < 0)
goto out;
if(H5Tget_array_dims2(dtype, dims) < 0)
goto out;
/* Print array dimensions */
for (i = 0; i < ndims; i++) {
HDsnprintf(tmp_str, TMP_LEN, "[%d]", (int) dims[i]);
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
}
HDsnprintf(tmp_str, TMP_LEN, " ");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
if((super = H5Tget_super(dtype)) < 0)
goto out;
if(H5LTdtype_to_text(super, NULL, lang, &super_len) < 0)
goto out;
stmp = (char*)calloc(super_len, sizeof(char));
if(H5LTdtype_to_text(super, stmp, lang, &super_len) < 0)
goto out;
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, stmp)))
goto out;
if(stmp)
free(stmp);
stmp = NULL;
HDsnprintf(tmp_str, TMP_LEN, "\n");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
H5Tclose(super);
/* Print closing */
indent -= COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "}");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
break;
}
case H5T_COMPOUND:
{
char *mname = NULL;
hid_t mtype;
size_t moffset;
H5T_class_t mclass;
size_t mlen;
char* mtmp = NULL;
int nmembs;
if((nmembs = H5Tget_nmembers(dtype)) < 0)
goto out;
HDsnprintf(dt_str, *slen, "H5T_COMPOUND {\n");
indent += COL;
for (i = 0; i < nmembs; i++) {
if((mname = H5Tget_member_name(dtype, (unsigned)i))==NULL)
goto out;
if((mtype = H5Tget_member_type(dtype, (unsigned)i)) < 0)
goto out;
moffset = H5Tget_member_offset(dtype, (unsigned)i);
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
if((mclass = H5Tget_class(mtype)) < 0)
goto out;
if (H5T_COMPOUND == mclass)
indent += COL;
if(H5LTdtype_to_text(mtype, NULL, lang, &mlen) < 0)
goto out;
mtmp = (char*)calloc(mlen, sizeof(char));
if(H5LTdtype_to_text(mtype, mtmp, lang, &mlen) < 0)
goto out;
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, mtmp)))
goto out;
if(mtmp)
free(mtmp);
mtmp = NULL;
if (H5T_COMPOUND == mclass)
indent -= COL;
HDsnprintf(tmp_str, TMP_LEN, " \"%s\"", mname);
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
if(mname)
free(mname);
mname = NULL;
HDsnprintf(tmp_str, TMP_LEN, " : %lu;\n", (unsigned long)moffset);
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
}
/* Print closing */
indent -= COL;
if(!(dt_str = indentation(indent + COL, dt_str, no_user_buf, slen)))
goto out;
HDsnprintf(tmp_str, TMP_LEN, "}");
if(!(dt_str = realloc_and_append(no_user_buf, slen, dt_str, tmp_str)))
goto out;
break;
}
case H5T_TIME:
HDsnprintf(dt_str, *slen, "H5T_TIME: not yet implemented");
break;
case H5T_BITFIELD:
HDsnprintf(dt_str, *slen, "H5T_BITFIELD: not yet implemented");
break;
default:
HDsnprintf(dt_str, *slen, "unknown data type");
}
return dt_str;
out:
return NULL;
}
/*-------------------------------------------------------------------------
*
* Get attribute functions
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_string
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_string( hid_t loc_id,
const char *obj_name,
const char *attr_name,
char *data )
{
/* identifiers */
hid_t obj_id;
/* Open the object */
if ((obj_id = H5Oopen( loc_id, obj_name, H5P_DEFAULT)) < 0)
return -1;
/* Get the attribute */
if ( H5LT_get_attribute_disk( obj_id, attr_name, data ) < 0 )
return -1;
/* Close the object */
if(H5Oclose(obj_id) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_char
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_char( hid_t loc_id,
const char *obj_name,
const char *attr_name,
char *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_CHAR, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_uchar
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_uchar( hid_t loc_id,
const char *obj_name,
const char *attr_name,
unsigned char *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_UCHAR, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_short
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_short( hid_t loc_id,
const char *obj_name,
const char *attr_name,
short *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_SHORT, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_ushort
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_ushort( hid_t loc_id,
const char *obj_name,
const char *attr_name,
unsigned short *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_USHORT, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_int
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_int( hid_t loc_id,
const char *obj_name,
const char *attr_name,
int *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_INT, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_uint
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_uint( hid_t loc_id,
const char *obj_name,
const char *attr_name,
unsigned int *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_UINT, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_long
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_long( hid_t loc_id,
const char *obj_name,
const char *attr_name,
long *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_LONG, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_long_long
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Elena Pourmal, epourmal@ncsa.uiuc.edu
*
* Date: June 17, 2005
*
* Comments: This funstion was added to suuport INTEGER*8 Fortran types
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_long_long( hid_t loc_id,
const char *obj_name,
const char *attr_name,
long long *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_LLONG, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_ulong
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 8, 2004
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_ulong( hid_t loc_id,
const char *obj_name,
const char *attr_name,
unsigned long *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_ULONG, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_float
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_float( hid_t loc_id,
const char *obj_name,
const char *attr_name,
float *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_FLOAT, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute_double
*
* Purpose: Reads an attribute named attr_name
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute_double( hid_t loc_id,
const char *obj_name,
const char *attr_name,
double *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, H5T_NATIVE_DOUBLE, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* Function: H5LTget_attribute
*
* Purpose: Reads an attribute named attr_name with the memory type mem_type_id
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments: Private function
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LTget_attribute( hid_t loc_id,
const char *obj_name,
const char *attr_name,
hid_t mem_type_id,
void *data )
{
/* Get the attribute */
if(H5LT_get_attribute_mem(loc_id, obj_name, attr_name, mem_type_id, data) < 0)
return -1;
return 0;
}
/*-------------------------------------------------------------------------
* private functions
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* Function: H5LT_get_attribute_mem
*
* Purpose: Reads an attribute named attr_name with the memory type mem_type_id
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments: Private function
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t H5LT_get_attribute_mem(hid_t loc_id,
const char *obj_name,
const char *attr_name,
hid_t mem_type_id,
void *data)
{
/* identifiers */
hid_t obj_id = -1;
hid_t attr_id = -1;
/* Open the object */
if((obj_id = H5Oopen(loc_id, obj_name, H5P_DEFAULT)) < 0)
goto out;
if((attr_id = H5Aopen(obj_id, attr_name, H5P_DEFAULT)) < 0)
goto out;
if(H5Aread(attr_id, mem_type_id, data) < 0)
goto out;
if(H5Aclose(attr_id) < 0)
goto out;
attr_id = -1;
/* Close the object */
if(H5Oclose(obj_id) < 0)
goto out;
obj_id = -1;
return 0;
out:
if(attr_id > 0)
H5Aclose(attr_id);
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LT_get_attribute_disk
*
* Purpose: Reads an attribute named attr_name with the datatype stored on disk
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: September 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LT_get_attribute_disk( hid_t loc_id,
const char *attr_name,
void *attr_out )
{
/* identifiers */
hid_t attr_id;
hid_t attr_type;
if(( attr_id = H5Aopen(loc_id, attr_name, H5P_DEFAULT)) < 0)
return -1;
if((attr_type = H5Aget_type(attr_id)) < 0)
goto out;
if(H5Aread(attr_id, attr_type, attr_out) < 0)
goto out;
if(H5Tclose(attr_type) < 0)
goto out;
if ( H5Aclose( attr_id ) < 0 )
return -1;;
return 0;
out:
H5Tclose( attr_type );
H5Aclose( attr_id );
return -1;
}
/*-------------------------------------------------------------------------
* Function: H5LT_set_attribute_string
*
* Purpose: creates and writes an attribute named NAME to the dataset DSET_ID
*
* Return: FAIL on error, SUCCESS on success
*
* Programmer: pvn@ncsa.uiuc.edu
*
* Date: January 04, 2005
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t H5LT_set_attribute_string(hid_t dset_id,
const char *name,
const char *buf )
{
hid_t tid;
hid_t sid = -1;
hid_t aid = -1;
int has_attr;
size_t size;
/* verify if the attribute already exists */
has_attr = H5LT_find_attribute(dset_id,name);
/* the attribute already exists, delete it */
if(has_attr == 1)
if(H5Adelete(dset_id, name) < 0)
return FAIL;
/*-------------------------------------------------------------------------
* create the attribute type
*-------------------------------------------------------------------------
*/
if((tid = H5Tcopy(H5T_C_S1)) < 0)
return FAIL;
size = strlen(buf) + 1; /* extra null term */
if(H5Tset_size(tid,(size_t)size) < 0)
goto out;
if(H5Tset_strpad(tid, H5T_STR_NULLTERM) < 0)
goto out;
if((sid = H5Screate(H5S_SCALAR)) < 0)
goto out;
/*-------------------------------------------------------------------------
* create and write the attribute
*-------------------------------------------------------------------------
*/
if((aid = H5Acreate2(dset_id, name, tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto out;
if(H5Awrite(aid, tid, buf) < 0)
goto out;
if(H5Aclose(aid) < 0)
goto out;
if(H5Sclose(sid) < 0)
goto out;
if(H5Tclose(tid) < 0)
goto out;
return SUCCEED;
/* error zone */
out:
H5E_BEGIN_TRY {
H5Aclose(aid);
H5Tclose(tid);
H5Sclose(sid);
} H5E_END_TRY;
return FAIL;
}