JTreeWriter.hh

Go to the documentation of this file.

#ifndef __JROOT__JTREEWRITER__
#define __JROOT__JTREEWRITER__
 
#include "TTree.h"
#include "TBranch.h"
 
#include "JROOT/JTreeParameters.hh"
#include "JIO/JSerialisable.hh"
 
 
/**
 * \file
 * TTree writing for template data type.
 * \author mdejong
 */
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JIO::JReader;
 
 
  /**
   * Auxiliary class for template TTree writing.
   */
  template<class T>
  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();
    }
 
 
  private:
    TBranch*  branch;    //!< Pointer to unique branch belonging to this TTree.
    const T*  address;   //!< Pointer to unique object belonging to this TTree.
  };
 
 
  /**
   * 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) 
    {
      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();
  }
}
 
#endif