JSonSupportkit.hh

Go to the documentation of this file.

#ifndef __JDB_JSONSUPPORTKIT__
#define __JDB_JSONSUPPORTKIT__
 
#ifndef __ROOTCLING__
 
#include <sstream>
#include <vector>
#include <typeinfo>
#include <memory>
 
#include "TDictionary.h"
 
#include "JROOT/JRoot.hh"
#include "JROOT/JRootClass.hh"
 
#include "JLang/JException.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JPrimitiveTypes.hh"
#include "JLang/JSingleton.hh"
 
#include "JSon/JSon.hh"
 
#include "JDB/JDBString.hh"
 
/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }
 
namespace JDATABASE {
 
  using JSON::json;
  using JROOT::JRootWritableClass;
  using JROOT::JRootReadableClass;
  using JLANG::JException;
  using JLANG::JParserException;
  using JLANG::JSingleton;
 
 
  /**
   * Convert database string to JSon.
   *
   * \param  js         json
   * \param  object     database string
   */
  inline void to_json(json& js, const JDBString& object)
  {
    js = json(static_cast<const std::string&>(object));
  }
 
 
  /**
   * Convert JSon to database string.
   *
   * \param  js         json
   * \param  object     database string
   */
  inline void from_json(const json& js, JDBString& object)
  {
    static_cast<std::string&>(object) = js.get<std::string>();
  }
 
 
  /**
   * Assigment interface.
   */
  struct JSonIO {
 
    virtual ~JSonIO()
    {}
 
    virtual void to_json(json& js, const void* p) const = 0;
    virtual void from_json(const json& js, void* p) const = 0;
  };
 
 
  /**
   * Assigment implementation.
   */
  template<class T>
  struct JSonIO_t :
    public JSonIO
  {
    virtual void to_json(json& js, const void* p) const override
    { 
      js = * (const T*) p;
    }
    
    virtual void from_json(const json& js, void* p) const override
    {
      * (T*) p = js;
    }
  };
 
 
  /**
   * Assignment.
   */
  struct JSonDictionary :  
    public std::map< std::string, std::shared_ptr<JSonIO> >,
    public JSingleton<JSonDictionary>
  {
    /**
     * Default constructor.
     *
     * Removed types:
     *  - <tt>long double</tt> (not supported by ROOT TDictionary)
     *  - <tt>char</tt> (not supported by JSon)
     *
     * Added STL type definitions:
     *  - <tt>std::string</tt>
     *  - <tt>size_t</tt>
     *  - <tt>std::size_t</tt>
     *  - <tt>JDATABASE::JDBString</tt>
     */
    JSonDictionary()
    {
      using namespace JPP;
 
      for_each<JRemove<JPrimitiveTypes_t, JTypeList<char, long double> >::typelist>(*this);
 
      (*this)(JType<std::string>());
      (*this)(JType<size_t>());
      (*this)(JType<std::size_t>());
      (*this)(JType<JDATABASE::JDBString>());
    }
 
 
    /**
     * 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 data type.
     *
     * \param  type            data type
     */
    template<class T>
    void operator()(const JLANG::JType<T>& type)
    {
      (*this)[getTypename<T>()] = std::make_shared< JSonIO_t<T> >();
    }
  };
 
 
  /**
   * Auxiliary base class for JSon I/O based on ROOT dictionary.
   */
  template<class T>
  struct JSonHelper {
    /**
     * Convert object to JSon.
     *
     * \param  js         json
     * \param  object     object
     */
    friend inline void to_json(json& js, const T& object)
    {
      using namespace std;
      using namespace JPP;
 
      JRootWritableClass cls(object);
 
      for (unique_ptr<TIterator> i(cls.getClass()->GetListOfDataMembers()->MakeIterator()); const TDataMember* p = (const TDataMember*) i->Next(); ) {
 
        if (!JRoot::is_static(*p)) {
 
          JRootWritableClass abc = cls.get(*p);
 
          JSonDictionary::getInstance()[abc.getTypename()]->to_json(js[p->GetName()], abc.getAddress());
        }
      }
    }
 
 
    /**
     * Convert JSon to object/.
     *
     * \param  js         json
     * \param  object     object
     */
    friend inline void from_json(const json& js, T& object)
    {
      using namespace std;
      using namespace JPP;
 
      JRootReadableClass cls(object);
 
      for (unique_ptr<TIterator> i(cls.getClass()->GetListOfDataMembers()->MakeIterator()); const TDataMember* p = (const TDataMember*) i->Next(); ) {
 
        if (!JRoot::is_static(*p)) {
 
          JRootReadableClass abc = cls.get(*p);
 
          if (js.contains(p->GetName()))
            JSonDictionary::getInstance()[abc.getTypename()]->from_json(js[p->GetName()], abc.getAddress());
          else
            THROW(JParserException, "No key word <" << p->GetName() << "> in " << js);
        }
      }
    }
  };
}
 
#else
 
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }
 
namespace JDATABASE {
 
  template<class T>
  struct JSonHelper {};
}
#endif
 
#endif