Data.h

#ifndef FIRE_IO_DATA_H
#define FIRE_IO_DATA_H
 
#include <memory>
#include <type_traits>
#include <vector>
#include <map>
 
#include "fire/exception/Exception.h"
#include "fire/io/Access.h"
#include "fire/io/AbstractData.h"
#include "fire/io/Writer.h"
#include "fire/io/Constants.h"
#include "fire/io/h5/Reader.h"
#ifdef fire_USE_ROOT
#include "fire/io/root/Reader.h"
#endif
 
namespace fire::io {
 
// need implementation here so we can use the fully defined input file `type` function
template <typename DataType>
AbstractData<DataType>::AbstractData(const std::string& path, Reader* input_file, DataType* handle)
  : BaseData(path), owner_{handle == nullptr} {
  if (owner_) {
    handle_ = new DataType;
  } else {
    handle_ = handle;
  }
  save_type_ = { boost::core::demangle(typeid(DataType).name()), class_version<DataType> };
  if (input_file) {
    load_type_ = input_file->type(path);
  }
}
 
template <typename DataType, typename Enable = void>
class Data : public AbstractData<DataType> {
 public:
  enum SaveLoad {
    Both, 
    LoadOnly, 
    SaveOnly  
  };
 
  explicit Data(const std::string& path, Reader* input_file = nullptr, DataType* handle = nullptr)
      : AbstractData<DataType>(path, input_file, handle), input_file_{input_file} {
    fire::io::access::connect(*this->handle_, *this);
  }
 
  void load(h5::Reader& f) final override try {
    for (auto& [save,load,m] : members_) if (load) m->load(f);
  } catch (const HighFive::DataSetException& e) {
    const auto& [memt, memv] = this->save_type_;
    const auto& [diskt, diskv] = f.type(this->path_);
    std::stringstream ss;
    ss << "Data at " << this->path_ << " could not be loaded into "
        << memt  << " (version " << memv << ") from the type it was written as " 
        << diskt << " (version " << diskv << ")\n"
        "  Check that your implementation of attach can handle any "
        "previous versions of your class you are trying to read.\n"
        "  H5 Error:\n" << e.what();
    throw Exception("BadType",ss.str(), false);
  }
 
#ifdef fire_USE_ROOT
  void load(root::Reader& f) final override {
    f.load(this->path_, *(this->handle_));
  }
#endif
 
  /*
   * Saving this dataset from the file involves simply saving
   * all of the members of the data type.
   *
   * @param[in] f file to save to
   */
  void save(Writer& f) final override {
    for (auto& [save,load,m] : members_) if (save) m->save(f);
  }
 
  void structure(Writer& f) final override {
    f.structure(this->path_, this->save_type_);
    for (auto& [save,load,m] : members_) if (save) m->structure(f);
  }
 
  template <typename MemberType>
  void attach(const std::string& name, MemberType& m, SaveLoad sl = SaveLoad::Both) {
    if (name == constants::SIZE_NAME) {
      throw Exception("BadName",
          "The member name '"+constants::SIZE_NAME+"' is not allowed due to "
          "its use in the serialization of variable length types.\n"
          "    Please give your member a more detailed name corresponding to "
          "your class", false);
    }
    bool save{false}, load{false};
    Reader* input_file{input_file_};
    if (sl == SaveLoad::LoadOnly) load = true;
    else if (sl == SaveLoad::SaveOnly) { save = true; input_file = nullptr; }
    else { save = true; load = true; }
    members_.push_back(std::make_tuple(save, load,
        std::make_unique<Data<MemberType>>(this->path_ + "/" + name, input_file, &m)));
  }
 
  template <typename MemberType>
  void rename(const std::string& old_name, const std::string& new_name, MemberType& m) {
    attach(old_name,m,SaveLoad::LoadOnly);
    attach(new_name,m,SaveLoad::SaveOnly);
  }
 
 private:
  std::vector<std::tuple<bool,bool,std::unique_ptr<BaseData>>> members_;
  Reader* input_file_;
};  // Data
 
template <typename AtomicType>
class Data<AtomicType, std::enable_if_t<is_atomic_v<AtomicType>>>
    : public AbstractData<AtomicType> {
 public:
  explicit Data(const std::string& path, Reader* input_file = nullptr, AtomicType* handle = nullptr)
      : AbstractData<AtomicType>(path, input_file, handle) {}
 
  void load(h5::Reader& f) final override {
    f.load(this->path_, *(this->handle_));
  }
 
#ifdef fire_USE_ROOT
  void load(root::Reader& f) final override {
    f.load(this->path_, *(this->handle_));
  }
#endif
 
  void save(Writer& f) final override {
    f.save(this->path_, *(this->handle_));
  }
 
  void structure(Writer& f) final override {
    // atomic types get translated into H5 DataSets
    // in save so we purposefully DO NOTHING here
  }
};  // Data<AtomicType>
 
template <typename ContentType>
class Data<std::vector<ContentType>>
    : public AbstractData<std::vector<ContentType>> {
  fire_class_version(1);
 public:
  explicit Data(const std::string& path, Reader* input_file = nullptr, 
      std::vector<ContentType>* handle = nullptr)
      : AbstractData<std::vector<ContentType>>(path, input_file, handle),
        size_{path + "/" + constants::SIZE_NAME, input_file},
        data_{path + "/data", input_file} {}
 
  void load(h5::Reader& f) final override {
    size_.load(f);
    this->handle_->resize(size_.get());
    for (std::size_t i_vec{0}; i_vec < size_.get(); i_vec++) {
      data_.load(f);
      (*(this->handle_))[i_vec] = data_.get();
    }
  }
 
#ifdef fire_USE_ROOT
  void load(root::Reader& f) final override {
    f.load(this->path_, *(this->handle_));
  }
#endif
 
  void save(Writer& f) final override {
    size_.update(this->handle_->size());
    size_.save(f);
    for (std::size_t i_vec{0}; i_vec < this->handle_->size(); i_vec++) {
      data_.update(this->handle_->at(i_vec));
      data_.save(f);
    }
  }
 
  void structure(Writer& f) final override {
    f.structure(this->path_, this->save_type_);
    size_.structure(f);
    data_.structure(f);
  }
 
 private:
  Data<std::size_t> size_;
  Data<ContentType> data_;
};  // Data<std::vector>
 
template <typename KeyType, typename ValType>
class Data<std::map<KeyType,ValType>>
    : public AbstractData<std::map<KeyType,ValType>> {
  fire_class_version(1);
 public:
  explicit Data(const std::string& path, Reader* input_file = nullptr, 
      std::map<KeyType,ValType>* handle = nullptr)
      : AbstractData<std::map<KeyType,ValType>>(path, input_file, handle),
        size_{path + "/" + constants::SIZE_NAME, input_file},
        keys_{path + "/keys", input_file},
        vals_{path + "/vals", input_file} {}
 
  void load(h5::Reader& f) final override {
    size_.load(f);
    for (std::size_t i_map{0}; i_map < size_.get(); i_map++) {
      keys_.load(f);
      vals_.load(f);
      this->handle_->emplace(keys_.get(), vals_.get());
    }
  }
 
#ifdef fire_USE_ROOT
  void load(root::Reader& f) final override {
    f.load(this->path_, *(this->handle_));
  }
#endif
 
  void save(Writer& f) final override {
    size_.update(this->handle_->size());
    size_.save(f);
    for (auto const& [key,val] : *(this->handle_)) {
      keys_.update(key);
      keys_.save(f);
      vals_.update(val);
      vals_.save(f);
    }
  }
 
  void structure(Writer& f) final override {
    f.structure(this->path_, this->save_type_);
    size_.structure(f);
    keys_.structure(f);
    vals_.structure(f);
  }
 
 private:
  Data<std::size_t> size_;
  Data<KeyType> keys_;
  Data<ValType> vals_;
};  // Data<std::map>
 
}  // namespace fire::io
  
#endif  // FIRE_H5_DATASET_H