JRootSupportkit.hh

Go to the documentation of this file.

#ifndef __JROOTSUPPORTKIT__
#define __JROOTSUPPORTKIT__

#include "TFile.h"

#include "JLang/JTest.hh"
#include "JLang/JBool.hh"

#include "JROOT/JRootToolkit.hh"


/**
 * \file
 *
 * Data type dependent action methods for customised ROOT version management.
 * \author mdejong
 */
namespace JROOT {}
namespace JPP { using namespace JROOT; }

namespace JROOT {

  using JLANG::JTest;
  using JLANG::JBool;

  
  /**
   * Auxiliary class to handle version management of given class at opening of a ROOT file.
   */
  template <class T>
  class JActionAtFileOpen :
    public JTest
  {
    using JTest::test;
    
    template<class U> static JTrue test(JTypecheck<void (*)(int), &U::actionAtFileOpen>*);


    /**
     * Execute action.
     *
     * This implementation transfers the action to the given class.
     *
     * \param  file           pointer to file
     * \param  option         true
     */
    static inline void execute(TFile* file, JBool<true> option)
    {
      T::actionAtFileOpen(getStreamerVersion(file, T::Class_Name()));
    }


    /**
     * Execute action.
     *
     * This implementation does nothing.
     *
     * \param  file           pointer to file
     * \param  option         false
     */
    static inline void execute(TFile* file, JBool<false> option)
    {}
    
  public:

    static const bool has_method = JTEST(test<T>(NULL)); //!< true if class has policy method actionAtFileOpen; else false


    /**
     * Execute action.
     *
     * \param  file           pointer to file
     */
    static inline void execute(TFile* file)
    {
      execute(file, JBool<has_method>());
    }
  };

  
  /**
   * Auxiliary class to handle version management of given class at reading from a ROOT file.
   */
  template <class T>
  class JActionAtFileRead :
    public JTest
  {
    using JTest::test;

    template<class U> static JTrue test(JTypecheck<void (U::*)(), &U::actionAtFileRead>*);

    
    /**
     * Execute action.
     *
     * This implementation transfers the action to the given object.
     *
     * \param  object         pointer to object (I/O)
     * \param  option         true
     */
    static inline void execute(T* object, JBool<true> option)
    {
      object->actionAtFileRead();
    }

    
    /**
     * Execute action.
     *
     * This implementation does nothing.
     *
     * \param  object         pointer to object (I/O)
     * \param  option         false
     */
    static inline void execute(T* object, JBool<false> option)
    {}

  public:
    
    static const bool has_method = JTEST(test<T>(NULL)); //!< true if class has policy method actionAtFileRead; else false

    
    /**
     * Execute action.
     *
     * \param  object         pointer to object (I/O)
     */
    static inline void execute(T* object)
    {
      execute(object, JBool<has_method>());
    }
  };

  
  /**
   * General action method at file open.
   *
   * The class T should provide the policy method:
   * <pre>
   *    static void %actionAtFileOpen(int version);
   * </pre>
   * whenever an action specific to this data type has to be executed after opening a file.\n
   * This method will then be called following each file open operation.
   *
   * \param  file           pointer to file
   */
  template<class T>
  inline void actionAtFileOpen(TFile* file)
  {
    if (file != NULL) {
      JActionAtFileOpen<T>::execute(file);
    }
  }


  /**
   * General action method at file read.
   *
   * The class T should provide the policy method:
   * <pre>
   *    void %actionAtFileRead();
   * </pre>
   * whenever an action specific to this data type has to be executed after reading from a file.\n
   * This method will then be called following each file read operation.
   *
   * \param  object         pointer to object (I/O)
   */
  template<class T>
  inline void actionAtFileRead(T* object)
  {
    if (object != NULL) {
      JActionAtFileRead<T>::execute(object);
    }
  }
}
#endif