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/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 TDictionary)
     *
     * Added STL type definitions:
     *  - <tt>std::size_t</tt>
     *  - <tt>std::string</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;

      this->add(JType<JRemove<JPrimitiveTypes_t, long double>::typelist>());

      this->add(JType<std::string>());

      this->insert(VALUE_TYPE(size_t));
      this->insert(VALUE_TYPE(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(Long64_t));
      this->insert(VALUE_TYPE(ULong64_t));
      this->insert(VALUE_TYPE(Float_t));
      this->insert(VALUE_TYPE(Double_t));

#undef VALUE_TYPE
    }


    /**
     * Get typename for given template class.
     *
     * This method uses the TDictionary class to get the name of the given class.
     *
     * \return               type name
     */
    template<class T>
    static const char* getTypename()
    {
      const TDictionary* pDictionary = TDictionary::GetDictionary(typeid(T));

      if (pDictionary != NULL)
        return pDictionary->GetName(); 
      else
        THROW(JException, "Data type not implemented.");
    }


    /**
     * Add ASCII I/O for given (list of) class(es) to dictionary.
     */
    template<class T>
    void add()
    {
      add(JType<T>());
    }


  protected:
    /**
     * Addition of class.
     *
     * \param  type          data type
     */
    template<class T>
    void add(const JType<T>& type)
    {
      this->insert(value_type(getTypename<T>(), new JObjectStreamer<T>()));

      try {
        this->insert(value_type(getTypename< std::vector<T> >(), new JObjectStreamer< std::vector<T> >()));
      }
      catch(const JException& error) {};
    }


    /**
     * Addition of <tt>std::vector</tt>.
     *
     * \param  type          data type
     */
    template<class JElement_t, class JAllocator_t>
    void add(const JType< std::vector<JElement_t, JAllocator_t> >& type)
    {
      typedef std::vector<JElement_t, JAllocator_t>  data_type;

      this->insert(value_type(getTypename<data_type>(), new JObjectStreamer<data_type>()));
    }


    /**
     * Recursive addition of classes.
     *
     * \param  typelist      type list
     */
    template<class JHead_t, class JTail_t>
    void add(const JType< JTypeList<JHead_t, JTail_t> >& typelist)
    {
      add(JType<JHead_t>());
      add(JType<JTail_t>());
    }


    /**
     * Template specialisation to terminate addition of classes.
     *
     * \param  type          null type
     */
    void add(const JType<JNullType>& type)
    {}
  };
}


/**
 * 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