JRootSupportkit.hh

Go to the documentation of this file.

#ifndef __JROOTSUPPORTKIT__
#define __JROOTSUPPORTKIT__
 
#include <type_traits>
 
 
#include "TFile.h"
 
#include "JLang/JTest.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;
 
  
  /**
   * 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, std::true_type 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, std::false_type 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, std::bool_constant<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, std::true_type 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, std::false_type 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, std::bool_constant<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