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/JRootClass.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());

      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 (!JRootClass::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