JRootDictionary.hh

Go to the documentation of this file.

#ifndef __JROOT__JROOTDICTIONARY__
#define __JROOT__JROOTDICTIONARY__
 
#include <string>
#include <vector>
#include <typeinfo>
 
#include "TDictionary.h"
 
#include "JLang/JType.hh"
#include "JLang/JNullType.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JPrimitiveTypes.hh"
#include "JLang/JException.hh"
#include "JLang/JSingleton.hh"
#include "JROOT/JRoot.hh"
#include "JROOT/JRootDictionary_t.hh"
#include "JROOT/JRootStreamer.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JType;
  using JLANG::JNullType;
  using JLANG::JTypeList;
  using JLANG::JTYPELIST;
  using JLANG::JException;
  using JLANG::JSingleton;
 
  /**
   * Default implementation of ROOT based dictionary for ASCII I/O.
   */
  class JRootDictionary :
    public JRootDictionary_t,
    public JSingleton<JRootDictionary>
  {
  public:
    /**
     * Default constructor.
     *
     * This constructor builds a default dictionary which includes all primitive data types and <tt>std::vector</tt> thereof.
     *
     * Removed types:
     *  - <tt>long double</tt> (not supported by ROOT <tt>TDictionary</tt>)
     *
     * Added STL type definitions:
     *  - <tt>std::string</tt>
     *  - <tt>std::size_t</tt>
     *
     * Added ROOT type definitions:
     *  - <tt>[U]Char_t  </tt>
     *  - <tt>[U]Short_t </tt>
     *  - <tt>[U]Int_t   </tt>
     *  - <tt>[U]Long64_t</tt>
     *  - <tt>[U]Float_t </tt>
     *  - <tt>[U]Double_t</tt>
     */
    JRootDictionary() :
      JRootDictionary_t()
    {
#define VALUE_TYPE(__TYPE__) value_type(#__TYPE__, new JObjectStreamer<__TYPE__>())
 
      using namespace JPP;
 
      for_each(*this, JType<JRemove<JPrimitiveTypes_t, long double>::typelist>());
 
      (*this)(JType<std::string>());
      (*this)(JType<std::size_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));
 
#undef VALUE_TYPE
    }
 
    /**
     * Addition of class.
     *
     * \param  type          data type
     */
    template<class T>
    void operator()(const JType<T>& type)
    {
      this->insert(value_type(JRoot::getTypename<T>(), new JObjectStreamer<T>()));
 
      try {
        this->insert(value_type(JRoot::getTypename< std::vector<T> >(), new JObjectStreamer< std::vector<T> >()));
      }
      catch(const JException& error) {};
    }
 
    /**
     * Addition of class.
     */
    template<class T>
    void add()
    {
      (*this)(JType<T>());
    }
  };
}
 
 
/**
 * Global ROOT based dictionary for ASCII I/O.
 */
#define gRootDictionary (JROOT::JRootDictionary::getInstance())
 
 
/**
 * Add ASCII I/O for (list of) class(es) to dictionary.
 */
template<class T>
inline void addToRootDictionary()
{
  gRootDictionary.add<T>();
}
 
 
/**
 * Add ASCII I/O for given object to dictionary.
 *
 * \param  object        object
 */
template<class T>
inline void addToRootDictionary(const T& object)
{
  gRootDictionary.add<T>();
}
 
#endif