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;
}
DataSet DataSet::create(const H5::CommonFG &parent,
const std::string &name,
const H5::DataType &fileType,
const NDSize &size,
const NDSize &maxsize,
const NDSize &chunks,
bool max_size_unlimited,
bool guess_chunks)
{
H5::DataSpace space;
if (size) {
if (maxsize) {
space = DataSpace::create(size, maxsize);
} else {
space = DataSpace::create(size, max_size_unlimited);
}
}
H5::DSetCreatPropList plcreate = H5::DSetCreatPropList::DEFAULT;
if (chunks) {
int rank = static_cast<int>(chunks.size());
plcreate.setChunk(rank, chunks.data());
} else if (guess_chunks) {
NDSize guessedChunks = DataSet::guessChunking(size, fileType.getSize());
plcreate.setChunk(static_cast<int>(guessedChunks.size()), guessedChunks.data());
}
H5::DataSet dset = parent.createDataSet(name, fileType, space);
return DataSet(dset);
}
std::string hdfutil::ReadString (const H5::CommonFG& group, const std::string & dsname) {
const H5::DataSet & dataset = group.openDataSet(dsname);
try {
H5::DataType type = dataset.getDataType();
std::string retval;
retval.resize(type.getSize());
dataset.read(&retval[0], dataset.getStrType());
return retval;
} catch (H5::Exception e) {
std::string error = "Unable to ReadString.";// + dsname;
throw std::runtime_error(error.c_str());
}
}
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;
}
void ossim_hdf5::printAttribute( const H5::Attribute& attr,
const std::string& prefix,
std::ostream& out )
{
std::string name = attr.getName();
H5::DataType type = attr.getDataType();
H5T_class_t typeClass = attr.getTypeClass();
size_t size = type.getSize();
std::string value; // Initialized below.
if ( ( typeClass == H5T_INTEGER ) || ( typeClass == H5T_FLOAT ) )
{
H5::IntType intType = attr.getIntType();
ossimScalarType scalar = ossim_hdf5::getScalarType( intType.getId() );
ossimByteOrder order = ossim_hdf5::getByteOrder( &attr );
ossimEndian* endian = 0;
if ( ( size > 1 ) && ( order != ossim::byteOrder() ) )
{
endian = new ossimEndian(); // If set used as flag to byte swap.
}
if ( typeClass == H5T_INTEGER )
{
switch ( scalar )
{
case OSSIM_UINT8:
{
if ( size == 1 )
{
ossim_uint8 i;
attr.read( type, (void*)&i );
value = ossimString::toString( ossim_int32(i) ).string();
}
break;
}
case OSSIM_SINT8:
{
if ( size == 1 )
{
ossim_sint8 i;
attr.read( type, (void*)&i );
value = ossimString::toString( ossim_int32(i) ).string();
}
break;
}
case OSSIM_UINT16:
{
if ( size == 2 )
{
ossim_uint16 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_SINT16:
{
if ( size == 2 )
{
ossim_sint16 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_UINT32:
{
if ( size == 4 )
{
ossim_uint32 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_SINT32:
{
if ( size == 4 )
{
ossim_sint32 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_UINT64:
{
if ( size == 8 )
{
ossim_uint64 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_SINT64:
{
if ( size == 8 )
{
ossim_sint32 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
default:
break;
}
}
else if ( typeClass == H5T_FLOAT )
{
if ( scalar == OSSIM_FLOAT32 )
{
if ( size == 4 )
{
ossim_float32 f;
attr.read( type, (void*)&f );
if ( endian )
{
endian->swap( f );
}
value = ossimString::toString( f ).string();
}
}
if ( scalar == OSSIM_FLOAT64 )
{
if ( size == 8 )
{
ossim_float64 f;
attr.read( type, (void*)&f );
if ( endian )
{
endian->swap( f );
}
value = ossimString::toString( f ).string();
}
}
}
if ( endian )
{
delete endian;
endian = 0;
}
}
else if ( typeClass == H5T_STRING )
{
attr.read( type, value );
}
else
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimH5Util::printAttribute WARN: Unhandled type class: " << typeClass
<< std::endl;
}
out << prefix << "." << name << ": " << value << std::endl;
} // End: ossim_hdf5::printAttribute
