AbstractBranch.h

#pragma once
 
#include <boost/core/demangle.hpp>  // for demangling
#include <limits>
#include <optional>
#include <string>
 
#include "hdtree/ClassVersion.h"
#include "hdtree/Version.h"
 
namespace hdtree {
 
class Writer;
class Reader;
 
class BaseBranch {
 public:
  explicit BaseBranch(const std::string& full_name) : name_{full_name} {}
 
  virtual ~BaseBranch() = default;
 
  virtual void attach(Reader& f) = 0;
 
  virtual void load() = 0;
 
  virtual void attach(Writer& f) = 0;
 
  virtual void save() = 0;
 
  virtual void clear() = 0;
 
  BaseBranch(const BaseBranch&) = delete;
  BaseBranch& operator=(const BaseBranch&) = delete;
 
 protected:
  std::string name_;
};
 
template <typename DataType>
class AbstractBranch : public BaseBranch {
 public:
  explicit AbstractBranch(const std::string& branch_name,
                          DataType* handle = nullptr)
      : BaseBranch(branch_name), owner_{handle == nullptr} {
    if (owner_) {
      handle_ = new DataType;
    } else {
      handle_ = handle;
    }
 
    save_type_ = {boost::core::demangle(typeid(DataType).name()),
                  class_version<DataType>};
  }
 
  virtual ~AbstractBranch() {
    if (owner_) delete handle_;
  }
 
  virtual void attach(Reader& f) = 0;
  virtual void load() = 0;
 
  virtual void save() = 0;
 
  virtual void attach(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; }
 
  DataType& operator*() { return *handle_; }
 
  const DataType& operator*() const { return get(); }
 
  DataType* operator->() { return handle_; }
 
  const DataType* operator->() const { return handle_; }
 
 protected:
  std::optional<std::pair<std::string, int>> load_type_;
  std::pair<std::string, int> save_type_;
 
  DataType* handle_;
  bool owner_;
};  // AbstractBranch
 
}  // namespace hdtree