JAutoTreeWriter.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JAUTOTREEWRITER__
#define __JSUPPORT__JAUTOTREEWRITER__
 
#include "JLang/JType.hh"
#include "JTools/JAutoMap.hh"
#include "JROOT/JTreeWriter.hh"
#include "JROOT/JRootFile.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using JLANG::JType;
  using JTOOLS::JAutoMap;
  using JROOT::JTreeCopyWriterInterface;
  using JROOT::JRootOutputFile;
 
 
  /**
   * Auxiliary class to copy input data to corresponding TTree.
   *
   * This class derives from JROOT::JRootOutputFile.
   * It re-implements the methods open and close of the underlying JLANG::JAccessible class
   * so that each TTree is properly attached to and detached from the corresponding TDirectory, respectively.
   */
  template<class JKey_t>
  class JAutoTreeWriter :
    public JAutoMap<JKey_t, JTreeCopyWriterInterface*>,
    public JRootOutputFile
  {
  public:
 
    typedef typename JAutoMap<JKey_t, JTreeCopyWriterInterface*>::map_type      map_type;
    typedef typename JAutoMap<JKey_t, JTreeCopyWriterInterface*>::value_type    value_type;
 
    typedef typename map_type::const_iterator                          const_iterator;
    typedef typename map_type::iterator                                iterator;
    typedef typename map_type::const_reverse_iterator                  const_reverse_iterator;
    typedef typename map_type::reverse_iterator                        reverse_iterator;
 
    using JAutoMap<JKey_t, JTreeCopyWriterInterface*>::insert;
 
 
    /**
     * Default constrtuctor.
     */
    JAutoTreeWriter()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  type             data type
     */
    template<class T>
    JAutoTreeWriter(JType<T> type)
    {
      this->template insert<T>();
    }
 
 
    /**
     * Get key.
     *
     * This method should be overloaded for the requested data types.
     *
     * \param  type             data type
     * \return                  key
     */
    template<class T>
    static JKey_t getKey(JType<T> type);
 
 
    /**
     * Insert (list of) data type(s).
     */
    template<class T>
    void insert()
    {
      insert<T>(JTOOLS::JAutomate<JElement_t>());
    }
 
 
    /**
     * Open file.
     *
     * \param  file_name      file name
     */
    virtual void open(const char* file_name) override 
    {
      JRootOutputFile::open(file_name);
      
      if (is_open()) {
        for (iterator i = this->begin(); i != this->end(); ++i) {
          i->second->SetDirectory(getFile());
        }
      }
    }
 
 
    /**
     * Close file.
     */
    virtual void close() override 
    {
      // Write objects in memory.
 
      if (is_open()) {
        getFile()->Write();
      }
 
      // Detach TTree from TDirectory to avoid deletion of TTree.
 
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->second->SetDirectory(0);
      }
 
      // Close file.
      
      if (is_open()) {
        getFile()->Close();
      }
 
      reset();
 
      // Reset TTree for next run.
      
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->second->Reset();
      }
    }
 
    
  protected:
    /**
     * Auxiliary class for element insertion.
     */
    struct JElement_t : 
      public value_type
    {
      /**
       * Constructor.
       *
       * \param  type             data type
       */
      template<class T>
      JElement_t(JType<T> type) :
        value_type(getKey(type), &JROOT::getTreeCopyWriter<T>())
      {}
    };
  };
}
 
#endif