ParameterStorage.h

#ifndef FIRE_IO_H5_PARAMETERSTORAGE_H
#define FIRE_IO_H5_PARAMETERSTORAGE_H
 
// STL
#include <boost/core/demangle.hpp>
#include <iostream>
#include <map>
#include <string>
#include <variant>
 
#include "fire/io/Data.h"
#include "fire/io/Reader.h"
#include "fire/exception/Exception.h"
 
namespace fire::io {
 
class ParameterStorage {
 public:
  template <typename ParameterType>
  const ParameterType& get(const std::string& name) const {
    try {
      return std::get<ParameterType>(parameters_.at(name));
    } catch (const std::bad_variant_access&) {
      throw Exception("BadType",
          "Parameter named " + name + " is not type " +
          boost::core::demangle(typeid(ParameterType).name()));
    } catch (const std::out_of_range&) {
      throw Exception("NotFound","Parameter named " + name + " not found.");
    }
  }
 
  template <typename ParameterType>
  void set(const std::string& name, const ParameterType& val) {
    static_assert(
        std::is_same_v<ParameterType, int> ||
            std::is_same_v<ParameterType, float> ||
            std::is_same_v<ParameterType, std::string>,
        "Parameters are only allowed to be float, int, or std::string.");
    parameters_[name] = val;
  }
 
  void clear();
 
 private:
  friend class Data<ParameterStorage>;
 
  std::unordered_map<std::string, std::variant<int, float, std::string>>
      parameters_;
};
 
template <>
class Data<ParameterStorage> : public AbstractData<ParameterStorage> {
 public:
  Data(const std::string& path, Reader* input_file, ParameterStorage* handle);
 
  void load(h5::Reader& r) final override;
 
#ifdef fire_USE_ROOT
  void load(root::Reader&) final override {
    throw Exception("BadCode","This function should never be called.");
  }
#endif
 
  void save(Writer& w) final override;
 
  void structure(Writer& w) final override;
 
 private:
  template <typename ParameterType>
  void attach(const std::string& name) {
    parameters_[name] = std::make_unique<Data<ParameterType>>(
        this->path_ + "/" + name, 
        input_file_,
        std::get_if<ParameterType>(&(this->handle_->parameters_[name])));
  }
 
 private:
  std::unordered_map<std::string, std::unique_ptr<BaseData>> parameters_;
  Reader* input_file_;
};
 
}
 
#endif