// JRC: This fat interface may not scale? What about // scalar attributes? herr_t VsH5Attribute::getDoubleVectorValue(std::vector<double>* dvals) { herr_t err = 0; size_t npoints; hid_t atype = H5Aget_type(getId()); H5T_class_t type = H5Tget_class(atype); hid_t aspace = H5Aget_space(getId()); size_t rank = H5Sget_simple_extent_ndims(aspace); if (type != H5T_FLOAT) { VsLog::warningLog() <<"VsH5Attribute::getDoubleVectorValue() - Requested attribute " <<getShortName() <<" is not a floating point vector." <<std::endl; dvals->resize(0); return -1; } if (rank == 0) { dvals->resize(1); double v; err = H5Aread(getId(), H5T_NATIVE_DOUBLE, &v); (*dvals)[0] = v; return err; } // rank>0 npoints = H5Sget_simple_extent_npoints(aspace); double* v = new double[npoints]; err = H5Aread(getId(), H5T_NATIVE_DOUBLE, v); dvals->resize(npoints); for (size_t i = 0; i<npoints; ++i) { (*dvals)[i] = v[i]; } delete [] v; return err; }
int AMRreader:: getIntfInfo( hid_t gid ) { hid_t aid = H5Aopen_name( gid, intf_np_name ); if( aid<0 ) { nvert_=0; debug1 << "Failed to find number of interface points.\n"; return -1; } else { H5Aread( aid, H5T_NATIVE_INT, &nvert_ ); H5Aclose(aid); } debug2 << "nvert is " << nvert_ << "\n"; aid = H5Aopen_name( gid, intf_ne_name ); if( aid<0 ) { nrect_=0; debug1 << "Failed to find number of interface elements.\n"; return -2; } else { H5Aread( aid, H5T_NATIVE_INT, &nrect_ ); H5Aclose(aid); } debug2 << "nrect is " << nrect_ << "\n"; return 0; }
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); }
/* Read and verify attribute for group or dataset. */ int read_attribute(hid_t obj_id, int this_type, int num) { hid_t aid; hsize_t group_block[2]={1,1}, dset_block[2]={1, 8}; int i, mpi_rank, in_num, in_data[8], out_data[8], vrfy_errors = 0; char attr_name[32]; MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); if(this_type == is_group) { sprintf(attr_name, "Group Attribute %d", num); aid = H5Aopen_name(obj_id, attr_name); if(MAINPROCESS) { H5Aread(aid, H5T_NATIVE_INT, &in_num); vrfy_errors = dataset_vrfy(NULL, NULL, NULL, group_block, &in_num, &num); } H5Aclose(aid); } else if(this_type == is_dset) { sprintf(attr_name, "Dataset Attribute %d", num); for(i=0; i<8; i++) out_data[i] = i; aid = H5Aopen_name(obj_id, attr_name); if(MAINPROCESS) { H5Aread(aid, H5T_NATIVE_INT, in_data); vrfy_errors = dataset_vrfy(NULL, NULL, NULL, dset_block, in_data, out_data); } H5Aclose(aid); } return vrfy_errors; }
herr_t attribute_read(char *attribute_name, enum my_hdf5_types hdf5_type, hid_t hdf5_file_handle, void *buf) { hid_t hdf5_attribute_id, hdf5_dataspace, hdf5_datatype; herr_t hdf5_status = 0; //here we get an identifier for a datatype switch (hdf5_type) { case my_hdf5_int: hdf5_datatype = H5Tcopy(H5T_NATIVE_INT); break; case my_hdf5_long: hdf5_datatype = H5Tcopy(H5T_NATIVE_LONG); break; case my_hdf5_float: hdf5_datatype = H5Tcopy(H5T_NATIVE_FLOAT); break; case my_hdf5_double: hdf5_datatype = H5Tcopy(H5T_NATIVE_DOUBLE); break; default: exit(-1); break; } hdf5_dataspace = H5Screate(H5S_SCALAR); hdf5_attribute_id = H5Acreate(hdf5_file_handle, attribute_name, hdf5_datatype, hdf5_dataspace, H5P_DEFAULT); //here we 'create' an attribute switch (hdf5_type) { case my_hdf5_int: hdf5_status = H5Aread(hdf5_attribute_id, hdf5_datatype, (int *) buf); break; case my_hdf5_long: hdf5_status = H5Aread(hdf5_attribute_id, hdf5_datatype, (long *) buf); break; case my_hdf5_float: hdf5_status = H5Aread(hdf5_attribute_id, hdf5_datatype, (float *) buf); break; case my_hdf5_double: hdf5_status = H5Aread(hdf5_attribute_id, hdf5_datatype, (double *) buf); break; default: exit(-1); break; } H5Tclose(hdf5_datatype); H5Aclose(hdf5_attribute_id); H5Sclose(hdf5_dataspace); return hdf5_status; }
void AbstractHdf5Access::SetUnlimitedDatasetId() { // Now deal with the unlimited dimension // In terms of an Unlimited dimension dataset: // * Files pre - r16738 (inc. Release 3.1 and earlier) use simply "Time" for "Data"'s unlimited variable. // * Files generated by r16738 - r18257 used "<DatasetName>_Time" for "<DatasetName>"'s unlimited variable, // - These are not to be used and there is no backwards compatibility for them, since they weren't in a release. // * Files post r18257 (inc. Release 3.2 onwards) use "<DatasetName>_Unlimited" for "<DatasetName>"'s // unlimited variable, // - a new attribute "Name" has been added to the Unlimited Dataset to allow it to assign // any name to the unlimited variable. Which can then be easily read by Hdf5DataReader. // - if this dataset is missing we look for simply "Time" to remain backwards compatible with Releases <= 3.1 if (DoesDatasetExist(mDatasetName + "_Unlimited")) { mUnlimitedDatasetId = H5Dopen(mFileId, (mDatasetName + "_Unlimited").c_str()); hid_t name_attribute_id = H5Aopen_name(mUnlimitedDatasetId, "Name"); hid_t unit_attribute_id = H5Aopen_name(mUnlimitedDatasetId, "Unit"); hid_t attribute_type = H5Aget_type(name_attribute_id); // Read into it. char* string_array = (char *)malloc(sizeof(char)*MAX_STRING_SIZE); H5Aread( name_attribute_id, attribute_type, string_array); std::string name_string(&string_array[0]); mUnlimitedDimensionName = name_string; H5Aread( unit_attribute_id, attribute_type, string_array); std::string unit_string(&string_array[0]); mUnlimitedDimensionUnit = unit_string; free(string_array); H5Tclose(attribute_type); H5Aclose(name_attribute_id); H5Aclose(unit_attribute_id); } else if (DoesDatasetExist("Time")) { mUnlimitedDimensionName = "Time"; mUnlimitedDimensionUnit = "msec"; mUnlimitedDatasetId = H5Dopen(mFileId, mUnlimitedDimensionName.c_str()); } else { NEVER_REACHED; } mIsUnlimitedDimensionSet = true; }
char HIntAttribute::read(int *data) { herr_t status = H5Aread(fObjectId, dataType(), data); if(status < 0) return 0; return 1; }
static herr_t get_attribute_mem(hid_t obj_id, const char *attr_name, hid_t mem_type_id, void *data) { hid_t attr_id; herr_t status; attr_id = H5Aopen_name(obj_id, attr_name); if (attr_id < 0) return -1; status = H5Aread(attr_id, mem_type_id, data); if (status < 0) { H5Aclose(attr_id); return -1; } status = H5Aclose(attr_id); if (status < 0) return -1; return 0; }
static herr_t get_attribute_disk(hid_t loc_id, const char *attr_name, void *attr_out) { hid_t attr_id; hid_t attr_type; herr_t status; attr_id = H5Aopen_name(loc_id, attr_name); if (attr_id < 0) return -1; attr_type = H5Aget_type(attr_id); if (attr_type < 0) goto out; status = H5Aread(attr_id, attr_type, attr_out); if (status < 0) goto out; status = H5Tclose(attr_type); if (status < 0) goto out; status = H5Aclose(attr_id); if (status < 0) return -1; return 0; out: H5Tclose(attr_type); H5Aclose(attr_id); return -1; }
/* * Class: hdf_hdf5lib_H5 * Method: H5Aread * Signature: (JJ[B)I */ JNIEXPORT jint JNICALL Java_hdf_hdf5lib_H5_H5Aread (JNIEnv *env, jclass clss, jlong attr_id, jlong mem_type_id, jbyteArray buf) { herr_t status = -1; jbyte *byteP; jboolean isCopy; if (buf == NULL) { h5nullArgument( env,"H5Aread: buf is NULL"); } /* end if */ else { byteP = ENVPTR->GetByteArrayElements(ENVPAR buf, &isCopy); if (byteP == NULL) { h5JNIFatalError( env,"H5Aread: buf is not pinned"); } /* end if */ else { status = H5Aread((hid_t)attr_id, (hid_t)mem_type_id, byteP); if (status < 0) { ENVPTR->ReleaseByteArrayElements(ENVPAR buf, byteP, JNI_ABORT); h5libraryError(env); } /* end if */ else { ENVPTR->ReleaseByteArrayElements(ENVPAR buf, byteP, 0); } /* end else */ } /* end else */ } /* end else */ return (jint)status; } /* end Java_hdf_hdf5lib_H5_H5Aread */
// read a complex float attribute float_complex read_complex_attribute(hid_t loc_id, const char* path, const char* name) { float_complex value; float *buf; hid_t attr_id, real_type_id; ; hsize_t *dims; herr_t status; status = H5Aexists_by_name(loc_id, path, name, H5P_DEFAULT); if (status < 0) { printf("attribut %s does not exist \n", name); } real_type_id = create_real_type_id(); attr_id = H5Aopen_by_name(loc_id, path, name, H5P_DEFAULT, H5P_DEFAULT); status = H5Aread(attr_id, real_type_id, buf); if (status < 0) { printf("Can't read attribute : %s\n", name); } value.re = buf[0]; value.im=buf[1]; return value; }
/* read attribute value */ char* H5Dataset_read_attr_value(hid_t aid) { hid_t asid=-1, atid=-1; int i, rank; hsize_t *dims; size_t size=1; char *attr_buf=NULL; asid = H5Aget_space(aid); atid = H5Aget_type(aid); rank = H5Sget_simple_extent_ndims(asid); if (rank > 0) { dims = (hsize_t *)malloc(rank * sizeof(hsize_t)); H5Sget_simple_extent_dims(asid, dims, NULL); for (i=0; i<rank; i++) { size *= (size_t)dims[i]; free(dims); } size *= H5Tget_size(atid); attr_buf = (char *)malloc(size); if (H5Aread( aid, atid, attr_buf) < 0) { free(attr_buf); attr_buf = NULL; } } if( atid > 0) H5Tclose(atid); if (asid > 0) H5Sclose(asid); return attr_buf; }
inline typename boost::enable_if<boost::is_same<T, std::string>, T>::type read_attribute(H5::H5Object const& object, std::string const& name) { H5::Attribute attr; try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); attr = object.openAttribute(name); } catch (H5::AttributeIException const&) { throw; } if (!has_scalar_space(attr)) { throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace"); } H5::DataType tid = attr.getDataType(); std::string value; if (!tid.isVariableStr()) { // read fixed-size string, allocate space in advance and let the HDF5 // library take care about NULLTERM and NULLPAD strings value.resize(tid.getSize(), std::string::value_type()); attr.read(tid, &*value.begin()); } else { // read variable-length string, memory will be allocated by HDF5 C // library and must be freed by us char *c_str; if (H5Aread(attr.getId(), tid.getId(), &c_str) < 0) { throw H5::AttributeIException("Attribute::read", "H5Aread failed"); } value = c_str; // copy '\0'-terminated string free(c_str); } return value; }
estatus_t e5_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; }
static int readIntAttribute_v1(int _iDatasetId, const char *_pstName) { hid_t iAttributeId; herr_t status; hsize_t n = 0; int iVal = -1; if (H5Aiterate(_iDatasetId, H5_INDEX_NAME, H5_ITER_NATIVE, &n, find_attr_by_name_v1, (void *)_pstName) > 0) { iAttributeId = H5Aopen_by_name(_iDatasetId, ".", _pstName, H5P_DEFAULT, 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; }
// Read string attribute <attr_name> given by address <path> char AH5_read_str_attr(hid_t loc_id, const char *path, char *attr_name, char **rdata) { hid_t attr_id, filetype, memtype; size_t sdim; char success = AH5_FALSE; if (AH5_path_valid(loc_id, path) || strcmp(path, ".") == 0) if (H5Aexists_by_name(loc_id, path, attr_name, H5P_DEFAULT) > 0) { attr_id = H5Aopen_by_name(loc_id, path, attr_name, H5P_DEFAULT, H5P_DEFAULT); filetype = H5Aget_type(attr_id); sdim = H5Tget_size(filetype); sdim++; // make a space for null terminator *rdata = (char *) malloc(sdim * sizeof(char)); memtype = H5Tcopy(H5T_C_S1); H5Tset_size(memtype, sdim); if (H5Aread(attr_id, memtype, *rdata) >= 0) success = AH5_TRUE; else free(*rdata); H5Tclose(memtype); H5Tclose(filetype); H5Aclose(attr_id); } if (!success) *rdata = NULL; return success; }
estatus_t e5_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; }
bool read_attribute(const char * name, const H5ID & dataset, T & value) { H5ID attribute(H5Aopen_name(dataset, name), H5Aclose); if (!attribute) return false; herr_t status = H5Aread(attribute, H5T_NATIVE_FLOAT, &value); return status >= 0; }
void mhdf_getElemTypeName( mhdf_FileHandle file_handle, const char* elem_handle, char* buffer, size_t buf_len, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, type_id, attr_id; char bytes[16]; herr_t rval; API_BEGIN; if (NULL == buffer || buf_len < 2) { mhdf_setFail( status, "invalid input" ); return; } buffer[0] = '\0'; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return; elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status ); if (elem_id < 0) return; attr_id = H5Aopen_name( elem_id, ELEM_TYPE_ATTRIB ); H5Gclose( elem_id ); if (attr_id < 0) { mhdf_setFail( status, "Missing element type attribute. Invalid file." ); return; } type_id = H5Aget_type( attr_id ); assert( type_id > 0 ); rval = H5Aread( attr_id, type_id, bytes ); H5Aclose( attr_id ); if (rval < 0) { H5Tclose( type_id ); mhdf_setFail( status, "Failed to read element type attribute. Invalid file." ); return; } rval = H5Tenum_nameof( type_id, bytes, buffer, buf_len ); H5Tclose( type_id ); if (rval < 0) { mhdf_setFail( status, "Invalid datatype for element type attribute. Invalid file." ); return; } mhdf_setOkay( status ); API_END; return ; }
/* fetch num_cols and the col for a particular trackname */ void get_cols(chromosome_t *chromosome, char *trackname, hsize_t *num_cols, hsize_t *col) { hid_t attr, root, dataspace, datatype; hsize_t data_size, cell_size, num_cells; char *attr_data; /* Tracknames are stored in the attributes of the root group of each file */ root = H5Gopen(chromosome->h5group, "/", H5P_DEFAULT); assert(root >= 0); attr = H5Aopen_name(root, "tracknames"); assert(attr >= 0); dataspace = H5Aget_space(attr); assert(dataspace >= 0); assert(H5Sget_simple_extent_dims(dataspace, num_cols, NULL) == 1); assert(H5Sclose(dataspace) >= 0); if (trackname && col) { datatype = H5Aget_type(attr); assert(datatype >= 0); assert(H5Tget_class(datatype) == H5T_STRING); cell_size = H5Tget_size(datatype); assert(cell_size > 0); data_size = H5Aget_storage_size(attr); assert(data_size > 0); num_cells = data_size / cell_size; /* allocate room for tracknames */ attr_data = xmalloc(data_size); assert(attr_data); assert(H5Aread(attr, datatype, attr_data) >= 0); *col = 0; for (*col = 0; *col <= num_cells; (*col)++) { if (*col == num_cells) { fprintf(stderr, "can't find trackname: %s\n", trackname); free(attr_data); exit(EXIT_FAILURE); } else { if (!strncmp(attr_data + (*col * cell_size), trackname, cell_size)) { break; } } } /* clean up read tracknames */ free(attr_data); } assert(H5Aclose(attr) >= 0); }
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 compare_and_read_scalar_attribute_internal(hid_t attribute_id, hid_t type_id, hid_t expected_type, void* buffer) { if(H5Tequal(type_id, expected_type)) { herr_t status = H5Aread(attribute_id, type_id, buffer); if(status >= 0) return; } throw std::runtime_error("type mismatch"); }
void get_attr(hid_t loc, const char *name, hid_t mem_type_id, void *buf) { hid_t attr; attr = H5Aopen_name(loc, name); assert(attr >= 0); assert(H5Aread(attr, mem_type_id, buf) >= 0); assert(H5Aclose(attr) >= 0); }
static herr_t get_attribute_str(hid_t obj_id, const char *attr_name, char **data) { hid_t attr_id; hid_t attr_type; size_t type_size; herr_t status; *data = NULL; attr_id = H5Aopen_name(obj_id, attr_name); if (attr_id < 0) return -1; attr_type = H5Aget_type(attr_id); if (attr_type < 0) goto out; /* Get the size */ type_size = H5Tget_size(attr_type); if (type_size < 0) goto out; /* malloc enough space for the string, plus 1 for trailing '\0' */ *data = (char *)malloc(type_size + 1); status = H5Aread(attr_id, attr_type, *data); if (status < 0) goto out; /* Set the last character to '\0' in case we are dealing with * null padded or space padded strings */ (*data)[type_size] = '\0'; status = H5Tclose(attr_type); if (status < 0) goto out; status = H5Aclose(attr_id); if (status < 0) return -1; return 0; out: H5Tclose(attr_type); H5Aclose(attr_id); if (*data) free(*data); return -1; }
char HStringAttribute::read(std::string & str) { const int d = dataSpaceDimension(); char * t = new char[d + 1]; herr_t status = H5Aread(fObjectId, dataType(), t); if(status < 0) return 0; t[d] = '\0'; str = std::string(t); delete[] t; return 1; }
void ReadStringsT( 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); }
herr_t H5AreadVL_str (JNIEnv *env, hid_t aid, hid_t tid, jobjectArray buf) { char **strs; jstring jstr; jint i; jint n; hid_t sid; hsize_t dims[H5S_MAX_RANK]; herr_t status = -1; n = ENVPTR->GetArrayLength(ENVPAR buf); strs =(char**)HDcalloc((size_t)n, sizeof(char*)); if (strs == NULL) { h5JNIFatalError(env, "H5AreadVL_str: failed to allocate buff for read variable length strings"); } /* end if */ else { status = H5Aread(aid, tid, strs); if (status < 0) { dims[0] = (hsize_t)n; sid = H5Screate_simple(1, dims, NULL); H5Dvlen_reclaim(tid, sid, H5P_DEFAULT, strs); H5Sclose(sid); HDfree(strs); h5JNIFatalError(env, "H5AreadVL_str: failed to read variable length strings"); } /* end if */ else { for (i=0; i < n; i++) { jstr = ENVPTR->NewStringUTF(ENVPAR strs[i]); ENVPTR->SetObjectArrayElement(ENVPAR buf, i, jstr); H5free_memory (strs[i]); } /* end for */ /* for repeatedly reading a dataset with a large number of strs (e.g., 1,000,000 strings, H5Dvlen_reclaim() may crash on Windows because the Java GC will not be able to collect free space in time. Instead, use "H5free_memory(strs[i])" above to free individual strings after it is done. H5Dvlen_reclaim(tid, mem_sid, xfer_plist_id, strs); */ HDfree(strs); } /* end else */ } /* end else */ return status; } /* end H5AreadVL_str */
std::string HdfAttribute::readString() const { char name[HDF_MAX_NAME]; hid_t datatype = H5Tcopy( H5T_C_S1 ); H5Tset_size( datatype, HDF_MAX_NAME ); herr_t status = H5Aread( d->id, datatype, name ); if ( status < 0 ) { //MDAL::debug("Failed to read data!"); return std::string(); } H5Tclose( datatype ); return std::string( name ); }
/*---------------------------------------------------------------------------- * Name: h5aread_c * Purpose: Call H5Aread to read an attribute * Inputs: dset_id - dataset identifier * mem_type_id - memory datatype identifier * dims - array to store dimensions sizes of buf; used only * by Fortran routine. * Outputs: buf - data buffer * Returns: 0 on success, -1 on failure * Programmer: Elena Pourmal * Thursday, August 12, 1999 * Modifications: dims paramete added. * April 4, 2001 * Added nh5aread_integer(real,double)_s,1-7 functions to eliminate * complains about wrong parameters types in h5awrite_c function * called by Fortran routines. * October 9, 2006 EIP *---------------------------------------------------------------------------*/ int_f nh5aread_c (hid_t_f *attr_id, hid_t_f *mem_type_id, void *buf, void UNUSED * dims) { int_f ret_value=0; /* Return value */ /* * Call H5Aread function. */ if (H5Aread((hid_t)*attr_id, (hid_t)*mem_type_id, buf) < 0) HGOTO_DONE(FAIL); done: return ret_value; }