Reader.h

#pragma once
 
#include <utility>
 
// using HighFive
#include <highfive/H5File.hpp>
 
#include "hdtree/AbstractBranch.h"
#include "hdtree/Atomic.h"
#include "hdtree/Writer.h"
 
namespace hdtree {
 
class Reader {
 public:
  Reader(const std::pair<std::string, std::string>& file_tree_path,
         bool inplace = false);
 
  virtual std::vector<std::pair<std::string, std::string>> availableObjects();
 
  virtual std::pair<std::string, int> type(const std::string& branch_name);
 
  virtual std::string name() const;
 
  std::vector<std::string> list(const std::string& group_path) const;
 
  HighFive::DataSet getDataSet(const std::string& branch_name) const;
 
  HighFive::DataType getDataSetType(const std::string& dataset) const;
 
  HighFive::ObjectType getH5ObjectType(const std::string& path) const;
 
  std::string getTypeName(const std::string& obj_name) const;
 
  inline std::size_t entries() const { return entries_; }
 
  virtual bool canCopy() const { return true; }
 
  virtual void copy(unsigned long int i_entry, const std::string& branch_name,
                    Writer& output);
 
  Reader(const Reader&) = delete;
  void operator=(const Reader&) = delete;
 
 private:
  void mirror(const std::string& branch_name, Writer& output);
 
 private:
  class MirrorObject {
    std::unique_ptr<BaseBranch> data_;
    std::unique_ptr<BaseBranch> size_member_;
    std::vector<std::unique_ptr<MirrorObject>> obj_members_;
    unsigned long int last_entry_{0};
 
   public:
    MirrorObject(const std::string& branch_name, Reader& reader,
                 Writer& writer);
 
    void copy(unsigned long int i_entry, unsigned long int n);
  };
 
 private:
  HighFive::File file_;
  HighFive::Group tree_;
  std::size_t entries_;
  std::unordered_map<std::string, std::unique_ptr<MirrorObject>>
      mirror_objects_;
};  // Reader
 
}  // namespace hdtree