JRootTypesHandler.hh

Go to the documentation of this file.

#ifndef __JROOT__JROOTTYPESHANDLER__
#define __JROOT__JROOTTYPESHANDLER__
 
#include <typeinfo>
#include <string>
#include <memory>
#include <map>
 
#include <TDictionary.h>
#include <TString.h>
 
#include "JLang/JType.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JPrimitiveTypes.hh"
#include "JLang/JException.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JType;
  using JLANG::JException;
 
 
  /**
   * Interface for handling of a template class.
   *
   * The given template class should provide for the function object operator
   * <pre>
   *    template<class T>
   *    void operator()(const char* const name, const JType<T> type);
   * </pre>
   */
  template<class JType_t>
  class JAbstractType {
  public:
    /**
     * Virtual destructor.
     */
    virtual ~JAbstractType()
    {}
 
    
    /**
     * Apply type with given name to object.
     *
     * \param  object        object
     * \param  name          name
     */
    virtual void apply(JType_t& object, const char* const name) const = 0;
  };
  
 
  /**
   * Implementation for handling of a template class.
   *
   * The given template class should provide for the function object operator
   * <pre>
   *    template<class T>
   *    void operator()(const char* const name, const JType<T> type);
   * </pre>
   *
   * This class implements the JROOT::JAstractType interface for the given template class.
   */
  template<class JType_t, class T>
  class JObjectType :
    public JAbstractType<JType_t>
  {
  public:
    /**
     * Apply type with given name to object.
     *
     * \param  object        object
     * \param  name          name
     */
    virtual void apply(JType_t& object, const char* const name) const override
    {
      object(name, JType<T>());
    }
  };
  
 
  /**
   * Auxiliary class for handling ROOT types.
   *
   * Included types:
   *  - <tt>JPrimitiveTypes_t</tt>
   *
   * Removed types:
   *  - <tt>long double</tt> (not supported by ROOT <tt>TDictionary</tt>)
   *
   * Added STL types:
   *  - <tt>std::string</tt>
   *  - <tt>std::size_t</tt>
   *
   * Added ROOT types:
   *  - <tt>[U]Char_t</tt>
   *  - <tt>[U]Short_t</tt>
   *  - <tt>[U]Int_t</tt>
   *  - <tt>[U]Long_t</tt>
   *  - <tt>[U]Long64_t</tt>
   *  - <tt>Float_t</tt>
   *  - <tt>Double_t</tt>
   *  - <tt>LongDouble_t</tt>
   *  - <tt>TString</tt>
   */
  template<class JType_t>
  class JRootTypesHandler :
    public std::map<std::string, std::shared_ptr< JAbstractType<JType_t> > >
  {
  public:
 
    typedef std::map<std::string, std::shared_ptr< JAbstractType<JType_t> > >  map_type;
    
    /**
     * Default constructor.
     */
    JRootTypesHandler()
    {
      using namespace JPP;
 
      for_each<JTYPELIST<JRemove<JPrimitiveTypes_t, long double>::typelist,
                         std::string,
                         std::size_t>::typelist>(*this);
 
#define VALUE_TYPE(__TYPE__) typename map_type::value_type(#__TYPE__, new JObjectType<JType_t, __TYPE__>())
 
      this->insert(VALUE_TYPE(Byte_t));
      this->insert(VALUE_TYPE(Char_t));
      this->insert(VALUE_TYPE(UChar_t));
      this->insert(VALUE_TYPE(Short_t));
      this->insert(VALUE_TYPE(UShort_t));
      this->insert(VALUE_TYPE(Int_t));
      this->insert(VALUE_TYPE(UInt_t));
      this->insert(VALUE_TYPE(Long_t));
      this->insert(VALUE_TYPE(ULong_t));
      this->insert(VALUE_TYPE(Long64_t));
      this->insert(VALUE_TYPE(ULong64_t));
      this->insert(VALUE_TYPE(Float_t));
      this->insert(VALUE_TYPE(Double_t));
      this->insert(VALUE_TYPE(LongDouble_t));
      this->insert(VALUE_TYPE(TString));
 
#undef VALUE_TYPE
    }
 
 
    /**
     * Addition of data type.
     *
     * This method uses <tt>TDictionary></tt> to determine name of given data type.
     *
     * \param  type          data type
     */
    template<class T>
    void operator()(const JType<T>& type)
    {
      const TDictionary* pDictionary = TDictionary::GetDictionary(typeid(T));
 
      if (pDictionary != NULL)
        (*this)(pDictionary->GetName(), type);
      else
        THROW(JException, "ROOT TDictionary unknown data type " << typeid(T).name());
    }
 
 
    /**
     * Addition of data type.
     *
     * \param  name          data name
     * \param  type          data type
     */
    template<class T>
    void operator()(const char* const name, const JType<T>& type)
    {
      this->insert(typename map_type::value_type(name, new JObjectType<JType_t, T>()));
    }
 
 
    /**
     * Apply this handler to given object.
     *
     * \param  object        object
     */
    void apply(JType_t& object) const
    {
      for (typename map_type::const_iterator i = this->begin(); i != this->end(); ++i) {
        i->second->apply(object, i->first.c_str());
      }
    }
  };
 
 
  /**
   * Apply ROOT types handler to given object.
   *
   * Note that the underlying <tt>TDictionary</tt> is dynamically built in ROOT.
   *
   * \param  object        object
   */
  template<class JType_t>
  inline void handler(JType_t& object)
  {
    JRootTypesHandler<JType_t> handler;
 
    handler.apply(object);
  }
}
 
#endif