missing_placeholder.hpp

Go to the documentation of this file.

#ifndef RITSUKO_HDF5_MISSING_PLACEHOLDER_HPP
#define RITSUKO_HDF5_MISSING_PLACEHOLDER_HPP
 
#include "H5Cpp.h"
#include <string>
 
#include "as_numeric_datatype.hpp"
#include "load_attribute.hpp"
#include "validate_string.hpp"
#include "get_1d_length.hpp"
#include "get_name.hpp"
 
namespace ritsuko {
 
namespace hdf5 {
 
inline void check_numeric_missing_placeholder_attribute(const H5::DataSet& dset, const H5::Attribute& attr, bool type_class_only = false) {
    if (!is_scalar(attr)) {
        throw std::runtime_error("expected the '" + get_name(attr) + "' attribute to be a scalar");
    }
    if (type_class_only) {
        if (attr.getTypeClass() != dset.getTypeClass()) {
            throw std::runtime_error("expected the '" + get_name(attr) + "' attribute to have the same type class as its dataset");
        }
    } else {
        if (attr.getDataType() != dset.getDataType()) {
            throw std::runtime_error("expected the '" + get_name(attr) + "' attribute to have the same type as its dataset");
        }
    }
}
 
template<typename Type_>
std::optional<Type_> open_and_load_optional_numeric_missing_placeholder(const H5::DataSet& handle, const char* attr_name) {
    if (!handle.attrExists(attr_name)) {
        return {};
    }
    auto ahandle = handle.openAttribute(attr_name);
    check_numeric_missing_placeholder_attribute(handle, ahandle);
    Type_ value;
    ahandle.read(as_numeric_datatype<Type_>(), &value);
    return value;
}
 
namespace internal {
 
inline void check_string_missing_placeholder_attribute_preliminary(const H5::Attribute& attr) {
    if (!is_scalar(attr)) {
        throw std::runtime_error("expected the '" + get_name(attr) + "' attribute to be a scalar");
    }
    if (attr.getTypeClass() != H5T_STRING) {
        throw std::runtime_error("expected the '" + get_name(attr) + "' attribute to have a string datatype");
    }
}
 
}
inline void check_string_missing_placeholder_attribute(const H5::Attribute& attr) {
    internal::check_string_missing_placeholder_attribute_preliminary(attr);
    validate_scalar_string_attribute(attr);
}
 
inline std::optional<std::string> open_and_load_optional_string_missing_placeholder(const H5::DataSet& handle, const char* attr_name) {
    if (!handle.attrExists(attr_name)) {
        return {};
    }
    auto ahandle = handle.openAttribute(attr_name);
    internal::check_string_missing_placeholder_attribute_preliminary(ahandle);
    return load_scalar_string_attribute(ahandle);
}
 
}
 
}
 
#endif