AbstractData.h

#ifndef FIRE_IO_ABSTRACTDATA_H
#define FIRE_IO_ABSTRACTDATA_H
 
#include <string>
 
#include <boost/core/demangle.hpp> // for demangling
 
#include "fire/version/Version.h"
#include "fire/io/ClassVersion.h"
 
namespace fire::io {
 
class Writer;
class Reader;
namespace h5 { class Reader; }
#ifdef fire_USE_ROOT
namespace root { class Reader; }
#endif
 
class BaseData {
 public:
  explicit BaseData(const std::string& path) : path_{path} {}
 
  virtual ~BaseData() = default;
 
  virtual void load(h5::Reader& f) = 0;
 
#ifdef fire_USE_ROOT
  virtual void load(root::Reader& f) = 0;
#endif
 
  virtual void save(Writer& f) = 0;
 
  virtual void structure(Writer& f) = 0;
 
  virtual void clear() = 0;
 
 protected:
  std::string path_;
 
};
 
template <typename DataType>
class AbstractData : public BaseData {
 public:
  explicit AbstractData(const std::string& path, Reader* input_file = nullptr, 
      DataType* handle = nullptr);
 
  virtual ~AbstractData() {
    if (owner_) delete handle_;
  }
 
  virtual void load(h5::Reader& f) = 0;
 
#ifdef fire_USE_ROOT
  virtual void load(root::Reader& f) = 0;
#endif
 
  virtual void save(Writer& f) = 0;
 
  virtual void structure(Writer& f) = 0;
 
  virtual void clear() {
    if (owner_) {
      if constexpr (std::numeric_limits<DataType>::is_specialized) {
        *(this->handle_) = std::numeric_limits<DataType>::min();
      } else {
        handle_->clear();
      }
    }
  }
 
  virtual const DataType& get() const { return *handle_; }
 
  int version() const {
    return load_type_.value_or(save_type_).second;
  }
 
  virtual void update(const DataType& val) { 
    *handle_ = val; 
  }
 
 protected:
  std::optional<std::pair<std::string,int>> load_type_;
  std::pair<std::string,int> save_type_;
 
  DataType* handle_;
  bool owner_;
};  // AbstractData
 
}
 
#endif