H5DataType.hpp

/*
 *  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)
 *
 */
#ifndef H5DATATYPE_HPP
#define H5DATATYPE_HPP
 
#include <vector>
 
#include "H5Object.hpp"
#include "bits/H5Utils.hpp"
 
namespace h5gt {
 
 
enum class DataTypeClass {
  Time,
  Integer,
  Float,
  String,
  BitField,
  Opaque,
  Compound,
  Reference,
  Enum,
  VarLen,
  Array,
  Invalid
};
 
enum Endian {
  Native,
  Little,
  Big
};
 
 
class DataType : public Object {
public:
 
  DataType() = default;
 
  virtual bool isTypeEqual(const DataType& other) const;
 
  DataTypeClass getClass() const;
 
  size_t getSize() const;
 
  std::string string() const;
 
  bool isVariableStr() const;
 
  bool isFixedLenStr() const;
 
  bool empty() const noexcept;
 
  bool isReference() const;
 
  bool operator==(const DataType& other) const;
  bool operator!=(const DataType& other) const;
 
  static DataType FromId(const hid_t& id, const bool& increaseRefCount = false){
    Object obj = Object(id, ObjectType::UserDataType, increaseRefCount);
    return DataType(obj);
  };
 
protected:
  DataType(const Object& obj) : Object(obj){};
  using Object::Object;
 
  friend class Attribute;
  friend class File;
  friend class Group;
  friend class DataSet;
  friend class NodeTraits<File>;
  friend class NodeTraits<Group>;
};
 
template <typename T>
class AtomicType : public DataType {
public:
  AtomicType(Endian endian = Endian::Native);
 
  typedef T basic_type;
 
  static AtomicType FromId(const hid_t& id, const bool& increaseRefCount = false){
    DataType obj = DataType::FromId(id, increaseRefCount);
    return AtomicType(obj);
  };
 
protected:
  AtomicType(const DataType& obj) : DataType(obj){};
};
 
 
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 void commit(const Object& object, const std::string& name) const;
 
  inline const std::vector<member_def>& getMembers() const noexcept {
    return members;
  }
 
  DataTypeClass getMemberClass(const unsigned& member_no) const;
  int getMemberIndex(const std::string& field_name) const;
  std::string getMemberName(const unsigned& field_idx) const;
  size_t getMemberOffset(const unsigned& memb_no) const;
  hid_t getMemberType(const unsigned& field_idx) const;
  int getNMembers() const;
 
 
  static CompoundType FromId(const hid_t& id, const bool& increaseRefCount = false){
    DataType obj = DataType::FromId(id, increaseRefCount);
    return CompoundType(obj);
  };
 
protected:
  CompoundType(const DataType& obj) : DataType(obj){};
 
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) {
    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;
 
  int getMemberIndex(const std::string& field_name) const;
  std::string getMemberName(const unsigned& field_idx) const;
  void getMemberValue(const unsigned& memb_no, void *value) const;
  int getNMembers() const;
 
  static EnumType FromId(const hid_t& id, const bool& increaseRefCount = false){
    DataType obj = DataType::FromId(id, increaseRefCount);
    return EnumType(obj);
  };
 
protected:
  EnumType(const DataType& obj) : DataType(obj){};
 
private:
  std::vector<member_def> members;
 
  void create();
};
 
 
template <typename T>
DataType create_datatype();
 
 
template <typename T>
DataType create_and_check_datatype();
 
 
template <std::size_t N>
class FixedLenStringArray {
public:
  FixedLenStringArray() = default;
 
  FixedLenStringArray(const char array[][N], std::size_t length);
 
  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 h5gt
 
 
#define H5GT_REGISTER_TYPE(type, function)                \
  template<>                                              \
  inline h5gt::DataType h5gt::create_datatype<type>() {   \
  return function();                                      \
  }                                                       \
 
#include "bits/H5DataType_misc.hpp"
 
#endif // H5DATATYPE_HPP