JTreeParameters.hh

Go to the documentation of this file.

#ifndef __JROOT__JTREEPARAMETERS__
#define __JROOT__JTREEPARAMETERS__
 
#include <istream>
#include <ostream>
#include <iomanip>
#include <type_traits>
 
#include "TString.h"
 
#include "JLang/JType.hh"
#include "JLang/JNullType.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JType;
  using JLANG::JNullType;
 
 
  /**
   * Data structure for TTree parameters.
   */
  class JTreeParameters {
  public:
    /**
     * Constructor.
     *
     * \param  treeName            TTree   name
     * \param  treeTitle           TTree   title
     * \param  branchName          TBranch name
     * \param  compressionLevel    TBranch compression level
     * \param  basketSize          TBranch basket size
     * \param  splitLevel          TBranch split level
     * \param  autoFlush           TTree   auto flush
     */
    JTreeParameters(const TString& treeName,
                    const TString& treeTitle,
                    const TString& branchName       = "",
                    const int      compressionLevel =     1,
                    const int      basketSize       = 65536,
                    const int      splitLevel       =     1,
                    const Long64_t autoFlush        =  5000)
                    
    {
      this->treeName         = treeName;
      this->treeTitle        = treeTitle;
      this->branchName       = branchName;
      this->compressionLevel = compressionLevel;
      this->basketSize       = basketSize;
      this->splitLevel       = splitLevel;
      this->autoFlush        = autoFlush;
    }
 
 
    /**
     * Get TTree parameters.
     *
     * \return        TTree parameters
     */
    inline const JTreeParameters& getTreeParameters() const
    {
      return static_cast<const JTreeParameters&>(*this);
    }
 
 
    /**
     * Get TTree name.
     *
     * \return        TTree name
     */
    const TString& getTreeName() const 
    {
      return treeName;
    }
 
 
    /**
     * Get TTree title.
     *
     * \return        TTree title
     */
    const TString& getTreeTitle() const 
    {
      return treeTitle;
    }
 
 
    /**
     * Get TBranch name.
     *
     * \return        TBranch name
     */
    const TString& getBranchName() const 
    {
      return (branchName != "" ? branchName : treeName);
    }
 
 
    /**
     * Get compression level.
     *
     * \return        compression level
     */
    int getCompressionLevel() const 
    {
      return compressionLevel;
    }
 
 
    /**
     * Set compression level.
     *
     * \param  value  compression level
     */
    void setCompressionLevel(const int value)
    {
      compressionLevel = value;
    }
 
 
    /**
     * Get basket size.
     *
     * \return        basket size
     */
    int getBasketSize() const 
    {
      return basketSize;
    }
 
 
    /**
     * Set basket size.
     *
     * \param  value  basket size
     */
    void setBasketSize(int value)
    {
      basketSize = value;
    }
 
 
    /**
     * Get split level.
     *
     * \return        split level
     */
    int getSplitLevel() const 
    {
      return splitLevel;
    }
 
 
    /**
     * Set split level.
     *
     * \param  value  split level
     */
    void setSplitLevel(int value)
    {
      splitLevel = value;
    }
 
 
    /**
     * Get auto flush.
     *
     * \return        auto flush
     */
    Long64_t getAutoFlush() const 
    {
      return autoFlush;
    }
 
 
    /**
     * Set auto flush.
     *
     * \param  value  auto flush
     */
    void setAutoFlush(Long64_t value)
    {
      autoFlush = value;
    }
 
 
    /**
     * Read TTree parameters from input.
     *
     * \param  in         input stream
     * \param  object     TTree parameters
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTreeParameters& object)
    {
      using namespace std;
 
      object.treeName  .ReadToken(in);
      object.branchName.ReadToken(in);
 
      return in >> object.compressionLevel
                >> object.basketSize
                >> object.splitLevel
                >> object.autoFlush;    
    }
 
    /**
     * Write TTree parameters to output.
     *
     * \param  out        output stream
     * \param  object     TTree parameters
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTreeParameters& object)
    {
      using namespace std;
 
      return out << setw(24) << left << object.getTreeName()   << right << ' '
                 << setw(24) << left << object.getBranchName() << right << ' '
                 << setw(1)  << object.getCompressionLevel()            << ' '
                 << setw(10) << object.getBasketSize()                  << ' '
                 << setw(2)  << object.getSplitLevel()                  << ' '
                 << setw(8)  << object.getAutoFlush();  
    }
 
 
  protected:
    /**
     * Default constructor.
     */
    JTreeParameters()
    {}
 
 
    TString  treeName;           //!< TTree   name
    TString  treeTitle;          //!< TTree   title
    TString  branchName;         //!< TBranch name
    int      compressionLevel;   //!< TBranch compression level
    int      basketSize;         //!< TBranch basket size
    int      splitLevel;         //!< TBranch split level
    Long64_t autoFlush;          //!< TTree   auto flush
  };
 
 
  /**
   * Template definition for method returning TTree parameters.
   * The template argument refers to the class for which ROOT TTree I/O is desired.
   *
   * \return        TTree parameters
   */
  template<class T>
  inline JTreeParameters& getTreeParameters() 
  {
    static JTreeParameters parameters = getTreeParameters(JType<T>()); 
 
    return parameters;
  }
 
 
  /**
   * Method with argument definition for obtaining TTree parameters.
   * The method argument refers to the class for which ROOT TTree I/O is desired.
   * This method should then be overloaded and the overloaded method should
   * return a JTreeParameters object with the corresponding TTree parameters.
   *
   * \param  type   data type
   * \return        TTree parameters
   */
  template<class T>
  inline JNullType getTreeParameters(const JType<T>& type);
 
 
  /**
   * Test availability of TTree parameters for given class.
   *
   * The parameter result evaluates to true if for this class TTree parameters are defined.
   */
  template<class T>
  class JTreeParametersAvailable
  {
  public:
    static const bool result = std::is_same<JTreeParameters, decltype(getTreeParameters(JType<T>()))>::value; //!< true if TTree parameters available; else false
  };
 
 
  /**
   * Auxiliary data structure for setting TTree parameters.
   */
  struct JTreeParameters_t :
    public JTreeParameters
  {
    /**
     * Set TTree parameters.
     *
     * \param  type         data type
     */
    template<class T>
    void operator()(const JType<T>& type) const
    {
      set(type, std::bool_constant<JTreeParametersAvailable<T>::result>());
    }
 
  private:
    /**
     * Set TTree parameters.
     *
     * \param  type         data type
     * \param  option       option for availability of TTree parameters
     */
    template<class T>
    void set(const JType<T>& type, std::true_type option) const
    {
      if (JROOT::getTreeParameters<T>().getTreeName()   == this->getTreeName() &&
          JROOT::getTreeParameters<T>().getBranchName() == this->getBranchName()) {
        JROOT::getTreeParameters<T>() = this->getTreeParameters();
      }
    }
 
 
    /**
     * Set TTree parameters.
     *
     * \param  type         data type
     * \param  option       option for unavailability of TTree parameters
     */
    template<class T>
    void set(const JType<T>& type, std::false_type option) const
    {}
  };
}
 
#endif