HdfTuple.h

Go to the documentation of this file.

// this is -*- C++ -*-
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef HDF_TUPLE_HH
#define HDF_TUPLE_HH
 
#include "H5Traits.h"
 
#include "H5Cpp.h"
 
#include <functional>
#include <vector>
#include <memory>
 
namespace H5Utils {
 
 
  namespace internal {
 
 
    template <typename T>
    data_buffer_t get_buffer_from_func(const std::function<T()>& func) {
      data_buffer_t buffer;
      H5Traits<T>::ref(buffer) = func();
      return buffer;
    }
 
    class IVariableFiller
    {
    public:
      virtual ~IVariableFiller() {}
      virtual data_buffer_t get_buffer() const = 0;
      virtual H5::DataType get_type() const = 0;
      virtual std::string name() const = 0;
    };
 
    template <typename T>
    class VariableFiller: public IVariableFiller
    {
    public:
      VariableFiller(const std::string&, const std::function<T()>&);
      internal::data_buffer_t get_buffer() const;
      H5::DataType get_type() const;
      std::string name() const;
    private:
      std::function<T()> m_getter;
      std::string m_name;
    };
    template <typename T>
    VariableFiller<T>::VariableFiller(const std::string& name,
                                      const std::function<T()>& func):
      m_getter(func),
      m_name(name)
    {
    }
    template <typename T>
    data_buffer_t VariableFiller<T>::get_buffer() const {
      return get_buffer_from_func<T>(m_getter);
    }
    template <typename T>
    H5::DataType VariableFiller<T>::get_type() const {
      return H5Traits<T>::type;
    }
    template <typename T>
    std::string VariableFiller<T>::name() const {
      return m_name;
    }
 
  }
 
 
 
  class VariableFillers:
    public std::vector<std::shared_ptr<internal::IVariableFiller> >
  {
  public:
    template <typename T>
    void add(const std::string& name, const std::function<T()>&);
  };
 
  template <typename T>
  void VariableFillers::add(const std::string& name,
                            const std::function<T()>& fun) {
    using internal::VariableFiller;
    this->push_back(std::make_shared<VariableFiller<T> >(name, fun));
  }
 
 
  class WriterXd {
  public:
    WriterXd(H5::Group& group, const std::string& name,
             VariableFillers fillers,
             std::vector<hsize_t> dataset_dimensions,
             hsize_t chunk_size = 2048);
    WriterXd(const WriterXd&) = delete;
    WriterXd& operator=(WriterXd&) = delete;
    ~WriterXd();
    void fillWhileIncrementing(
      std::vector<size_t>& indices);
    void flush();
    size_t index() const;
  private:
    hsize_t buffer_size() const;
    H5::CompType m_type;
    std::vector<hsize_t> m_max_length;
    std::vector<hsize_t> m_dim_stride;
    hsize_t m_batch_size;
    hsize_t m_offset;
    std::vector<internal::data_buffer_t> m_buffer;
    VariableFillers m_fillers;
    H5::DataSet m_ds;
  };
 
}
#endif