JTreeWriter.hh

Go to the documentation of this file.

#ifndef __JROOT__JTREEWRITER__
#define __JROOT__JTREEWRITER__
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#include "TTree.h"
#include "TBranch.h"
#pragma GCC diagnostic pop
 
#include "JIO/JSerialisable.hh"
#include "JLang/JException.hh"
#include "JROOT/JRoot.hh"
#include "JROOT/JRootPrimitiveTypes.hh"
#include "JROOT/JTreeParameters.hh"
#include "TRealData.h"
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
/**
 * \file
 * TTree writing for template data type.
 * \author mdejong
 */
namespace JROOT {
 
  using JIO::JReader;
  using JLANG::JException;
 
 
  /**
   * Auxiliary class for default template TTree writing.
   */
  template<class T, bool flat = false>
  class JTreeWriter :
    public virtual TTree,
    public JTreeParameters
  {
  public:
    /**
     * Constructor.
     *
     * Note that the default TTree parameters are obtained using method JROOT::getTreeParameters.
     *
     * \param  parameters    parameters of TTree
     */
    JTreeWriter(const JTreeParameters& parameters = JROOT::getTreeParameters<T>()) :
      JTreeParameters(parameters),
      address(NULL)
    {
      SetNameTitle(this->getTreeName(), this->getTreeTitle());
 
      SetAutoFlush(this->getAutoFlush());
      SetCacheSize();
 
      branch = Branch(this->getBranchName(),
                      T::Class_Name(),
                      &address,
                      this->getBasketSize(),
                      this->getSplitLevel());
 
      branch->SetCompressionLevel(this->getCompressionLevel());
    }
 
 
    /**
     * Get the pointer to the unique TBranch belonging this TTree.
     *
     * \return               pointer to TBranch
     */
    const TBranch* GetBranch() const
    {
      return branch;
    }
 
 
    /**
     * Data object output equivalent of TTree::Fill().
     *
     * \param  object        data object
     * \return               as TTree::Fill
     */
    Int_t Write(const T& object)
    {
      address = &object;
 
      return this->Fill();
    }
 
  protected:
    using TTree::GetBranch;
    using TTree::Write;
 
  private:
    TBranch* branch;   //!< Pointer to unique branch belonging to this TTree.
    const T* address;  //!< Pointer to unique object belonging to this TTree.
  };
 
 
  /**
   * Template specialisation for flat template TTree writing.
   */
  template<class T>
  class JTreeWriter<T, true> : public virtual TTree
  {
  public:
    /**
     * Constructor.
     *
     * \param  parameters    parameters of TTree
     */
    JTreeWriter(const JTreeParameters& parameters)
    {
      SetNameTitle(parameters.getTreeName(), parameters.getTreeTitle());
 
      // if more than one branch, check those are the data members of T
 
      TClass* t_class = TClass::GetClass<T>();
 
      if (t_class == nullptr) {
        THROW(JException, "Could not get class " << typeid(T).name());
      }
 
      TIter      next(t_class->GetListOfRealData());
      TRealData* data{nullptr};
      T          object;
 
      auto* base = reinterpret_cast<uint8_t*>(&object);
 
      while ((data = dynamic_cast<TRealData*>(next())) != nullptr) {
 
        if (!JRoot::is_tobject_member(data->GetName())) {
 
          auto*       member    = data->GetDataMember();
          auto*       address   = reinterpret_cast<uint8_t*>(base + member->GetOffset());
          std::string type_name = data->GetDataMember()->GetTypeName();
 
          if (member->GetArrayDim() > 0) {
            type_name += "[]";
          }
 
          std::string type_code = JRootPrimitiveTypes::getTypeCode(type_name);
 
          if (type_code.empty()) {
            THROW(JException, "unknown type " << type_name);
          }
 
          std::string leaf = data->GetName();
          leaf += "/" + type_code;
          auto branch = Branch(data->GetName(), address, leaf.c_str());
 
          branches_.push_back(branch);
          offsets_ .push_back(member->GetOffset());
        }
      }
    }
 
    /**
     * Data object output equivalent of TTree::Fill().
     *
     * \param  object        data object
     * \return               as TTree::Fill
     */
    Int_t Write(const T& object)
    {
      auto* base = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&object));
 
      for (size_t i = 0; i < branches_.size(); i++) {
        branches_[i]->SetAddress(reinterpret_cast<uint8_t*>(base + offsets_[i]));
      }
 
      return this->Fill();
    }
 
  protected:
    using TTree::Write;
 
  private:
    std::vector<TBranch*>  branches_;
#if ROOT_VERSION_CODE <= ROOT_VERSION(6,26,0)
    std::vector<Long_t> offsets_;
#else
    std::vector<Longptr_t> offsets_;
#endif
  };
 
  /**
   * Interface for template TTree writing and copying.
   */
  struct JTreeCopyWriterInterface :
    public virtual TTree
  {
    /**
     * Copy data.
     *
     * \param  in            binary reader
     */
    virtual Int_t copy(JReader& in) = 0;
  };
 
 
  /**
   * Implementation for template TTree writing and copying.
   * This class implements the JTreeCopyWriter interface.
   */
  template<class T>
  class JTreeCopyWriter :
    public JTreeWriter<T>,
    public JTreeCopyWriterInterface
  {
  protected:
    /**
     * Constructor.
     *
     * \param  tree          parameters of TTree
     */
    JTreeCopyWriter(const JTreeParameters& tree) :
      JTreeWriter<T>(tree)
    {}
 
 
    /**
     * Hide copy constructor.
     *
     * \param  writer        TTree writer object
     */
    JTreeCopyWriter(const JTreeCopyWriter<T>& writer);
 
 
  public:
    /**
     * Get reference to unique instance of this class object.
     *
     * \return               reference to this class object
     */
    static JTreeCopyWriter<T>& getInstance()
    {
      static JTreeCopyWriter<T> writer(getTreeParameters<T>());
 
      return writer;
    }
 
 
    /**
     * Copy data.
     *
     * \param  in            binary reader
     */
    virtual Int_t copy(JReader& in) override
    {
      in >> object;
 
      return static_cast<JTreeWriter<T>&>(*this).Write(object);
    }
 
 
  protected:
    T object;
  };
 
 
  /**
   * Get the TTree writer and copy for this type of object.
   *
   * \return             TTree writer and copy for this type of object
   */
  template<class T>
  inline JTreeCopyWriter<T>& getTreeCopyWriter()
  {
    return JTreeCopyWriter<T>::getInstance();
  }
}  // namespace JROOT
 
#endif