F5A.h File Reference

#include "hdf5inc.h"
#include "F5WinDLLApi.h"

Go to the source code of this file.

Macros
#define	__F5_F5A_H   "Attribute Functions"

Functions
F5_API hid_t	F5Aappend (hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_plist)
F5_API hid_t	F5Atry_to_open (hid_t location, const char *name)
F5_API hid_t	F5Aopen_name (hid_t location, const char *name)
F5_API int	F5Asave_string (hid_t loc_id, const char *name, const char *buf)
F5_API int	F5Asave_strings (hid_t loc_id, const char *name, const char *buf, int HowMany)
F5_API char *	F5Aget_string (hid_t loc_id, const char *name, char *buf, size_t len)
F5_API hid_t	F5Aget_type (hid_t loc_id, const char *name, hid_t *attrib)
F5_API herr_t	F5Asave_version (hid_t loc_id, int major, int minor, int release)
F5_API herr_t	F5Aget_version (hid_t loc_id, int *major, int *minor, int *release)
F5_API long	F5Aget_ints (hid_t loc_id, const char *name, int *data, hsize_t n)
F5_API int	F5Asave_ints (hid_t loc_id, const char *name, const int data[], hsize_t n)
F5_API int	F5Astore_integer (hid_t loc_id, const char *name, int data)
F5_API int	F5Awrite_integer (hid_t loc_id, const char *name, int data)
F5_API int	F5Asave (hid_t loc_id, const char *name, hid_t file_type_id, hid_t mem_type_id, const void *data, hsize_t n)

Macro Definition Documentation

__F5_F5A_H

#define __F5_F5A_H   "Attribute Functions"

Definition at line 2 of file F5A.h.

Function Documentation

F5Aappend()

F5_API hid_t F5Aappend	(	hid_t	loc_id,
		const char *	name,
		hid_t	type_id,
		hid_t	space_id,
		hid_t	create_plist )

Open some attribute if it exists, otherwise create one.

Definition at line 9 of file F5A.c.

{
hid_t   id;
 
        H5E_BEGIN_TRY
        id  = H5Acreate2(loc_id, name, type_id, space_id, create_plist, H5P_DEFAULT );
        H5E_END_TRY
 
        if (id<0)
                return F5Aopen_name(loc_id, name );
 
        return id;
}

References F5Aopen_name(), and name.

Referenced by F5Bappend_slice().

F5Aget_ints()

F5_API long F5Aget_ints	(	hid_t	loc_id,
		const char *	name,
		int *	data,
		hsize_t	n )

Get a number of integers from an attribute which is an integer array. The specified number n must match exactly with the number of elements.

Returns

positive number of elements (n) if success, 0 if attribute not found, and the negative number of elements otherwise. Success can easily be tested by checking the return value to be larger than zero.

Definition at line 406 of file F5A.c.

{
hsize_t elems;
hid_t   space_hid,
        attr_hid = F5Atry_to_open(loc_id, name);
 
        if (attr_hid<0)
                return 0;
 
        space_hid = H5Aget_space(attr_hid);
 
        assert( space_hid > 0);
        /*
          Could be more generous here... currently must match exactly.
         */
        elems = H5Sget_simple_extent_npoints(space_hid);
        if (elems != n)
        {
                H5Sclose(space_hid);
                H5Aclose(attr_hid);
                return -elems;
        }
 
        F_H5Aread(attr_hid, H5T_NATIVE_INT, data, name);
        H5Aclose(attr_hid);
        H5Sclose(space_hid);
 
        return elems;
}

References F5Atry_to_open(), F_H5Aread(), and name.

Referenced by F5Asave_ints(), F5LTexpand_dataspace(), F5LTget_index_depth(), F5LTget_skeleton_dimensionality(), F5LTset_dataspace(), and F5Tget_index_depth().

F5Aget_string()

F5_API char * F5Aget_string	(	hid_t	loc_id,
		const char *	name,
		char *	buf,
		size_t	len )

Get a string attribute from the file. If buf is a NULL pointer, then the string is allocated dynamically and the caller needs to issue free() on the result. If the string could not be read, returns a NULL pointer.

Definition at line 109 of file F5A.c.

{
hid_t   space_hid;
hsize_t N;
hsize_t len;
 
hid_t   attr_type_hid;
hid_t   attr_hid = F5Atry_to_open(loc_id, name );
 
        if (attr_hid<0)
                return 0;
 
        F5printf(300, "F5Aget_string()");
 
        attr_type_hid = H5Aget_type(attr_hid);
 
        if (H5Tget_class(attr_type_hid) != H5T_STRING)
        {
                F5printf(1, "F5 Error: getAttribute(string): attribute `%s' is not of type string!\n", name);
                H5Tclose(attr_type_hid);
                H5Aclose(attr_hid);
        }
 
        space_hid = H5Aget_space(attr_hid);
        assert( space_hid > 0);
        N = H5Sget_simple_extent_npoints(space_hid);
 
        len = H5Tget_size(attr_type_hid);
 
        F5printf(100,"F5 String Attribute `%s': %ld strings of len %ld\n", name, (long)N, (long)len);
 
        if (!buf)
                buf = (char*)malloc(N*(len+1));
        else
        {
                if (len>buflen+1)
                {
                        H5Tclose(attr_type_hid);
                        H5Sclose(space_hid);
                        H5Aclose(attr_hid);
                        return NULL;
                }
        }
 
        if (F_H5Aread(attr_hid, attr_type_hid, buf, name ) < 0)
        {
                H5Tclose(attr_type_hid);
                H5Sclose(space_hid);
                H5Aclose(attr_hid);
                return NULL;
        }
        H5Sclose(space_hid);
        H5Tclose(attr_type_hid);
        H5Aclose(attr_hid);
        buf[N*len] = 0;
        return buf;
}

References F5Atry_to_open(), F5printf, F_H5Aread(), H5Tclose(), and name.

Referenced by F5B_read_chart_domain().

F5Aget_type()

F5_API hid_t F5Aget_type	(	hid_t	loc_id,
		const char *	name,
		hid_t *	attrib )

Get type of an attribute by name. After calling this function both, attribute and type must be closed, otherwise warnings will occur

Definition at line 167 of file F5A.c.

{
        if (!attrib)
        {
                F5printf(50, "-- F5Aget_type() hid_t attrib == NULL");
                return -1;
        }
 
        *attrib = F5Aopen_name(loc_id, name);
 
        if (*attrib < 0)
        {
                F5printf(50, "-- F5Aget_type() hid_t attrib < 0");
                return *attrib;
        }
 
        {
        hid_t   type = H5Aget_type(*attrib);
                if (type < 0)
                        F5printf(50, "-- F5Aget_type hid_t type < 0");
                return type;
        }
}

References F5_API, F5Aopen_name(), F5printf, and name.

Referenced by F5Fis_attribute_of_type(), and F5Fis_fragment_attribute_of_type().

F5Aget_version()

F5_API herr_t F5Aget_version	(	hid_t	loc_id,
		int *	major,
		int *	minor,
		int *	release )

Get version number for given object.

Parameters

loc_id

Any HDF5 object that may carry attributes.

Definition at line 304 of file F5A.c.

{
int     version_info[3];
hid_t   attr_hid;
hid_t   space_hid;
 
        if (major  ) *major   = 0;
        if (minor  ) *minor   = 0;
        if (release) *release = 0;
 
        if (loc_id<=0) return -1;
 
        attr_hid = F5Aopen_name(loc_id, FIBER_VERSION_ATTRIBUTE_NAME);
 
        if (attr_hid<=0)  return -1;
 
        space_hid = H5Aget_space(attr_hid);
 
        if (space_hid<=0)
        {
                H5Aclose(attr_hid);
                return -1;
        }
 
        assert( space_hid >0 );
        /*
          Could be more generous here...
         */
        if (H5Sget_simple_extent_npoints(space_hid) != 3)
        {
                if (major  ) *major   = 0;
                if (minor  ) *minor   = 0;
                if (release) *release = 0;
 
                H5Sclose(space_hid);
                H5Aclose(attr_hid);
                return -1;
        }
 
        F_H5Aread(attr_hid, H5T_NATIVE_INT, version_info, FIBER_VERSION_ATTRIBUTE_NAME);
        H5Aclose(attr_hid);
        H5Sclose(space_hid);
 
        if (major  ) *major   = version_info[0];
        if (minor  ) *minor   = version_info[1];
        if (release) *release = version_info[2];
 
        return 0;
}

References F5Aopen_name(), F_H5Aread(), and FIBER_VERSION_ATTRIBUTE_NAME.

Referenced by F5Tget_field_Array_enum(), and F5Tget_field_ProcArray_enum().

F5Asave()

F5_API int F5Asave	(	hid_t	loc_id,
		const char *	name,
		hid_t	file_type_id,
		hid_t	mem_type_id,
		const void *	data,
		hsize_t	n )

Definition at line 529 of file F5A.c.

{
hid_t   attr_hid;
        F5printf(50, "-- F5Asave(,name=%s,,n=%d)", name, n);
 
        {
        hid_t   space_hid = n==1? H5Screate(H5S_SCALAR) : H5Screate_simple(1, &n , &n);
                H5E_BEGIN_TRY
                attr_hid = H5Acreate2(loc_id, name, file_type_id, space_hid, H5P_DEFAULT, H5P_DEFAULT);
                H5E_END_TRY
 
                if (attr_hid<0)
                {
                        H5Sclose(space_hid);
                        return 0;
                }
 
                H5Awrite(attr_hid, mem_type_id, data);
                H5Aclose(attr_hid);
 
                H5Sclose(space_hid);
        }
        return 1;
}

References F5printf, and name.

Referenced by F5FwriteIMAGE().

F5Asave_ints()

F5_API int F5Asave_ints	(	hid_t	loc_id,
		const char *	name,
		const int	data[],
		hsize_t	n )

Save an array of integers as an attribute.

Returns

non-zero in case of error

Definition at line 355 of file F5A.c.

{
hid_t   attr_hid;
        F5printf(50, "-- F5Asave_ints(,name=%s,,n=%d)", name, n);
 
        {
        hid_t   space_hid = n==1? H5Screate(H5S_SCALAR) : H5Screate_simple(1, &n , &n);
                H5E_BEGIN_TRY
                attr_hid = H5Acreate2(loc_id, name, H5T_NATIVE_INT, space_hid, H5P_DEFAULT, H5P_DEFAULT);
                H5E_END_TRY
 
                if (attr_hid<0)
                {
                int     file_data[ 128 ];
                        H5Sclose(space_hid);
                        if (n>128)
                        {
                                F5printf(30, "F5Asave_ints(,%s,,%d) FAILED, comparison >128 unsupported.", name, (int)n);
                                return 0;
                        }
                        if (F5Aget_ints(loc_id, name, file_data, n)>0)
                        {
                        hsize_t i;
                                for(i=0; i<n; i++)
                                {
                                        if (file_data[i] != data[i])
                                        {
                                                if (n==1)
                                                        F5printf(10, "F5Asave_ints(,%s,,1) FAILED for storing attribute: current value %d; it already exists and has different value %d.",
                                                                 name, (int)data[0], (int)file_data[0]);
                                                else
                                                        F5printf(10, "F5Asave_ints(,%s,,%d) FAILED, attribute already exists and has different values.", name, (int)n);
                                                return 0;
                                        }
                                }
                                F5printf(50, "F5Asave_ints(,%s,,%d) attribute already exists and has same values, nothing changed.", name, (int)n);
                                return 1;
                        }
                        F5printf(10, "F5Asave_ints(,%s,,%d) FAILED because attribute could not be created.", name, (int)n);
                        H5Sclose(space_hid);
                        return 0;
                }
                H5Awrite(attr_hid, H5T_NATIVE_INT, data);
                H5Aclose(attr_hid);
 
                H5Sclose(space_hid);
        }
        return 1;
}

References F5Aget_ints(), F5printf, and name.

Referenced by F5B_save_global_chart(), F5file_type(), F5LTcreate_topology(), F5LwriteX(), and F5Tsave_tensor().

F5Asave_string()

F5_API int F5Asave_string	(	hid_t	loc_id,
		const char *	name,
		const char *	buf )

Create a string attribute which is of the size of the given string and write it to the file.

Definition at line 45 of file F5A.c.

{
        // delete attribute first to "overwrite" existing string attribute
        // if ( H5Lexists(loc_id, name, H5P_DEFAULT) )
        // {
        //      if ( !H5Adelete(loc_id, name) )
        //              return -1;
        // }
 
hid_t   type_id  = H5Tcopy(H5T_C_S1);
hid_t   space_id = H5Screate(H5S_SCALAR);
hid_t   attr_id;
        {
        size_t  size     = strlen(buf);
                H5Tset_size(type_id, size+1);
        }
        H5Tset_strpad(type_id, H5T_STR_NULLTERM);
 
        H5E_BEGIN_TRY
        attr_id = H5Acreate2(loc_id, name, type_id, space_id,  H5P_DEFAULT,  H5P_DEFAULT);
        H5E_END_TRY
 
        if (attr_id>0)
        {
                H5Awrite(attr_id, type_id, buf);
                H5Aclose(attr_id);
        }
 
        H5Sclose(space_id);
        H5Tclose(type_id);
 
        return 1;
}

References H5Tclose(), and name.

Referenced by F5FwriteIMAGE(), F5Tsave_F5field_enum(), F5Tsave_ProcArray_enum(), and F5Tsave_tensor().

F5Asave_strings()

F5_API int F5Asave_strings	(	hid_t	loc_id,
		const char *	name,
		const char *	buf,
		int	HowMany )

Definition at line 79 of file F5A.c.

{
hid_t   type_id  = H5Tcopy(H5T_C_S1);
hsize_t Sdims = HowMany;
hid_t   space_id = H5Screate_simple(1, &Sdims, &Sdims);
 
 
hid_t   attr_id;
        {
        size_t  size     = strlen(buf);
                H5Tset_size(type_id, size+1);
        }
        H5Tset_strpad(type_id, H5T_STR_NULLTERM);
 
        H5E_BEGIN_TRY
        attr_id = H5Acreate2(loc_id, name, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
        if (attr_id>0)
        {
                H5Awrite(attr_id, type_id, buf);
                H5Aclose(attr_id);
        }
 
        H5Sclose(space_id);
        H5Tclose(type_id);
 
        return 1;
}

References H5Tclose(), and name.

Referenced by F5FwriteIMAGE().

F5Asave_version()

F5_API herr_t F5Asave_version	(	hid_t	loc_id,
		int	major,
		int	minor,
		int	release )

Definition at line 286 of file F5A.c.

{
int     version_info[3];
hsize_t Sdims = 3;
hid_t   space_hid = H5Screate_simple(1, &Sdims, &Sdims);
hid_t   attr_hid = H5Acreate2(loc_id, FIBER_VERSION_ATTRIBUTE_NAME, H5T_NATIVE_INT, space_hid, H5P_DEFAULT,  H5P_DEFAULT);
 
        version_info[0] = major;
        version_info[1] = minor;
        version_info[2] = release;
 
        H5Awrite(attr_hid, H5T_NATIVE_INT, version_info);
        H5Aclose(attr_hid);
 
        H5Sclose(space_hid);
        return 0;
}

References FIBER_VERSION_ATTRIBUTE_NAME.

Referenced by F5I_create_contents(), F5Tsave_F5field_enum(), and F5Tsave_ProcArray_enum().

F5Astore_integer()

F5_API int F5Astore_integer	(	hid_t	loc_id,
		const char *	name,
		int	data )

Save an integer to the file as an attribute, checking if it already existed, and if so, that it had the same value.

Returns

non-zero in case of error, such as different value in file.

Definition at line 436 of file F5A.c.

{
herr_t  status;
hid_t   attr_id;
hid_t   space_id = H5Screate(H5S_SCALAR);
 
        F5printf(50, "-- F5Asave_integer(,%s,%d)\n", name, data);
 
        H5E_BEGIN_TRY
        attr_id = H5Acreate2(loc_id, name, H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
        H5Sclose(space_id);
        if (attr_id<0)
        {
                attr_id = F5Aopen_name(loc_id, name );
                if (attr_id>=0)
                {
                int     file_value = data;
                        status = H5Aread(attr_id, H5T_NATIVE_INT, &file_value);
                        if (status>=0)
                        {
                                H5Aclose(attr_id);
                                /*
                                  value in file is identical to what shall be
                                  written, so we are just fine
                                 */
                                if (file_value == data)
                                {
                                        F5printf(40, "F5Asave_integer(,%s,%d): attribute already has value %d, not overwritten!\n",
                                         name, data, file_value);
 
                                        return 1;
                                }
 
                                F5printf(4, "F5Asave_integer(,%s,%d): attribute has value %d, not overwritten!\n",
                                         name, data, file_value);
                        }
                        else
                        {
                                F5printf(4, "F5Asave_integer(,%s,%d): attribute could not be read, not changed!\n",
                                         name, data);
                        }
                }
                else
                {
                        F5printf(4, "F5Asave_integer(,%s,%d): can neither create nor open, don't know what to do.\n",
                                         name, data);
                }
                return 0;
        }
        assert(attr_id>=0);
 
        status = H5Awrite(attr_id, H5T_NATIVE_INT, &data);
        assert(status>=0);
        status = H5Aclose(attr_id); assert(status>=0);
        return 1;
}

References F5Aopen_name(), F5printf, and name.

Referenced by F5LTcreate_topology().

F5Atry_to_open()

F5_API hid_t F5Atry_to_open	(	hid_t	location,
		const char *	name )

Try to open an HDF5 attribute, silently return -1 if it does not exist.

Definition at line 23 of file F5A.c.

{
hid_t   retval;
 
        H5E_BEGIN_TRY
        retval = F5Aopen_name(location, name);
        H5E_END_TRY
 
        return retval;
}

References F5Aopen_name(), and name.

Referenced by F5Aget_ints(), F5Aget_string(), F5B_read_chart_domain(), F5Dset_type_attribute(), F5Fget_attribute_byname(), F5Fset_attribute_byname(), F5Lget_type(), and F5Tget_field_Array_enum().

F5Awrite_integer()

F5_API int F5Awrite_integer	(	hid_t	loc_id,
		const char *	name,
		int	data )

Save an integer to the file as an attribute, overwriting any existing value.

Returns

non-zero in case of error

Definition at line 494 of file F5A.c.

{
herr_t  status;
hid_t   attr_id;
hid_t   space_id = H5Screate(H5S_SCALAR);
 
        F5printf(50, "-- F5Awrite_integer(,%s,%d)\n", name, data);
 
        H5E_BEGIN_TRY
        attr_id = H5Acreate2(loc_id, name, H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
        H5Sclose(space_id);
        if (attr_id<0)
        {
                attr_id = F5Aopen_name(loc_id, name );
                if (attr_id<0)
                {
                        F5printf(4, "F5Awrite_integer(,%s,%d): can neither create nor open, don't know what to do.\n",
                                 name, data);
                        return  0;
                }
        }
        status = H5Awrite(attr_id, H5T_NATIVE_INT, &data);
        assert(status>=0);
        if (status<0)   // might fail if attribute is different type, in this case need to do something about it
        {
                H5Aclose(attr_id);
                return status;
        }
        status = H5Aclose(attr_id);
        assert(status>=0);
        return  1;
}

References F5Aopen_name(), F5printf, and name.