extern hid_t get_attribute_handle(hid_t parent, char *name)
{
char buf[MAX_ATTR_NAME+1];
int nattr, i, len;
hid_t aid;
H5O_info_t object_info;
if (parent < 0) {
debug3("PROFILE: parent is not HDF5 object");
return -1;
}
H5Oget_info(parent, &object_info);
nattr = object_info.num_attrs;
for (i = 0; (nattr>0) && (i<nattr); i++) {
aid = H5Aopen_by_idx(parent, ".", H5_INDEX_NAME, H5_ITER_INC,
i, H5P_DEFAULT, H5P_DEFAULT);
// Get the name of the attribute.
len = H5Aget_name(aid, MAX_ATTR_NAME, buf);
if (len < MAX_ATTR_NAME) {
if (strcmp(buf, name) == 0) {
return aid;
}
}
H5Aclose(aid);
}
debug3("PROFILE: failed to find HDF5 attribute=%s\n", name);
return -1;
}
//--------------------------------------------------------------------------
// Function: H5Object::openAttribute
///\brief Opens an attribute given its index.
///\param idx - IN: Index of the attribute, a 0-based, non-negative integer
///\return Attribute instance
///\exception H5::AttributeIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
Attribute H5Object::openAttribute( const unsigned int idx ) const
{
hid_t attr_id = H5Aopen_by_idx(getId(), ".", H5_INDEX_CRT_ORDER,
H5_ITER_INC, (hsize_t)idx, H5P_DEFAULT, H5P_DEFAULT);
if( attr_id > 0 )
{
Attribute attr( attr_id );
return( attr );
}
else
{
throw AttributeIException(inMemFunc("openAttribute"), "H5Aopen_by_idx failed");
}
}
//--------------------------------------------------------------------------
// Function: H5Location::openAttribute
///\brief Opens an attribute given its index.
///\param idx - IN: Index of the attribute, a 0-based, non-negative integer
///\return Attribute instance
///\exception H5::AttributeIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
Attribute H5Location::openAttribute( const unsigned int idx ) const
{
hid_t attr_id = H5Aopen_by_idx(getId(), ".", H5_INDEX_CRT_ORDER,
H5_ITER_INC, static_cast<hsize_t>(idx), H5P_DEFAULT, H5P_DEFAULT);
if( attr_id > 0 )
{
Attribute attr;
f_Attribute_setId(&attr, attr_id);
return(attr);
}
else
{
throw AttributeIException(inMemFunc("openAttribute"), "H5Aopen_by_idx failed");
}
}
void h5_att_str(hid_t file_id, char *group, char *name, char *value)
{
int ii, kk;
void *buf = NULL;
hid_t attr_id;
H5O_info_t object_info;
char *attr_name = (char *) MALLOC(sizeof(char)*50);
H5Oget_info_by_name(file_id, group, &object_info, H5P_DEFAULT);
for (ii=0; ii<object_info.num_attrs; ii++) {
attr_id = H5Aopen_by_idx(file_id, group, H5_INDEX_NAME, H5_ITER_NATIVE, ii,
H5P_DEFAULT, H5P_DEFAULT);
H5Aget_name(attr_id, 50, attr_name);
if (strcmp_case(name, attr_name) == 0) {
hid_t attr_type = H5Aget_type(attr_id);
H5T_class_t data_type = H5Tget_native_type(attr_type, H5T_DIR_DEFAULT);
size_t data_size = H5Tget_size(data_type);
hid_t attr_space = H5Aget_space(attr_id);
hsize_t dims[H5S_MAX_RANK];
int rank = H5Sget_simple_extent_dims(attr_space, dims, NULL);
hsize_t elements = 1;
for (kk=0; kk<rank; kk++)
elements *= dims[kk];
buf = (void *) MALLOC((unsigned)(elements*data_size));
H5Aread(attr_id, attr_type, buf);
H5Tclose(attr_type);
H5Tclose(data_type);
H5Sclose(attr_space);
}
else {
H5Aclose(attr_id);
continue;
}
H5Aclose(attr_id);
}
if (buf) {
strcpy(value, buf);
FREE(buf);
}
else
strcpy(value, "???");
FREE(attr_name);
}
/*
* Class: hdf_hdf5lib_H5
* Method: _H5Aopen_by_idx
* Signature: (JLjava/lang/String;IIJJJ)J
*/
JNIEXPORT jlong JNICALL
Java_hdf_hdf5lib_H5__1H5Aopen_1by_1idx
(JNIEnv *env, jclass clss, jlong loc_id, jstring name, jint idx_type, jint order, jlong n, jlong aapl_id, jlong lapl_id)
{
hid_t retVal = -1;
const char *aName;
PIN_JAVA_STRING(name, aName);
if (aName != NULL) {
retVal = H5Aopen_by_idx((hid_t)loc_id, aName, (H5_index_t)idx_type,
(H5_iter_order_t)order, (hsize_t)n, (hid_t)aapl_id, (hid_t)lapl_id);
UNPIN_JAVA_STRING(name, aName);
if (retVal < 0)
h5libraryError(env);
}
return (jlong)retVal;
} /* end Java_hdf_hdf5lib_H5__1H5Aopen_1by_1idx */
void Object::updateAttributes()
{
fAttributes.clear();
if (fObjectId < 0)
return;
// get attributes
int nAttrs = H5Aget_num_attrs(fObjectId);
if (nAttrs < 0) {
throw Exception("Could not retrieve number of attributes");
}
for (size_t iAttr = 0; iAttr < static_cast<size_t>(nAttrs); ++iAttr) {
char* attrName;
char objName[] = ".";
ssize_t nameLen = H5Aget_name_by_idx(fObjectId, objName, H5_INDEX_NAME, H5_ITER_INC, iAttr, 0, 0, H5P_DEFAULT);
if (nameLen > 0) {
// fetch name of this attribute
attrName = new char[++nameLen];
H5Aget_name_by_idx(fObjectId, objName, H5_INDEX_NAME, H5_ITER_INC, iAttr, attrName, nameLen, H5P_DEFAULT);
string sAttrName(attrName);
delete[] attrName;
// open attribute
hid_t attrId = H5Aopen_by_idx(fObjectId, objName, H5_INDEX_NAME, H5_ITER_INC, iAttr, H5P_DEFAULT, H5P_DEFAULT);
if (attrId < 0) {
cerr << "Could not open attribute '" << sAttrName << "'" << endl;
continue;
}
// parse type info
// cout << "Reading attribute: " << sAttrName << endl;
fAttributes[sAttrName] = llReadAttribute(attrId);
// close attribute
H5Aclose(attrId);
}
}
}
hsize_t diff_attr(hid_t loc1_id,
hid_t loc2_id,
const char *path1,
const char *path2,
diff_opt_t *options)
{
hid_t attr1_id=-1; /* attr ID */
hid_t attr2_id=-1; /* attr ID */
hid_t space1_id=-1; /* space ID */
hid_t space2_id=-1; /* space ID */
hid_t ftype1_id=-1; /* file data type ID */
hid_t ftype2_id=-1; /* file data type ID */
hid_t mtype1_id=-1; /* memory data type ID */
hid_t mtype2_id=-1; /* memory data type ID */
size_t msize1; /* memory size of memory type */
size_t msize2; /* memory size of memory type */
void *buf1=NULL; /* data buffer */
void *buf2=NULL; /* data buffer */
hsize_t nelmts1; /* number of elements in dataset */
int rank1; /* rank of dataset */
int rank2; /* rank of dataset */
hsize_t dims1[H5S_MAX_RANK];/* dimensions of dataset */
hsize_t dims2[H5S_MAX_RANK];/* dimensions of dataset */
char name1[512];
char name2[512];
char np1[512];
char np2[512];
H5O_info_t oinfo1, oinfo2; /* Object info */
unsigned u; /* Local index variable */
hsize_t nfound = 0;
hsize_t nfound_total = 0;
int j;
if(H5Oget_info(loc1_id, &oinfo1) < 0)
goto error;
if(H5Oget_info(loc2_id, &oinfo2) < 0)
goto error;
if(oinfo1.num_attrs != oinfo2.num_attrs)
return 1;
for( u = 0; u < (unsigned)oinfo1.num_attrs; u++)
{
/* reset buffers for every attribute, we might goto out and call free */
buf1 = NULL;
buf2 = NULL;
/* open attribute */
if((attr1_id = H5Aopen_by_idx(loc1_id, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, (hsize_t)u, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr1_id, 255, name1) < 0)
goto error;
/* use the name on the first file to open the second file */
H5E_BEGIN_TRY
{
if((attr2_id = H5Aopen(loc2_id, name1, H5P_DEFAULT)) < 0)
goto error;
} H5E_END_TRY;
/* get name */
if(H5Aget_name(attr2_id, 255, name2) < 0)
goto error;
/* get the datatypes */
if ((ftype1_id = H5Aget_type(attr1_id)) < 0)
goto error;
if ((ftype2_id = H5Aget_type(attr2_id)) < 0)
goto error;
if ((mtype1_id = h5tools_get_native_type(ftype1_id))<0)
goto error;
if ((mtype2_id = h5tools_get_native_type(ftype2_id))<0)
goto error;
if ((msize1 = H5Tget_size(mtype1_id))==0)
goto error;
if ((msize2 = H5Tget_size(mtype2_id))==0)
goto error;
/* get the dataspace */
if ((space1_id = H5Aget_space(attr1_id)) < 0)
goto error;
if ((space2_id = H5Aget_space(attr2_id)) < 0)
goto error;
/* get dimensions */
if ( (rank1 = H5Sget_simple_extent_dims(space1_id, dims1, NULL)) < 0 )
goto error;
if ( (rank2 = H5Sget_simple_extent_dims(space2_id, dims2, NULL)) < 0 )
goto error;
/*-------------------------------------------------------------------------
* check for comparable TYPE and SPACE
*-------------------------------------------------------------------------
*/
if ( msize1 != msize2
||
diff_can_type(ftype1_id,
ftype2_id,
rank1,
rank2,
dims1,
dims2,
NULL,
NULL,
name1,
name2,
options,
0)!=1)
{
if (H5Tclose(ftype1_id)<0)
goto error;
if (H5Tclose(ftype2_id)<0)
goto error;
if (H5Sclose(space1_id)<0)
goto error;
if (H5Sclose(space2_id)<0)
goto error;
if (H5Aclose(attr1_id)<0)
goto error;
if (H5Aclose(attr2_id)<0)
goto error;
if (H5Tclose(mtype1_id)<0)
goto error;
if (H5Tclose(mtype2_id)<0)
goto error;
continue;
}
/*-------------------------------------------------------------------------
* read
*-------------------------------------------------------------------------
*/
nelmts1=1;
for (j=0; j<rank1; j++)
nelmts1*=dims1[j];
buf1=(void *) HDmalloc((unsigned)(nelmts1*msize1));
buf2=(void *) HDmalloc((unsigned)(nelmts1*msize2));
if ( buf1==NULL || buf2==NULL){
parallel_print( "cannot read into memory\n" );
goto error;
}
if (H5Aread(attr1_id,mtype1_id,buf1)<0)
goto error;
if (H5Aread(attr2_id,mtype2_id,buf2)<0)
goto error;
/* format output string */
sprintf(np1,"%s of <%s>",name1,path1);
sprintf(np2,"%s of <%s>",name2,path2);
/*-------------------------------------------------------------------------
* array compare
*-------------------------------------------------------------------------
*/
/* always print name */
if (options->m_verbose)
{
do_print_objname ("attribute", np1, np2);
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
print_found(nfound);
}
/* check first if we have differences */
else
{
if (options->m_quiet==0)
{
/* shut up temporarily */
options->m_quiet=1;
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
/* print again */
options->m_quiet=0;
if (nfound)
{
do_print_objname ("attribute", np1, np2);
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
print_found(nfound);
} /*if*/
} /*if*/
/* in quiet mode, just count differences */
else
{
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
} /*else quiet */
} /*else verbose */
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
if (H5Tclose(ftype1_id)<0)
goto error;
if (H5Tclose(ftype2_id)<0)
goto error;
if (H5Sclose(space1_id)<0)
goto error;
if (H5Sclose(space2_id)<0)
goto error;
if (H5Aclose(attr1_id)<0)
goto error;
if (H5Aclose(attr2_id)<0)
goto error;
if (H5Tclose(mtype1_id)<0)
goto error;
if (H5Tclose(mtype2_id)<0)
goto error;
if (buf1)
HDfree(buf1);
if (buf2)
HDfree(buf2);
nfound_total += nfound;
} /* u */
return nfound_total;
error:
H5E_BEGIN_TRY {
H5Tclose(ftype1_id);
H5Tclose(ftype2_id);
H5Tclose(mtype1_id);
H5Tclose(mtype2_id);
H5Sclose(space1_id);
H5Sclose(space2_id);
H5Aclose(attr1_id);
H5Aclose(attr2_id);
if (buf1)
HDfree(buf1);
if (buf2)
HDfree(buf2);
} H5E_END_TRY;
options->err_stat=1;
return nfound_total;
}
// Read all optional attributes
char AH5_read_opt_attrs(hid_t loc_id, const char *path, AH5_opt_attrs_t *opt_attrs, char mandatory_attrs[][AH5_ATTR_LENGTH], size_t nb_mandatory_attrs)
{
char success = AH5_FALSE, is_mandatory;
H5O_info_t object_info;
hsize_t i, j, k = 0;
hid_t attr_id, type_id, memtype;
float buf[2];
hsize_t nb_present_mandatory_attrs = 0;
char temp_name[AH5_ATTR_LENGTH];
if (AH5_path_valid(loc_id, path))
{
// Check presence of all mandatory attributes
for (i = 0; i < (hsize_t) nb_mandatory_attrs; i++)
if (H5Aexists_by_name(loc_id, path, mandatory_attrs[i], H5P_DEFAULT) > 0)
nb_present_mandatory_attrs++;
H5Oget_info_by_name(loc_id, path, &object_info, H5P_DEFAULT);
opt_attrs->nb_instances = object_info.num_attrs - nb_present_mandatory_attrs;
if (opt_attrs->nb_instances > 0)
opt_attrs->instances = (AH5_attr_instance_t *) malloc ((size_t) opt_attrs->nb_instances * sizeof(AH5_attr_instance_t));
for (i = 0; i < object_info.num_attrs; i++)
{
is_mandatory = AH5_FALSE;
attr_id = H5Aopen_by_idx(loc_id, path, H5_INDEX_CRT_ORDER, H5_ITER_NATIVE, i, H5P_DEFAULT, H5P_DEFAULT);
H5Aget_name(attr_id, AH5_ATTR_LENGTH, temp_name);
for (j = 0; j < nb_mandatory_attrs; j++)
if (strcmp(temp_name, mandatory_attrs[j]) == 0)
is_mandatory = AH5_TRUE;
if (!is_mandatory)
{
opt_attrs->instances[k].name = strdup(temp_name);
type_id = H5Aget_type(attr_id);
opt_attrs->instances[k].type = H5Tget_class(type_id);
H5Tclose(type_id);
switch (opt_attrs->instances[k].type)
{
case H5T_INTEGER:
opt_attrs->instances[k].value.i = 0;
if (H5Aread(attr_id, H5T_NATIVE_INT, &(opt_attrs->instances[k].value.i)) >= 0)
success = AH5_TRUE;
break;
case H5T_FLOAT:
opt_attrs->instances[k].value.f = 0;
if (H5Aread(attr_id, H5T_NATIVE_FLOAT, &(opt_attrs->instances[k].value.f)) >= 0)
success = AH5_TRUE;
break;
case H5T_COMPOUND:
opt_attrs->instances[k].value.c = AH5_set_complex(0, 0);
type_id = AH5_H5Tcreate_cpx_memtype();
if (H5Aread(attr_id, type_id, buf) >= 0)
{
opt_attrs->instances[k].value.c = AH5_set_complex(buf[0], buf[1]);
success = AH5_TRUE;
}
H5Tclose(type_id);
break;
case H5T_STRING:
opt_attrs->instances[k].value.s = NULL;
memtype = H5Tcopy(H5T_C_S1);
H5Tset_size(memtype, AH5_ATTR_LENGTH);
opt_attrs->instances[k].value.s = (char *) malloc(AH5_ATTR_LENGTH * sizeof(char));
if (H5Aread(attr_id, memtype, opt_attrs->instances[k].value.s) >= 0)
success = AH5_TRUE;
H5Tclose(memtype);
break;
default:
opt_attrs->instances[k].type = H5T_NO_CLASS;
printf("***** WARNING: Unsupported type of attribute \"%s@%s\". *****\n\n", path, opt_attrs->instances[k].name);
break;
}
k++;
}
H5Aclose(attr_id);
}
}
if (!success)
{
opt_attrs->instances = NULL;
opt_attrs->nb_instances = 0;
}
return success;
}
/*-------------------------------------------------------------------------
* Function: build_match_list_attrs
*
* Purpose: get list of matching attribute name from obj1 and obj2
*
* Note:
* Find common attribute; the algorithm for search is referred from
* build_match_list() in h5diff.c .
*
* Parameter:
* table_out [OUT] : return the list
*
* Programmer: Jonathan Kim
*
* Date: March 15, 2011
*------------------------------------------------------------------------*/
static herr_t build_match_list_attrs(hid_t loc1_id, hid_t loc2_id, table_attrs_t ** table_out, diff_opt_t *options)
{
H5O_info_t oinfo1, oinfo2; /* Object info */
hid_t attr1_id=-1; /* attr ID */
hid_t attr2_id=-1; /* attr ID */
size_t curr1 = 0;
size_t curr2 = 0;
unsigned infile[2];
char name1[ATTR_NAME_MAX];
char name2[ATTR_NAME_MAX];
int cmp;
unsigned i;
table_attrs_t *table_lp = NULL;
if(H5Oget_info(loc1_id, &oinfo1) < 0)
goto error;
if(H5Oget_info(loc2_id, &oinfo2) < 0)
goto error;
table_attrs_init( &table_lp );
/*--------------------------------------------------
* build the list
*/
while(curr1 < oinfo1.num_attrs && curr2 < oinfo2.num_attrs)
{
/*------------------
* open attribute1 */
if((attr1_id = H5Aopen_by_idx(loc1_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr1, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr1_id, (size_t)ATTR_NAME_MAX, name1) < 0)
goto error;
/*------------------
* open attribute2 */
if((attr2_id = H5Aopen_by_idx(loc2_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr2, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr2_id, (size_t)ATTR_NAME_MAX, name2) < 0)
goto error;
/* criteria is string compare */
cmp = HDstrcmp(name1, name2);
if(cmp == 0)
{
infile[0] = 1;
infile[1] = 1;
table_attr_mark_exist(infile, name1, table_lp);
curr1++;
curr2++;
}
else if(cmp < 0)
{
infile[0] = 1;
infile[1] = 0;
table_attr_mark_exist(infile, name1, table_lp);
table_lp->nattrs_only1++;
curr1++;
}
else
{
infile[0] = 0;
infile[1] = 1;
table_attr_mark_exist(infile, name2, table_lp);
table_lp->nattrs_only2++;
curr2++;
}
/* close for next turn */
H5Aclose(attr1_id);
attr1_id = -1;
H5Aclose(attr2_id);
attr2_id = -1;
} /* end while */
/* list1 did not end */
infile[0] = 1;
infile[1] = 0;
while(curr1 < oinfo1.num_attrs)
{
/*------------------
* open attribute1 */
if((attr1_id = H5Aopen_by_idx(loc1_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr1, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr1_id, (size_t)ATTR_NAME_MAX, name1) < 0)
goto error;
table_attr_mark_exist(infile, name1, table_lp);
table_lp->nattrs_only1++;
curr1++;
/* close for next turn */
H5Aclose(attr1_id);
attr1_id = -1;
}
/* list2 did not end */
infile[0] = 0;
infile[1] = 1;
while(curr2 < oinfo2.num_attrs)
{
/*------------------
* open attribute2 */
if((attr2_id = H5Aopen_by_idx(loc2_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr2, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr2_id, (size_t)ATTR_NAME_MAX, name2) < 0)
goto error;
table_attr_mark_exist(infile, name2, table_lp);
table_lp->nattrs_only2++;
curr2++;
/* close for next turn */
H5Aclose(attr2_id);
}
/*------------------------------------------------------
* print the list
*/
if(options->m_verbose_level == 2)
{
/* if '-v2' is detected */
parallel_print(" obj1 obj2\n");
parallel_print(" --------------------------------------\n");
for(i = 0; i < (unsigned int) table_lp->nattrs; i++)
{
char c1, c2;
c1 = (table_lp->attrs[i].exist[0]) ? 'x' : ' ';
c2 = (table_lp->attrs[i].exist[1]) ? 'x' : ' ';
parallel_print("%5c %6c %-15s\n", c1, c2, table_lp->attrs[i].name);
} /* end for */
}
if(options->m_verbose_level >= 1)
{
parallel_print("Attributes status: %d common, %d only in obj1, %d only in obj2\n", table_lp->nattrs - table_lp->nattrs_only1 - table_lp->nattrs_only2, table_lp->nattrs_only1, table_lp->nattrs_only2 );
}
*table_out = table_lp;
return 0;
error:
if (0 < attr1_id)
H5Aclose(attr1_id);
if (0 < attr2_id)
H5Aclose(attr2_id);
return -1;
}
/*-------------------------------------------------------------------------
* Function: copy_attr
*
* Purpose: copy attributes located in LOC_IN, which is obtained either from
* loc_id = H5Gopen2( fid, name);
* loc_id = H5Dopen2( fid, name);
* loc_id = H5Topen2( fid, name);
*
* Return: 0, ok, -1 no
*-------------------------------------------------------------------------
*/
int
copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p,
trav_table_t *travt, pack_opt_t *options)
{
int ret_value = 0;
hid_t attr_id = -1; /* attr ID */
hid_t attr_out = -1; /* attr ID */
hid_t space_id = -1; /* space ID */
hid_t ftype_id = -1; /* file type ID */
hid_t wtype_id = -1; /* read/write type ID */
size_t msize; /* size of type */
void *buf = NULL; /* data buffer */
hsize_t nelmts; /* number of elements in dataset */
int rank; /* rank of dataset */
htri_t is_named; /* Whether the datatype is named */
hsize_t dims[H5S_MAX_RANK];/* dimensions of dataset */
char name[255];
H5O_info_t oinfo; /* object info */
int j;
unsigned u;
hbool_t is_ref = 0;
H5T_class_t type_class = -1;
if (H5Oget_info(loc_in, &oinfo) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Oget_info failed");
/*-------------------------------------------------------------------------
* copy all attributes
*-------------------------------------------------------------------------
*/
for (u = 0; u < (unsigned) oinfo.num_attrs; u++) {
/* open attribute */
if ((attr_id = H5Aopen_by_idx(loc_in, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, (hsize_t) u, H5P_DEFAULT, H5P_DEFAULT)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aopen_by_idx failed");
/* get name */
if (H5Aget_name(attr_id, (size_t) 255, name) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
/* get the file datatype */
if ((ftype_id = H5Aget_type(attr_id)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_type failed");
/* Check if the datatype is committed */
if ((is_named = H5Tcommitted(ftype_id)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tcommitted failed");
if (is_named && travt) {
hid_t fidout = -1;
/* Create out file id */
if ((fidout = H5Iget_file_id(loc_out)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Iget_file_id failed");
/* Copy named dt */
if ((wtype_id = copy_named_datatype(ftype_id, fidout, named_dt_head_p, travt, options)) < 0) {
H5Fclose(fidout);
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_named_datatype failed");
} /* end if */
if (H5Fclose(fidout) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fclose failed");
} /* end if */
else {
if (options->use_native == 1)
wtype_id = H5Tget_native_type(ftype_id, H5T_DIR_DEFAULT);
else
wtype_id = H5Tcopy(ftype_id);
} /* end else */
/* get the dataspace handle */
if ((space_id = H5Aget_space(attr_id)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_space failed");
/* get dimensions */
if ((rank = H5Sget_simple_extent_dims(space_id, dims, NULL)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
nelmts = 1;
for (j = 0; j < rank; j++)
nelmts *= dims[j];
if ((msize = H5Tget_size(wtype_id)) == 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
/*-------------------------------------------------------------------------
* object references are a special case. We cannot just copy the buffers,
* but instead we recreate the reference.
* This is done on a second sweep of the file that just copies the referenced
* objects at copy_refs_attr()
*-------------------------------------------------------------------------
*/
type_class = H5Tget_class(wtype_id);
is_ref = (type_class == H5T_REFERENCE);
if (type_class == H5T_VLEN || type_class == H5T_ARRAY) {
hid_t base_type = -1;
base_type = H5Tget_super(ftype_id);
is_ref = (is_ref || (H5Tget_class(base_type) == H5T_REFERENCE));
if (H5Tclose(base_type) < 0)
H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose base_type failed");
}
if (type_class == H5T_COMPOUND) {
int nmembers = H5Tget_nmembers(wtype_id);
for (j = 0; j < nmembers; j++) {
hid_t mtid = H5Tget_member_type(wtype_id, (unsigned)j);
H5T_class_t mtclass = H5Tget_class(mtid);
if (H5Tclose(mtid) < 0)
H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose mtid failed");
if (mtclass == H5T_REFERENCE) {
is_ref = 1;
break;
}
} /* for (j=0; i<nmembers; j++) */
} /* if (type_class == H5T_COMPOUND) */
if (!is_ref) {
/*-------------------------------------------------------------------------
* read to memory
*-------------------------------------------------------------------------
*/
buf = (void *)HDmalloc((size_t)(nelmts * msize));
if (buf == NULL) {
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
} /* end if */
if (H5Aread(attr_id, wtype_id, buf) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
/*-------------------------------------------------------------------------
* copy
*-------------------------------------------------------------------------
*/
if ((attr_out = H5Acreate2(loc_out, name, wtype_id, space_id, H5P_DEFAULT, H5P_DEFAULT)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Acreate2 failed on ,%s>", name);
if (H5Awrite(attr_out, wtype_id, buf) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Awrite failed");
/*close*/
if (H5Aclose(attr_out) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
/* Check if we have VL data and string in the attribute's datatype that must
* be reclaimed */
if (TRUE == h5tools_detect_vlen(wtype_id))
H5Dvlen_reclaim(wtype_id, space_id, H5P_DEFAULT, buf);
HDfree(buf);
buf = NULL;
} /*H5T_REFERENCE*/
if (options->verbose)
printf(FORMAT_OBJ_ATTR, "attr", name);
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
if (H5Sclose(space_id) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
space_id = -1;
if (H5Tclose(wtype_id) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
wtype_id = -1;
if (H5Tclose(ftype_id) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
ftype_id = -1;
if (H5Aclose(attr_id) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
attr_id = -1;
} /* for u */
done:
H5E_BEGIN_TRY {
if (buf) {
/* Check if we have VL data and string in the attribute's datatype that must
* be reclaimed */
if (TRUE == h5tools_detect_vlen(wtype_id))
H5Dvlen_reclaim(wtype_id, space_id, H5P_DEFAULT, buf);
/* Free buf */
HDfree(buf);
} /* end if */
H5Aclose(attr_out);
H5Sclose(space_id);
H5Tclose(wtype_id);
H5Tclose(ftype_id);
H5Aclose(attr_id);
} H5E_END_TRY;
return ret_value;
} /* end copy_attr() */
int
main (void)
{
hid_t file, dataset; /* File and dataset identifiers */
hid_t fid; /* Dataspace identifier */
hid_t attr1, attr2, attr3; /* Attribute identifiers */
hid_t attr;
hid_t aid1, aid2, aid3; /* Attribute dataspace identifiers */
hid_t atype, atype_mem; /* Attribute type */
H5T_class_t type_class;
hsize_t fdim[] = {SIZE};
hsize_t adim[] = {ADIM1, ADIM2}; /* Dimensions of the first attribute */
float matrix[ADIM1][ADIM2]; /* Attribute data */
herr_t ret; /* Return value */
H5O_info_t oinfo; /* Object info */
unsigned i, j; /* Counters */
char string_out[80]; /* Buffer to read string attribute back */
int point_out; /* Buffer to read scalar attribute back */
/*
* Data initialization.
*/
int vector[] = {1, 2, 3, 4, 5, 6, 7}; /* Dataset data */
int point = 1; /* Value of the scalar attribute */
char string[] = "ABCD"; /* Value of the string attribute */
for (i=0; i < ADIM1; i++) { /* Values of the array attribute */
for (j=0; j < ADIM2; j++)
matrix[i][j] = -1.;
}
/*
* Create a file.
*/
file = H5Fcreate(H5FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create the dataspace for the dataset in the file.
*/
fid = H5Screate(H5S_SIMPLE);
ret = H5Sset_extent_simple(fid, RANK, fdim, NULL);
/*
* Create the dataset in the file.
*/
dataset = H5Dcreate2(file, "Dataset", H5T_NATIVE_INT, fid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/*
* Write data to the dataset.
*/
ret = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL , H5S_ALL, H5P_DEFAULT, vector);
/*
* Create dataspace for the first attribute.
*/
aid1 = H5Screate(H5S_SIMPLE);
ret = H5Sset_extent_simple(aid1, ARANK, adim, NULL);
/*
* Create array attribute.
*/
attr1 = H5Acreate2(dataset, ANAME, H5T_NATIVE_FLOAT, aid1, H5P_DEFAULT, H5P_DEFAULT);
/*
* Write array attribute.
*/
ret = H5Awrite(attr1, H5T_NATIVE_FLOAT, matrix);
/*
* Create scalar attribute.
*/
aid2 = H5Screate(H5S_SCALAR);
attr2 = H5Acreate2(dataset, "Integer attribute", H5T_NATIVE_INT, aid2,
H5P_DEFAULT, H5P_DEFAULT);
/*
* Write scalar attribute.
*/
ret = H5Awrite(attr2, H5T_NATIVE_INT, &point);
/*
* Create string attribute.
*/
aid3 = H5Screate(H5S_SCALAR);
atype = H5Tcopy(H5T_C_S1);
H5Tset_size(atype, 5);
H5Tset_strpad(atype,H5T_STR_NULLTERM);
attr3 = H5Acreate2(dataset, ANAMES, atype, aid3, H5P_DEFAULT, H5P_DEFAULT);
/*
* Write string attribute.
*/
ret = H5Awrite(attr3, atype, string);
/*
* Close attribute and file dataspaces, and datatype.
*/
ret = H5Sclose(aid1);
ret = H5Sclose(aid2);
ret = H5Sclose(aid3);
ret = H5Sclose(fid);
ret = H5Tclose(atype);
/*
* Close the attributes.
*/
ret = H5Aclose(attr1);
ret = H5Aclose(attr2);
ret = H5Aclose(attr3);
/*
* Close the dataset.
*/
ret = H5Dclose(dataset);
/*
* Close the file.
*/
ret = H5Fclose(file);
/*
* Reopen the file.
*/
file = H5Fopen(H5FILE_NAME, H5F_ACC_RDONLY, H5P_DEFAULT);
/*
* Open the dataset.
*/
dataset = H5Dopen2(file, "Dataset", H5P_DEFAULT);
/*
* Attach to the scalar attribute using attribute name, then read and
* display its value.
*/
attr = H5Aopen(dataset, "Integer attribute", H5P_DEFAULT);
ret = H5Aread(attr, H5T_NATIVE_INT, &point_out);
printf("The value of the attribute \"Integer attribute\" is %d \n", point_out);
ret = H5Aclose(attr);
/*
* Find string attribute by iterating through all attributes
*/
ret = H5Oget_info(dataset, &oinfo);
for(i = 0; i < (unsigned)oinfo.num_attrs; i++) {
attr = H5Aopen_by_idx(dataset, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, (hsize_t)i, H5P_DEFAULT, H5P_DEFAULT);
atype = H5Aget_type(attr);
type_class = H5Tget_class(atype);
if (type_class == H5T_STRING) {
atype_mem = H5Tget_native_type(atype, H5T_DIR_ASCEND);
ret = H5Aread(attr, atype_mem, string_out);
printf("Found string attribute; its index is %d , value = %s \n", i, string_out);
ret = H5Tclose(atype_mem);
}
ret = H5Aclose(attr);
ret = H5Tclose(atype);
}
/*
* Get attribute info using iteration function.
*/
ret = H5Aiterate2(dataset, H5_INDEX_NAME, H5_ITER_INC, NULL, attr_info, NULL);
/*
* Close the dataset and the file.
*/
H5Dclose(dataset);
H5Fclose(file);
return 0;
}
