自学教程：C++ H5Aopen函数代码示例

AccessTraceReader::AccessTraceReader(std::string _fname) : fname(_fname.c_str()) {    hid_t fid = H5Fopen(fname.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);    if (fid == H5I_INVALID_HID) panic("Could not open HDF5 file %s", fname.c_str());    // Check that the trace finished    hid_t fAttr = H5Aopen(fid, "finished", H5P_DEFAULT);    uint32_t finished;    H5Aread(fAttr, H5T_NATIVE_UINT, &finished);    H5Aclose(fAttr);    if (!finished) panic("Trace file %s unfinished (halted simulation?)", fname.c_str());    // Populate numRecords & numChildren    hsize_t nPackets;    hid_t table = H5PTopen(fid, "accs");    if (table == H5I_INVALID_HID) panic("Could not open HDF5 packet table");    H5PTget_num_packets(table, &nPackets);    numRecords = nPackets;    hid_t ncAttr = H5Aopen(fid, "numChildren", H5P_DEFAULT);    H5Aread(ncAttr, H5T_NATIVE_UINT, &numChildren);    H5Aclose(ncAttr);    curFrameRecord = 0;    cur = 0;    max = MIN(PT_CHUNKSIZE, numRecords);    buf = max? gm_calloc<PackedAccessRecord>(max) : nullptr;    if (max) {        H5PTread_packets(table, 0, max, buf);    }    H5PTclose(table);    H5Fclose(fid);}

char AH5_write_str_root_attr(hid_t loc_id, const char *attr_name, const char *wdata){  char success = AH5_FALSE;  hid_t aid = H5Screate(H5S_SCALAR);  hid_t atype = H5Tcopy(H5T_C_S1);  htri_t attr_exists = H5Aexists(loc_id, attr_name);  hid_t attr = -1;  H5Tset_size(atype, strlen(wdata));  if (atype >= 0) {    if (attr_exists == 0) {      attr = H5Acreate(loc_id, attr_name, atype, aid, H5P_DEFAULT, H5P_DEFAULT);    } else if (attr_exists > 0) {      attr = H5Aopen(loc_id, attr_name, H5P_DEFAULT);    }    if (attr && H5Awrite(attr, atype, wdata) >= 0 && H5Aclose(attr) >= 0)      success = AH5_TRUE;  }  success &= (H5Tclose(atype) >= 0);  success &= (H5Sclose(aid) >= 0);  return success;}

inte5_write_attr_list_double(    hid_t e5_group_id, e5_attr_double* e5_attr_list){    int i;    hid_t e5_attribute_id;    hid_t e5_dataspace_id = H5Screate(H5S_SCALAR);    for(i = 0; e5_attr_list && e5_attr_list[i].name != 0; i++)    {        e5_attr_double *attr = &e5_attr_list[i];        if(attr->name == 0 || strlen(attr->name) < 1)            continue;        if(H5Aexists(e5_group_id, attr->name) <= 0)            e5_attribute_id = H5Acreate(e5_group_id, attr->name, H5T_IEEE_F64LE, e5_dataspace_id, H5P_DEFAULT);        else            e5_attribute_id = H5Aopen(e5_group_id, attr->name, H5P_DEFAULT);        e5_info(e5_group_id, "Adding attribute [type='double', name='%s', value='%f']/n",  attr->name, attr->value);        H5Awrite(e5_attribute_id, H5T_NATIVE_DOUBLE, &(attr->value));        H5Aclose(e5_attribute_id);    }    H5Sclose(e5_dataspace_id);    return E5_SUCCESS;}

static int readIntAttribute(int _iDatasetId, const char *_pstName){    hid_t iAttributeId;    herr_t status;    int iVal = -1;    hsize_t n = 0;    if (H5Aiterate(_iDatasetId, H5_INDEX_NAME, H5_ITER_NATIVE, &n, find_attr_by_name, (void *)_pstName) > 0)    {        iAttributeId = H5Aopen(_iDatasetId, _pstName, H5P_DEFAULT);        if (iAttributeId < 0)        {            return -1;        }        status = H5Aread(iAttributeId, H5T_NATIVE_INT, &iVal);        if (status < 0)        {            return -1;        }        status = H5Aclose(iAttributeId);        if (status < 0)        {            return -1;        }    }    return iVal;}

estatus_te5_write_attr_list_str(    hid_t e5_group_id, e5_attr_str* e5_attr_list){    int i;    hid_t e5_attribute_id;    hid_t e5_dataspace_id = H5Screate(H5S_SCALAR);    hid_t e5_string_type = H5Tcopy(H5T_C_S1);    H5Tset_size(e5_string_type, E5_MAX_ATTR_STRING_LENGTH);    for(i = 0; e5_attr_list && e5_attr_list[i].name != 0; i++)    {        e5_attr_str *attr = &e5_attr_list[i];        if(attr->name == 0 || strlen(attr->name) < 1)            continue;        if(attr->value == 0 || strlen(attr->value) < 1)            continue;        if(H5Aexists(e5_group_id, attr->name) <= 0)            e5_attribute_id = H5Acreate(e5_group_id, attr->name, e5_string_type, e5_dataspace_id, H5P_DEFAULT);        else            e5_attribute_id = H5Aopen(e5_group_id, attr->name, H5P_DEFAULT);        e5_info(e5_group_id, "Adding attribute [type='string', name='%s', value='%s']/n",  attr->name, attr->value);        H5Awrite(e5_attribute_id, e5_string_type, &(attr->value));        H5Aclose(e5_attribute_id);    }    H5Sclose(e5_dataspace_id);    return E5_SUCCESS;}

    void DCAttribute::writeAttribute(const char* name, const hid_t type, hid_t parent,                                     uint32_t ndims, const Dimensions dims, const void* src)    throw (DCException)    {        hid_t attr = -1;        if (H5Aexists(parent, name))            attr = H5Aopen(parent, name, H5P_DEFAULT);        else        {            hid_t dsp;            if( ndims == 1 && dims.getScalarSize() == 1 )                dsp = H5Screate(H5S_SCALAR);            else                dsp = H5Screate_simple( ndims, dims.getPointer(), dims.getPointer() );            attr = H5Acreate(parent, name, type, dsp, H5P_DEFAULT, H5P_DEFAULT);            H5Sclose(dsp);        }        if (attr < 0)            throw DCException(getExceptionString(name, "Attribute could not be opened or created"));        if (H5Awrite(attr, type, src) < 0)        {            H5Aclose(attr);            throw DCException(getExceptionString(name, "Attribute could not be written"));        }        H5Aclose(attr);    }

estatus_te5_read_attr_list_float(    hid_t e5_group_id, e5_attr_float* e5_attr_list){    int i;    hid_t e5_attribute_id;    estatus_t status = E5_SUCCESS;    for(i = 0; e5_attr_list && e5_attr_list[i].name != 0; i++)    {        e5_attr_float *attr = &e5_attr_list[i];        if(attr->name == 0 || strlen(attr->name) < 1)            continue;        if(H5Aexists(e5_group_id, attr->name) <= 0)        {            status = E5_INVALID_ATTRIBUTE;            e5_error(e5_group_id, status, "Specified attribute '%s' does not exist/n", attr->name);            continue;        }        e5_attribute_id = H5Aopen(e5_group_id, attr->name, H5P_DEFAULT);        H5Aread(e5_attribute_id, H5T_NATIVE_FLOAT, &(attr->value));        H5Aclose(e5_attribute_id);        e5_info(e5_group_id, "Read attribute [type='float', name='%s', value='%f']/n",  attr->name, attr->value);    }    return status;}

	void write_internal(hdf5dataset& hdataset, const std::string& name, hid_t type_id, const void* buffer, bool overwrite)	{		bool exists = H5Aexists(hdataset.handle(), name.c_str());		hid_t attribute_id = -1;		if(exists && overwrite)		{			attribute_id = H5Aopen(hdataset.handle(), name.c_str(), H5P_DEFAULT);			//H5Ldelete(_hfile.handle(), name.c_str(), H5P_DEFAULT);		}		else if(exists && !overwrite)			throw std::runtime_error("Attribute already exists: (" + name + ")");		else		{			hsize_t dims = 1;			hid_t space_id = H5Screate_simple(1, &dims, NULL);			attribute_id = H5Acreate(hdataset.handle(), name.c_str(), type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);			H5Sclose(space_id);		}		if(attribute_id < 0)			throw std::runtime_error("Error creating or opening attribute () in file (" + name + ")");		H5Awrite(attribute_id, type_id, buffer);		H5Tclose(type_id);		H5Aclose(attribute_id);	}

escdf_errno_t utils_hdf5_check_attr(hid_t loc_id, const char *name,                                    hsize_t *dims, unsigned int ndims,                                    hid_t *attr_pt){    hid_t attr_id, dtspace_id;    if ((attr_id = H5Aopen(loc_id, name, H5P_DEFAULT)) < 0)        RETURN_WITH_ERROR(attr_id);    /* Check space dimensions. */    if ((dtspace_id = H5Aget_space(attr_id)) < 0) {        DEFER_FUNC_ERROR(dtspace_id);        goto cleanup_attr;    }    if (utils_hdf5_check_shape(dtspace_id, dims, ndims) != ESCDF_SUCCESS) {        goto cleanup_dtspace;    }    H5Sclose(dtspace_id);    if (attr_pt)        *attr_pt = attr_id;    else        H5Aclose(attr_id);    return ESCDF_SUCCESS;    cleanup_dtspace:    H5Sclose(dtspace_id);    cleanup_attr:    H5Aclose(attr_id);    return ESCDF_ERROR;}

estatus_te5_read_attr_list_str(    hid_t e5_group_id, e5_attr_str* e5_attr_list){    int i;    estatus_t status = E5_SUCCESS;    hid_t e5_attribute_id;    hid_t e5_dataspace_id = H5Screate(H5S_SCALAR);    hid_t e5_string_type = H5Tcopy(H5T_C_S1);    H5Tset_size(e5_string_type, E5_MAX_ATTR_STRING_LENGTH);    for(i = 0; e5_attr_list && e5_attr_list[i].name != 0; i++)    {        e5_attr_str *attr = &e5_attr_list[i];        if(attr->name == 0 || strlen(attr->name) < 1)            continue;        if(H5Aexists(e5_group_id, attr->name) <= 0)        {            status = E5_INVALID_ATTRIBUTE;            e5_error(e5_group_id, status, "Specified attribute '%s' does not exist/n", attr->name);            continue;        }        e5_attribute_id = H5Aopen(e5_group_id, attr->name, H5P_DEFAULT);        H5Aread(e5_attribute_id, e5_string_type, &(attr->value));        H5Aclose(e5_attribute_id);        e5_info(e5_group_id, "Read attribute [type='str', name='%s', value='%s']/n",  attr->name, attr->value);    }    H5Sclose(e5_dataspace_id);    return status;}

estatus_te5_write_attr_list(    hid_t e5_group_id, e5_attr* e5_attr_list){    int i;    eid_t status = E5_SUCCESS;    hid_t e5_attribute_id;    hid_t e5_dataspace_id = H5Screate(H5S_SCALAR);    for(i = 0; e5_attr_list && e5_attr_list[i].name != 0; i++)    {        e5_attr *attr = &e5_attr_list[i];        if(attr->name == 0 || strlen(attr->name) < 1)            continue;        if(e5_is_valid_type(e5_attr_list[i].type) != E5_TRUE)        {            status = E5_INVALID_TYPE;            e5_error(e5_group_id, status, "Invalid type requested for attribute [type='%d', name='%s', value='%p']/n",  attr->type, attr->name, attr->value);            continue;        }        hid_t hdf_type = e5_convert_type_to_hdf(e5_attr_list[i].type);        hid_t hdf_format = e5_convert_format_to_hdf(e5_attr_list[i].type);        if(H5Aexists(e5_group_id, attr->name) <= 0)            e5_attribute_id = H5Acreate(e5_group_id, attr->name, hdf_type, e5_dataspace_id, H5P_DEFAULT);        e5_info(e5_group_id, "Adding attribute [type='integer', name='%s', value='%d']/n",  attr->name, attr->value);        e5_attribute_id = H5Aopen(e5_group_id, attr->name, H5P_DEFAULT);        H5Awrite(e5_attribute_id, hdf_format, &(attr->value));        H5Aclose(e5_attribute_id);    }    H5Sclose(e5_dataspace_id);    return E5_SUCCESS;}

hid_t seissol::checkpoint::h5::Fault::initFile(int odd, const char* filename){	hid_t h5file;	if (loaded()) {		// Open the file		h5file = open(filename, false);		checkH5Err(h5file);		// Fault writer		m_h5timestepFault[odd] = H5Aopen(h5file, "timestep_fault", H5P_DEFAULT);		checkH5Err(m_h5timestepFault[odd]);		// Data		for (unsigned int i = 0; i < NUM_VARIABLES; i++) {			m_h5data[odd][i] = H5Dopen(h5file, VAR_NAMES[i], H5P_DEFAULT);			checkH5Err(m_h5data[odd][i]);		}	} else {		// Create the file		hid_t h5plist = H5Pcreate(H5P_FILE_ACCESS);		checkH5Err(h5plist);		checkH5Err(H5Pset_libver_bounds(h5plist, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST));#ifdef USE_MPI		checkH5Err(H5Pset_fapl_mpio(h5plist, comm(), MPI_INFO_NULL));#endif // USE_MPI		h5file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, h5plist);		checkH5Err(h5file);		checkH5Err(H5Pclose(h5plist));		// Create scalar dataspace for attributes		hid_t h5spaceScalar = H5Screate(H5S_SCALAR);		checkH5Err(h5spaceScalar);		// Fault writer		m_h5timestepFault[odd] = H5Acreate(h5file, "timestep_fault",				H5T_STD_I32LE, h5spaceScalar, H5P_DEFAULT, H5P_DEFAULT);		checkH5Err(m_h5timestepFault[odd]);		int t = 0;		checkH5Err(H5Awrite(m_h5timestepFault[odd], H5T_NATIVE_INT, &t));		checkH5Err(H5Sclose(h5spaceScalar));		// Variables		for (unsigned int i = 0; i < NUM_VARIABLES; i++) {			h5plist = H5Pcreate(H5P_DATASET_CREATE);			checkH5Err(h5plist);			checkH5Err(H5Pset_layout(h5plist, H5D_CONTIGUOUS));			checkH5Err(H5Pset_alloc_time(h5plist, H5D_ALLOC_TIME_EARLY));			m_h5data[odd][i] = H5Dcreate(h5file, VAR_NAMES[i], H5T_IEEE_F64LE, m_h5fSpaceData,				H5P_DEFAULT, h5plist, H5P_DEFAULT);			checkH5Err(m_h5data[odd][i]);			checkH5Err(H5Pclose(h5plist));		}	}	return h5file;}

hdf5attribute::hdf5attribute(hdf5dataset& hdataset, const std::string& name){	_attribute_id = H5Aopen(hdataset.handle(), name.c_str(), H5P_DEFAULT);	if(_attribute_id < 0)		throw std::runtime_error("Failed to open attribute (" + name + ") in dataset (" + "not available" + ") file (" + "not available" + ")");	_type_id = H5Aget_type(_attribute_id);}

/*-------------------------------------------------------------*/static void validateFloat3Attribute(pNXVcontext self,	hid_t dpField, char *name){	hid_t attID, attType, attSpace;	H5T_class_t h5class;	hsize_t dims[2], maxDims[2];	char fname[512];	memset(fname,0,sizeof(fname));	H5Iget_name(dpField,fname,sizeof(fname));	if(!H5LTfind_attribute(dpField,name)){			NXVsetLog(self,"sev","error");			NXVprintLog(self,"message",				"Missing attribute %s on %s",				name, fname);			NXVlog(self);			self->errCount++;	} else {		attID = H5Aopen(dpField,name,H5P_DEFAULT);		assert(attID >= 0);		attType = H5Aget_type(attID);		assert(attType >= 0);		h5class = H5Tget_class(attType);		if(h5class != H5T_FLOAT){			NXVsetLog(self,"sev","error");			NXVprintLog(self,"message",				"%s attribute on %s is of wrong type, expected float",				name, fname);			NXVlog(self);			self->errCount++;		} else {			attSpace = H5Aget_space(attID);			if(H5Sget_simple_extent_ndims(attSpace) != 1){				NXVsetLog(self,"sev","error");				NXVprintLog(self,"message",					"%s attribute on %s is of wrong rank, expected 1",					name, fname);				NXVlog(self);				self->errCount++;			} else {				H5Sget_simple_extent_dims(attSpace,dims,maxDims);				if(dims[0] != 3){					NXVsetLog(self,"sev","error");					NXVprintLog(self,"message",						"%s attribute on %s is of wrong size, expected 3",						name, fname);					NXVlog(self);					self->errCount++;				}			}			H5Sclose(attSpace);		}		H5Tclose(attType);		H5Aclose(attID);	}}

/*--------------------------------------------------------------	This validates the lesser depends_on chain fields like	vector, offset and transformation_type----------------------------------------------------------------*/static void validateDependsOnAttributes(pNXVcontext self,hid_t dpField){	char fname[512], transData[512];	hid_t attID, attType, attSpace;	H5T_class_t h5class;	memset(fname,0,sizeof(fname));	memset(transData,0,sizeof(transData));	H5Iget_name(dpField,fname,sizeof(fname));	/*		deal with transformation_type	*/	if(!H5LTfind_attribute(dpField,"transformation_type")){			NXVsetLog(self,"sev","error");			NXVprintLog(self,"message",				"Missing attribute transformation_type on %s",				fname);			NXVlog(self);			self->errCount++;	} else {		attID = H5Aopen(dpField,"transformation_type",H5P_DEFAULT);		assert(attID >= 0);		attType = H5Aget_type(attID);		assert(attType >= 0);		h5class = H5Tget_class(attType);		if(h5class != H5T_STRING){			NXVsetLog(self,"sev","error");			NXVprintLog(self,"message",				"transformation_type on %s is of wrong type, expected string",				fname);			NXVlog(self);			self->errCount++;		} else {			H5NXget_attribute_string(self->fileID, fname,					"transformation_type",transData);			if(strcmp(transData,"translation") != 0				&& strcmp(transData,"rotation") != 0){					NXVsetLog(self,"sev","error");					NXVprintLog(self,"message",						"transformation_type on %s contains bad data: %s",						fname,						"expected rotation or translation");					NXVlog(self);					self->errCount++;				}		}		H5Tclose(attType);		H5Aclose(attID);	}	validateFloat3Attribute(self,dpField,"offset");	validateFloat3Attribute(self,dpField,"vector");}

bool seissol::checkpoint::h5::Wavefield::validate(hid_t h5file) const{	// Turn of error printing	H5ErrHandler errHandler;	// Check #partitions	hid_t h5attr = H5Aopen(h5file, "partitions", H5P_DEFAULT);	if (h5attr < 0) {		logWarning(rank()) << "Checkpoint does not have a partition attribute.";		return false;	}	int p;	herr_t err = H5Aread(h5attr, H5T_NATIVE_INT, &p);	checkH5Err(H5Aclose(h5attr));	if (err < 0 || p != partitions()) {		logWarning(rank()) << "Partitions in checkpoint do not match.";		return false;	}	// Check dimensions	hid_t h5data = H5Dopen(h5file, "values", H5P_DEFAULT);	if (h5data < 0) {		logWarning(rank()) << "Checkpoint does not contains a data array.";		return false;	}	hid_t h5space = H5Dget_space(h5data);	checkH5Err(H5Dclose(h5data));	if (h5space < 0) {		logWarning(rank()) << "Could not get space identifier in checkpoint.";		return false;	}	bool isValid = true;	int dims = H5Sget_simple_extent_ndims(h5space);	if (dims != 1) {		isValid = false;		logWarning(rank()) << "Number of dimensions in checkpoint does not match.";	} else {		hsize_t dimSize;		if (H5Sget_simple_extent_dims(h5space, &dimSize, 0L) != 1) {			isValid = false;			logWarning(rank()) << "Could not get dimension sizes of checkpoint.";		} else {			if (dimSize != numTotalElems()) {				isValid = false;				logWarning(rank()) << "Number of elements in checkpoint does not match.";			}		}	}	checkH5Err(H5Sclose(h5space));	return isValid;}

void HDF5Attribute::open(const HDF5Id location_id, const String &name){    if (isValid()) {        THROW(Iex::IoExc, "Tried to open attribute that has already "                          "been opened or created");    }        m_id = H5Aopen(location_id, name.c_str(), H5P_DEFAULT);}

H5Attribute::H5Attribute(H5Object & _parent, const std::string & _name) : H5Object(_parent, _name){    if (H5Aexists(getParent().getH5Id(), name.c_str()) <= 0)    {        throw H5Exception(__LINE__, __FILE__, _("Cannot open attribute: %s"), name.c_str());    }    attr = H5Aopen(getParent().getH5Id(), name.c_str(), H5P_DEFAULT);    if (attr < 0)    {        throw H5Exception(__LINE__, __FILE__, _("Cannot open attribute: %s"), name.c_str());    }}

//--------------------------------------------------------------------------// Function:	H5Object::openAttribute////brief	Opens an attribute given its name.////param	name - IN: Name of the attribute////return	Attribute instance////exception	H5::AttributeIException// Programmer	Binh-Minh Ribler - 2000//--------------------------------------------------------------------------Attribute H5Object::openAttribute( const char* name ) const{   hid_t attr_id = H5Aopen(getId(), name, H5P_DEFAULT);   if( attr_id > 0 )   {      Attribute attr( attr_id );      return( attr );   }   else   {      throw AttributeIException(inMemFunc("openAttribute"), "H5Aopen failed");   }}

voidReadStringsT( hid_t iParent,              const std::string &iAttrName,              size_t iNumStrings,              StringT *oStrings ){    ABCA_ASSERT( iParent >= 0, "Invalid parent in ReadStringsT" );    // Open the attribute.    hid_t attrId = H5Aopen( iParent, iAttrName.c_str(), H5P_DEFAULT );    ABCA_ASSERT( attrId >= 0,                 "Couldn't open attribute named: " << iAttrName );    AttrCloser attrCloser( attrId );    // Checking code.    {        hid_t attrFtype = H5Aget_type( attrId );        DtypeCloser dtypeCloser( attrFtype );        hid_t nativeDtype = GetNativeDtype<CharT>();        ABCA_ASSERT( H5Tget_class( attrFtype ) ==                     H5Tget_class( nativeDtype ) &&                     H5Tget_sign( attrFtype ) ==                     H5Tget_sign( nativeDtype ),                     "Invalid datatype for stringT" );    }    hid_t attrSpace = H5Aget_space( attrId );    ABCA_ASSERT( attrSpace >= 0,                 "Couldn't get dataspace for attribute: " << iAttrName );    DspaceCloser dspaceCloser( attrSpace );    hssize_t numPoints = H5Sget_simple_extent_npoints( attrSpace );    ABCA_ASSERT( numPoints > 0,                 "Degenerate string dimensions in ReadStringsT" );    // Create temporary char storage buffer.    std::vector<CharT> charStorage( ( size_t )( 1 + numPoints ),                                    ( CharT )0 );    // Read into it.    herr_t status = H5Aread( attrId, GetNativeDtype<CharT>(),                             ( void * )&charStorage.front() );    ABCA_ASSERT( status >= 0, "Couldn't read from attribute: " << iAttrName );    // Extract 'em.    ExtractStrings( oStrings, ( const CharT * )&charStorage.front(),                    1 + numPoints, iNumStrings );}

int hdf5_read(void *output, hid_t file, char *n_group, char *n_dset, char *n_attr, int c){    hid_t memtype, type, group=-1, dset=-1, attr=-1, tmp_id, space;    herr_t status;    size_t sdim;    int ndims;        tmp_id = file;    if(strlen(n_group)>0){        group = H5Gopen(tmp_id, n_group, H5P_DEFAULT);        tmp_id = group;    }    if(strlen(n_dset)>0){        dset = H5Dopen(tmp_id, n_dset, H5P_DEFAULT);        tmp_id = dset;    }    if(strlen(n_attr)>0){        attr = H5Aopen(tmp_id, n_attr, H5P_DEFAULT);        tmp_id = attr;    }        if(c == 'c'){        memtype = H5Tcopy (H5T_C_S1);        type = H5Aget_type (tmp_id);        sdim = H5Tget_size (type);        sdim++;        status = H5Tset_size (memtype, sdim);    }    else if(c == 'd'){        memtype = H5T_NATIVE_DOUBLE;    }    else if(c == 'i' || c == 'n'){        memtype = H5T_NATIVE_INT;    }    else if(c == 'f'){        memtype = H5T_NATIVE_FLOAT;    }        if (tmp_id == attr){        status = H5Aread(tmp_id, memtype, output);    }    else if(tmp_id == dset && c == 'n'){        space = H5Dget_space (dset);        ndims = H5Sget_simple_extent_dims (space, output, NULL);    }    else{        return(-1);    }        return(1);}

estatus_te5_read_attr_list(    hid_t e5_group_id, e5_attr* e5_attr_list){    int i;    estatus_t status = E5_SUCCESS;    hid_t h5_type;    hid_t h5_native_type;    hid_t h5_space;    hid_t e5_attribute_id;    for(i = 0; e5_attr_list && e5_attr_list[i].name != 0; i++)    {        e5_attr *attr = &e5_attr_list[i];        if(attr->name == 0 || strlen(attr->name) < 1)            continue;        e5_info(e5_group_id, "Reading attribute [name='%s']/n", attr->name);        if(H5Aexists(e5_group_id, attr->name) <= 0)        {            status = E5_INVALID_ATTRIBUTE;            e5_error(e5_group_id, status, "Invalid name requested for attribute [type='%d', name='%s', value='%p']/n",  attr->type, attr->name, attr->value);            continue;        }        e5_attribute_id = H5Aopen(e5_group_id, attr->name, H5P_DEFAULT);        h5_type = H5Aget_type(e5_attribute_id);        h5_space = H5Aget_space(e5_attribute_id);        h5_native_type = e5_get_native_h5_type(h5_type);        attr->type = e5_convert_hdf_type(h5_type);        if(e5_is_valid_type(attr->type) != E5_TRUE)        {            status = E5_INVALID_TYPE;            e5_error(e5_group_id, status, "Invalid type requested for attribute [type='%d', name='%s', value='%p']/n",  attr->type, attr->name, attr->value);            continue;        }        H5Aread(e5_attribute_id, h5_native_type, attr->value);        H5Aclose(e5_attribute_id);        e5_info(e5_group_id, "Read attribute [type='%s', name='%s', value='%p']/n",            e5_typename(attr->type), attr->name, attr->value);    }    return status;}

//-*****************************************************************************voidReadTimeSamples( hid_t iParent,                 std::vector <  AbcA::TimeSamplingPtr > & oTimeSamples ){    oTimeSamples.clear();    // add the intrinsic default sampling    AbcA::TimeSamplingPtr ts( new AbcA::TimeSampling() );    oTimeSamples.push_back( ts );    uint32_t i = 1;    AbcA::TimeSamplingType tst;    std::string tstname = "1";    // keep trying to read till we can't find anymore    while ( ReadTimeSamplingType( iParent, tstname, tst ) )    {        // try to open the time samples attribute        std::string timeName = tstname + ".time";        hid_t aid = H5Aopen( iParent, timeName.c_str(), H5P_DEFAULT );        ABCA_ASSERT( aid >= 0,                     "Couldn't open time samples named: " << timeName );        AttrCloser attrCloser( aid );        // figure out how big it is        hid_t sid = H5Aget_space( aid );        ABCA_ASSERT( sid >= 0,                     "Couldn't get dataspace for time samples: " << timeName );        DspaceCloser dspaceCloser( sid );        hssize_t numPoints = H5Sget_simple_extent_npoints( sid );        ABCA_ASSERT( numPoints > 0, "No time samples data: " << timeName );        std::vector < chrono_t > times(numPoints);        // do the read        herr_t status = H5Aread( aid, H5T_NATIVE_DOUBLE, &(times.front()) );        ABCA_ASSERT( status >= 0, "Can't read time samples: " << timeName );        // create the TimeSampling and add it to our vector        ts.reset( new AbcA::TimeSampling(tst, times) );        oTimeSamples.push_back( ts );        // increment to try and read the next one        i++;        std::stringstream strm;        strm << i;        tstname = strm.str();    }}

void seissol::checkpoint::h5::Fault::load(int &timestepFault){	if (numSides() == 0)		return;	logInfo(rank()) << "Loading fault checkpoint";	seissol::checkpoint::CheckPoint::load();	hid_t h5file = open(linkFile());	checkH5Err(h5file);	// Attributes	hid_t h5attr = H5Aopen(h5file, "timestep_fault", H5P_DEFAULT);	checkH5Err(h5attr);	checkH5Err(H5Aread(h5attr, H5T_NATIVE_INT, &timestepFault));	checkH5Err(H5Aclose(h5attr));	// Set the memory space (this is the same for all variables)	hsize_t count[2] = {numSides(), numBndGP()};	hid_t h5memSpace = H5Screate_simple(2, count, 0L);	checkH5Err(h5memSpace);	checkH5Err(H5Sselect_all(h5memSpace));	// Offset for the file space	hsize_t fStart[2] = {fileOffset(), 0};	// Read the data	for (unsigned int i = 0; i < NUM_VARIABLES; i++) {		hid_t h5data = H5Dopen(h5file, VAR_NAMES[i], H5P_DEFAULT);		checkH5Err(h5data);		hid_t h5fSpace = H5Dget_space(h5data);		checkH5Err(h5fSpace);		// Read the data		checkH5Err(H5Sselect_hyperslab(h5fSpace, H5S_SELECT_SET, fStart, 0L, count, 0L));		checkH5Err(H5Dread(h5data, H5T_NATIVE_DOUBLE, h5memSpace, h5fSpace,				h5XferList(), data(i)));		checkH5Err(H5Sclose(h5fSpace));		checkH5Err(H5Dclose(h5data));	}	checkH5Err(H5Sclose(h5memSpace));	checkH5Err(H5Fclose(h5file));}

voidReadStringT<std::string,char>( hid_t iParent,                               const std::string &iAttrName,                               std::string &oString ){    ABCA_ASSERT( iParent >= 0, "Invalid parent in ReadStringT" );    // Open the attribute.    hid_t attrId = H5Aopen( iParent, iAttrName.c_str(), H5P_DEFAULT );    ABCA_ASSERT( attrId >= 0,                 "Couldn't open attribute named: " << iAttrName );    AttrCloser attrCloser( attrId );    // Checking code.    hid_t attrFtype = H5Aget_type( attrId );    DtypeCloser dtypeCloser( attrFtype );    ssize_t numChars = H5Tget_size( attrFtype );    ABCA_ASSERT( numChars >= 0,                 "ReadStringT() H5Aget_size() failed" );    // Read and check space    {        hid_t attrSpace = H5Aget_space( attrId );        ABCA_ASSERT( attrSpace >= 0,                     "Couldn't get dataspace for attribute: " << iAttrName );        DspaceCloser dspaceCloser( attrSpace );                H5S_class_t attrSpaceClass = H5Sget_simple_extent_type( attrSpace );        ABCA_ASSERT( attrSpaceClass == H5S_SCALAR,                     "Tried to read non-scalar attribute: " << iAttrName                     << " as scalar" );    }    // Create temporary char storage buffer.    std::vector<char> charStorage( ( size_t )( 1 + numChars ),                                   ( char )0 );    // Read into it.    herr_t status = H5Aread( attrId, attrFtype,                             ( void * )&charStorage.front() );    ABCA_ASSERT( status >= 0, "Couldn't read from attribute: " << iAttrName );    // Return it.    oString = ( const char * )&charStorage.front();}

bool Hdf5Dataset::open(){  const char *filepath = this->path_.c_str();  const char *name = this->filename_.c_str();  char fullpath[100];  strcpy(fullpath, filepath);  strcat(fullpath, name);  ROS_INFO("Opening map %s", this->filename_.c_str());  this->file_ = H5Fopen(fullpath,  H5F_ACC_RDONLY, H5P_DEFAULT);  this->group_poses_ = H5Gopen(this->file_, "/Poses", H5P_DEFAULT);  this->poses_dataset_ = H5Dopen(this->group_poses_, "poses_dataset", H5P_DEFAULT);  this->group_spheres_ = H5Gopen(this->file_, "/Spheres", H5P_DEFAULT);  this->sphere_dataset_ = H5Dopen(this->group_spheres_, "sphere_dataset", H5P_DEFAULT);  this->attr_ = H5Aopen(this->sphere_dataset_, "Resolution", H5P_DEFAULT);  herr_t ret = H5Aread(this->attr_, H5T_NATIVE_FLOAT, &this->res_);}

/* * Class:     hdf_hdf5lib_H5 * Method:    _H5Aopen * Signature: (JLjava/lang/String;J)J */JNIEXPORT jlong JNICALLJava_hdf_hdf5lib_H5__1H5Aopen    (JNIEnv *env, jclass clss, jlong obj_id, jstring name, jlong access_plist){    hid_t       retVal = -1;    const char *aName;    PIN_JAVA_STRING(name, aName);    if (aName != NULL) {        retVal = H5Aopen((hid_t)obj_id, aName, (hid_t)access_plist);        UNPIN_JAVA_STRING(name, aName);        if (retVal < 0)            h5libraryError(env);    }    return (jlong)retVal;} /* end Java_hdf_hdf5lib_H5__1H5Aopen */

 void DCAttribute::readAttribute(const char* name, hid_t parent, void* dst) throw (DCException) {     hid_t attr = H5Aopen(parent, name, H5P_DEFAULT);     if (attr < 0)         throw DCException(getExceptionString(name, "Attribute could not be opened for reading"));          hid_t attr_type = H5Aget_type(attr);     if (attr_type < 0)     {         H5Aclose(attr);         throw DCException(getExceptionString(name, "Could not get type of attribute"));     }          if (H5Aread(attr, attr_type, dst) < 0)     {         H5Aclose(attr);         throw DCException(getExceptionString(name, "Attribute could not be read"));     }          H5Aclose(attr); }

// from scrappiefloat fast5_read_float_attribute(hid_t group, const char *attribute) {    float val = NAN;    if (group < 0) {#ifdef DEBUG_FAST5_IO        fprintf(stderr, "Invalid group passed to %s:%d.", __FILE__, __LINE__);#endif        return val;    }    hid_t attr = H5Aopen(group, attribute, H5P_DEFAULT);    if (attr < 0) {#ifdef DEBUG_FAST5_IO        fprintf(stderr, "Failed to open attribute '%s' for reading.", attribute);#endif        return val;    }    H5Aread(attr, H5T_NATIVE_FLOAT, &val);    H5Aclose(attr);    return val;}

 /// Return the attribute name of obj, and "" if the attribute does not exist. void h5_read_attribute(hid_t id, std::string const &name, std::string & s) {  s = "";  // if the attribute is not present, return 0  if (H5LTfind_attribute(id, name.c_str()) == 0) return; // not present  attribute attr = H5Aopen(id, name.c_str(), H5P_DEFAULT);  if (!attr.is_valid()) TRIQS_RUNTIME_ERROR << "Cannot open the attribute " << name;  dataspace space = H5Aget_space(attr);  int rank = H5Sget_simple_extent_ndims(space);  if (rank != 0) TRIQS_RUNTIME_ERROR << "Reading a string attribute and got rank !=0";  datatype strdatatype = H5Aget_type(attr);  std::vector<char> buf(H5Aget_storage_size(attr) + 1, 0x00);  auto err = H5Aread(attr, strdatatype, (void *)(&buf[0]));  if (err < 0) TRIQS_RUNTIME_ERROR << "Cannot read the attribute " << name;  s.append(&(buf.front())); }