H5DataType.hpp

Go to the documentation of this file.

/*
 *  Copyright (c), 2017, Adrien Devresse <adrien.devresse@epfl.ch>
 *
 *  Distributed under the Boost Software License, Version 1.0.
 *    (See accompanying file LICENSE_1_0.txt or copy at
 *          http://www.boost.org/LICENSE_1_0.txt)
 *
 */
#pragma once
 
#include <type_traits>
#include <vector>
 
#include <H5Tpublic.h>
 
#include "H5Object.hpp"
#include "bits/H5Utils.hpp"
 
#include "bits/string_padding.hpp"
#include "H5PropertyList.hpp"
 
#include "bits/h5_wrapper.hpp"
#include "bits/h5t_wrapper.hpp"
 
namespace HighFive {
 
 
enum class DataTypeClass {
    Time = 1 << 1,
    Integer = 1 << 2,
    Float = 1 << 3,
    String = 1 << 4,
    BitField = 1 << 5,
    Opaque = 1 << 6,
    Compound = 1 << 7,
    Reference = 1 << 8,
    Enum = 1 << 9,
    VarLen = 1 << 10,
    Array = 1 << 11,
    Invalid = 0
};
 
inline DataTypeClass operator|(DataTypeClass lhs, DataTypeClass rhs) {
    using T = std::underlying_type<DataTypeClass>::type;
    return static_cast<DataTypeClass>(static_cast<T>(lhs) | static_cast<T>(rhs));
}
 
inline DataTypeClass operator&(DataTypeClass lhs, DataTypeClass rhs) {
    using T = std::underlying_type<DataTypeClass>::type;
    return static_cast<DataTypeClass>(static_cast<T>(lhs) & static_cast<T>(rhs));
}
 
class StringType;
 
class DataType: public Object {
  public:
    bool operator==(const DataType& other) const;
 
    bool operator!=(const DataType& other) const;
 
    DataTypeClass getClass() const;
 
    size_t getSize() const;
 
    std::string string() const;
 
    bool isVariableStr() const;
 
    bool isFixedLenStr() const;
 
    StringType asStringType() const;
 
    bool empty() const noexcept;
 
    bool isReference() const;
 
    DataTypeCreateProps getCreatePropertyList() const {
        return details::get_plist<DataTypeCreateProps>(*this, H5Tget_create_plist);
    }
 
  protected:
    using Object::Object;
 
    friend class Attribute;
    friend class File;
    friend class DataSet;
    friend class CompoundType;
    template <typename Derivate>
    friend class NodeTraits;
};
 
 
enum class CharacterSet : std::underlying_type<H5T_cset_t>::type {
    Ascii = H5T_CSET_ASCII,
    Utf8 = H5T_CSET_UTF8,
};
 
class StringType: public DataType {
  public:
    CharacterSet getCharacterSet() const;
 
    StringPadding getPadding() const;
 
  protected:
    using DataType::DataType;
    friend class DataType;
};
 
class FixedLengthStringType: public StringType {
  public:
    FixedLengthStringType(size_t size,
                          StringPadding padding,
                          CharacterSet character_set = CharacterSet::Ascii);
};
 
class VariableLengthStringType: public StringType {
  public:
    VariableLengthStringType(CharacterSet character_set = CharacterSet::Ascii);
};
 
 
template <typename T>
class AtomicType: public DataType {
  public:
    AtomicType();
 
    using basic_type = T;
};
 
 
class CompoundType: public DataType {
  public:
    struct member_def {
        member_def(std::string t_name, DataType t_base_type, size_t t_offset = 0)
            : name(std::move(t_name))
            , base_type(std::move(t_base_type))
            , offset(t_offset) {}
        std::string name;
        DataType base_type;
        size_t offset;
    };
 
    CompoundType(const CompoundType& other) = default;
 
    inline CompoundType(const std::vector<member_def>& t_members, size_t size = 0)
        : members(t_members) {
        create(size);
    }
    inline CompoundType(std::vector<member_def>&& t_members, size_t size = 0)
        : members(std::move(t_members)) {
        create(size);
    }
    inline CompoundType(const std::initializer_list<member_def>& t_members, size_t size = 0)
        : members(t_members) {
        create(size);
    }
 
    inline CompoundType(DataType&& type)
        : DataType(type) {
        if (getClass() != DataTypeClass::Compound) {
            std::ostringstream ss;
            ss << "hid " << _hid << " does not refer to a compound data type";
            throw DataTypeException(ss.str());
        }
        size_t n_members = static_cast<size_t>(detail::h5t_get_nmembers(_hid));
        members.reserve(n_members);
        for (unsigned i = 0; i < n_members; i++) {
            char* name = detail::h5t_get_member_name(_hid, i);
            size_t offset = detail::h5t_get_member_offset(_hid, i);
            hid_t member_hid = detail::h5t_get_member_type(_hid, i);
            DataType member_type{member_hid};
            members.emplace_back(std::string(name), member_type, offset);
 
            detail::h5_free_memory(name);
        }
    }
 
    inline void commit(const Object& object, const std::string& name) const;
 
    inline const std::vector<member_def>& getMembers() const noexcept {
        return members;
    }
 
  private:
    std::vector<member_def> members;
 
    void create(size_t size = 0);
};
 
template <typename T>
class EnumType: public DataType {
  public:
    struct member_def {
        member_def(const std::string& t_name, T t_value)
            : name(t_name)
            , value(std::move(t_value)) {}
        std::string name;
        T value;
    };
 
    EnumType(const EnumType& other) = default;
 
    EnumType(const std::vector<member_def>& t_members)
        : members(t_members) {
        static_assert(std::is_enum<T>::value, "EnumType<T>::create takes only enum");
        if (members.empty()) {
            HDF5ErrMapper::ToException<DataTypeException>(
                "Could not create an enum without members");
        }
        create();
    }
 
    EnumType(std::initializer_list<member_def> t_members)
        : EnumType(std::vector<member_def>(t_members)) {}
 
    void commit(const Object& object, const std::string& name) const;
 
  private:
    std::vector<member_def> members;
 
    void create();
};
 
 
template <typename T>
DataType create_datatype();
 
 
template <typename T>
DataType create_and_check_datatype();
 
 
namespace deprecated {
template <std::size_t N>
class FixedLenStringArray {
  public:
    FixedLenStringArray() = default;
 
    FixedLenStringArray(const char array[][N], std::size_t n_strings);
 
    explicit FixedLenStringArray(const std::vector<std::string>& vec);
 
    FixedLenStringArray(const std::string* iter_begin, const std::string* iter_end);
 
    FixedLenStringArray(const std::initializer_list<std::string>&);
 
    void push_back(const std::string&);
 
    void push_back(const std::array<char, N>&);
 
    std::string getString(std::size_t index) const;
 
    // Container interface
    inline const char* operator[](std::size_t i) const noexcept {
        return datavec[i].data();
    }
    inline const char* at(std::size_t i) const {
        return datavec.at(i).data();
    }
    inline bool empty() const noexcept {
        return datavec.empty();
    }
    inline std::size_t size() const noexcept {
        return datavec.size();
    }
    inline void resize(std::size_t n) {
        datavec.resize(n);
    }
    inline const char* front() const {
        return datavec.front().data();
    }
    inline const char* back() const {
        return datavec.back().data();
    }
    inline char* data() noexcept {
        return datavec[0].data();
    }
    inline const char* data() const noexcept {
        return datavec[0].data();
    }
 
  private:
    using vector_t = typename std::vector<std::array<char, N>>;
 
  public:
    // Use the underlying iterator
    using iterator = typename vector_t::iterator;
    using const_iterator = typename vector_t::const_iterator;
    using reverse_iterator = typename vector_t::reverse_iterator;
    using const_reverse_iterator = typename vector_t::const_reverse_iterator;
    using value_type = typename vector_t::value_type;
 
    inline iterator begin() noexcept {
        return datavec.begin();
    }
    inline iterator end() noexcept {
        return datavec.end();
    }
    inline const_iterator begin() const noexcept {
        return datavec.begin();
    }
    inline const_iterator cbegin() const noexcept {
        return datavec.cbegin();
    }
    inline const_iterator end() const noexcept {
        return datavec.end();
    }
    inline const_iterator cend() const noexcept {
        return datavec.cend();
    }
    inline reverse_iterator rbegin() noexcept {
        return datavec.rbegin();
    }
    inline reverse_iterator rend() noexcept {
        return datavec.rend();
    }
    inline const_reverse_iterator rbegin() const noexcept {
        return datavec.rbegin();
    }
    inline const_reverse_iterator rend() const noexcept {
        return datavec.rend();
    }
 
  private:
    vector_t datavec;
};
}  // namespace deprecated
 
template <size_t N>
using FixedLenStringArray H5_DEPRECATED_USING("Use 'std::vector<std::string>'.") =
    deprecated::FixedLenStringArray<N>;
 
}  // namespace HighFive
 
 
#define HIGHFIVE_REGISTER_TYPE(type, function)                    \
    template <>                                                   \
    inline HighFive::DataType HighFive::create_datatype<type>() { \
        return function();                                        \
    }
 
#include "bits/H5DataType_misc.hpp"