inline typename boost::enable_if<boost::mpl::and_< is_vector<T> , boost::is_same<typename T::value_type, std::string> >, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T const& value) { size_t size = value.size(); // size of longest string size_t str_len = 0; for (size_t i = 0; i < size; ++i) { str_len = std::max(str_len, value[i].size()); } // remove attribute if it exists and re-create with proper String datatype // and simple dataspace if (exists_attribute(object, name)) { object.removeAttr(name); } hsize_t dim[1] = { size }; H5::DataSpace ds(1, dim); H5::StrType tid(H5::PredType::C_S1, str_len); H5::Attribute attr = object.createAttribute(name, tid, ds); // copy strings to contiguous buffer std::vector<char> buffer(size * str_len); for (size_t i = 0; i < size; ++i) { value[i].copy(buffer.data() + i * str_len, str_len); } attr.write(tid, &*buffer.begin()); }
inline typename boost::enable_if<boost::mpl::and_<is_array<T>, boost::is_same<typename T::value_type, char const*> >, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T const& value) { enum { size = T::static_size }; hsize_t dim[1] = { size }; H5::DataSpace ds(1, dim); size_t max_len = 0; for (size_t i = 0; i < size; ++i) { max_len = std::max(max_len, strlen(value[i])); } H5::StrType tid(H5::PredType::C_S1, max_len); // remove attribute if it exists try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); object.removeAttr(name); } catch (H5::AttributeIException const&) {} H5::Attribute attr = object.createAttribute(name, tid, ds); std::vector<char> data(max_len * size); for (size_t i = 0; i < size; ++i) { strncpy(&*data.begin() + i * max_len, value[i], max_len); } attr.write(tid, &*data.begin()); }
inline typename boost::enable_if<boost::is_same<T, char const*>, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T value) { H5::StrType tid(H5::PredType::C_S1, strlen(value)); // remove attribute if it exists try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); object.removeAttr(name); } catch (H5::AttributeIException const&) {} H5::Attribute attr = object.createAttribute(name, tid, H5S_SCALAR); attr.write(tid, value); }
inline typename boost::enable_if<boost::mpl::and_< is_vector<T>, boost::is_fundamental<typename T::value_type> >, T>::type read_attribute(H5::H5Object const& object, std::string const& name) { typedef typename T::value_type value_type; H5::Attribute attr; try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); attr = object.openAttribute(name); } catch (H5::AttributeIException const&) { throw; } H5::DataSpace ds(attr.getSpace()); if (!ds.isSimple()) { throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace"); } size_t size = ds.getSimpleExtentNpoints(); std::vector<value_type> value(size); attr.read(ctype<value_type>::hid(), &*value.begin()); return value; }
inline typename boost::enable_if<is_multi_array<T>, T>::type read_attribute(H5::H5Object const& object, std::string const& name) { typedef typename T::element value_type; enum { rank = T::dimensionality }; H5::Attribute attr; try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); attr = object.openAttribute(name); } catch (H5::AttributeIException const&) { throw; } H5::DataSpace ds(attr.getSpace()); if (!has_rank<rank>(attr)) { throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace"); } hsize_t dim[rank]; ds.getSimpleExtentDims(dim); boost::array<size_t, rank> shape; std::copy(dim, dim + rank, shape.begin()); boost::multi_array<value_type, rank> value(shape); attr.read(ctype<value_type>::hid(), value.origin()); return value; }
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; }
/** * determine whether attribute exists in file/group/dataset */ inline bool exists_attribute(H5::H5Object const& object, std::string const& name) { htri_t tri = H5Aexists(object.getId(), name.c_str()); if (tri < 0) { throw error("failed to determine whether attribute \"" + name + "\" exists"); } return (tri > 0); }
inline typename boost::enable_if<boost::is_fundamental<T>, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T const& value) { H5::Attribute attr; try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); attr = object.openAttribute(name); if (!has_type<T>(attr) || !has_scalar_space(attr)) { // recreate attribute with proper type object.removeAttr(name); throw H5::AttributeIException(); } } catch (H5::AttributeIException const&) { attr = object.createAttribute(name, ctype<T>::hid(), H5S_SCALAR); } attr.write(ctype<T>::hid(), &value); }
inline typename boost::enable_if<boost::mpl::and_<is_array<T>, boost::is_fundamental<typename T::value_type> >, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T const& value) { typedef typename T::value_type value_type; enum { size = T::static_size }; H5::Attribute attr; try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); attr = object.openAttribute(name); if (!has_type<T>(attr) || !has_extent<T>(attr)) { // recreate attribute with proper type and size object.removeAttr(name); throw H5::AttributeIException(); } } catch (H5::AttributeIException const&) { hsize_t dim[1] = { size }; H5::DataSpace ds(1, dim); attr = object.createAttribute(name, ctype<value_type>::hid(), ds); } attr.write(ctype<value_type>::hid(), &*value.begin()); }
inline typename boost::enable_if<is_multi_array<T>, void>::type write_attribute(H5::H5Object const& object, std::string const& name, T const& value) { typedef typename T::element value_type; enum { rank = T::dimensionality }; H5::Attribute attr; try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); attr = object.openAttribute(name); if (!has_type<T>(attr) || !has_extent<T>(attr, value.shape())) { // recreate attribute with proper type and size object.removeAttr(name); throw H5::AttributeIException(); } } catch (H5::AttributeIException const&) { hsize_t dim[rank]; std::copy(value.shape(), value.shape() + rank, dim); H5::DataSpace ds(rank, dim); attr = object.createAttribute(name, ctype<value_type>::hid(), ds); } attr.write(ctype<value_type>::hid(), value.origin()); }
void File::doAddAttribute(H5::H5Object&loc, std::string name, void*data) { double v; //hsize_t size; H5::Group *d = (H5::Group *)data; H5::Attribute a(loc.openAttribute(name)); //size = loc.getStorageSize(); //FIXME: double a.read( H5::PredType::NATIVE_DOUBLE, &v ); hsize_t dataSize = 1; H5::DataSpace spaceParameters(1,&dataSize,&dataSize); H5::Attribute b(d->createAttribute(name,H5::PredType::NATIVE_DOUBLE, spaceParameters)); b.write( H5::PredType::NATIVE_DOUBLE, &v ); }
inline typename boost::enable_if<boost::is_fundamental<T>, 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"); } T value; attr.read(ctype<T>::hid(), &value); return value; }
inline typename boost::enable_if<boost::mpl::and_< is_vector<T> , boost::is_same<typename T::value_type, 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; } H5::DataSpace ds(attr.getSpace()); if (!ds.isSimple()) { throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace"); } size_t size = ds.getSimpleExtentNpoints(); H5::DataType tid = attr.getDataType(); if (tid.isVariableStr()) { throw error("reading non-scalar attribute of variable-length strings not supported"); } size_t str_len = tid.getSize(); // read to contiguous buffer and copy to std::vector std::vector<char> buffer(str_len * size); attr.read(tid, &*buffer.begin()); T value; value.reserve(size); char const* s = buffer.data(); for (size_t i = 0; i < size; ++i, s += str_len) { size_t len = strnlen(s, str_len); // strings of str_len size are not '\0'-terminated value.push_back(std::string(s, len)); // copy len bytes from buffer } return value; }
inline typename boost::enable_if<boost::mpl::and_<is_array<T>, boost::is_fundamental<typename T::value_type> >, T>::type read_attribute(H5::H5Object const& object, std::string const& name) { typedef typename T::value_type value_type; enum { size = T::static_size }; H5::Attribute attr; try { H5XX_NO_AUTO_PRINT(H5::AttributeIException); attr = object.openAttribute(name); } catch (H5::AttributeIException const&) { throw; } if (!has_extent<T>(attr)) { throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace"); } T value; attr.read(ctype<value_type>::hid(), &*value.begin()); return value; }