JAutoMap.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JAUTOMAP__
#define __JTOOLS__JAUTOMAP__
 
#include <map>
 
#include "JLang/JTypeList.hh"
#include "JLang/JType.hh"
#include "JLang/JNullType.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }
 
namespace JTOOLS {
 
  using JLANG::JTypeList;
  using JLANG::JType;
  using JLANG::JNullType;
 
 
  /**
   * Forward declaration of class JAutoMap for specialisation of class JAutomate.
   */
  template<class JKey_t, class JValue_t>
  class JAutoMap;
 
 
  /**
   * Auxiliary class for automatic element creation.
   *
   * The template argument corresponds to the data type of the elements in the map.
   * There should be a corresponding constructor <tt>JElement_t::JElement_t(JType<T>)</tt> 
   * for each data type <tt>T</tt> to be inserted in the map.
   */
  template<class JElement_t>
  struct JAutomate {
    /**
     * Get element.
     *
     * \param  type             data type
     * \return                  element
     */
    template<class T>
    static JElement_t getElement(JType<T> type)
    { 
      return JElement_t(type);
    }
  };
 
 
  /**
   * Specialisation of class JAutomate for class JAutoMap.
   *
   * By default, the creation of elements is transfered back to the map
   * via member method JAutoMap::getAutoElement.
   */
  template<class JKey_t, class JValue_t>
  struct JAutomate< JAutoMap<JKey_t, JValue_t> > {
 
    typedef JAutoMap<JKey_t, JValue_t>                           automap_type;
    typedef typename automap_type::value_type                    value_type;
 
    /**
     * Get element.
     *
     * \param  type             data type
     * \return                  element
     */
    template<class T>
    static value_type getElement(JType<T> type) 
    { 
      return automap_type::getAutoElement(type);
    }
  };
 
 
  /**
   * Wrapper class around std::map for automatic insertion of elements based on data types.
   */
  template<class JKey_t, class JValue_t>
  class JAutoMap :
    public std::map<JKey_t, JValue_t>
  {
  public:
 
    typedef std::map<JKey_t, JValue_t>                           map_type;
    typedef typename map_type::value_type                        value_type;
 
    using map_type::insert;
 
    /**
     * Default constructor.
     */
    JAutoMap() 
    {}
 
 
    /**
     * Creation of a map element for given data type.
     *
     * This method should be overloaded for the requested data types
     * if the method insert() is used without argument.
     *
     * \param  type             data type
     * \return                  element
     */
    template<class T>
    static value_type getAutoElement(JType<T> type);
 
 
    /**
     * Insert list of data types.
     */
    template<class T>
    void insert()
    {
      insert(JType<T>(), JAutomate<JAutoMap>());
    }
 
 
    /**
     * Insert (list of) data type(s).
     *
     * \param  automate         type defined element
     */
    template<class T, class JElement_t>
    void insert(const JAutomate<JElement_t>& automate)
    {
      insert(JType<T>(), automate);
    }
    
  protected:
    /**
     * Insertion of single data type.
     *
     * \param  type             data type
     * \param  automate         element automate by data type
     */
    template<class T, class JElement_t>
    void insert(JType<T>                     type,
                const JAutomate<JElement_t>& automate)
    {
      map_type::insert(automate.getElement(type));
    }
 
 
    /**
     * Recursive insertion of data types.
     *
     * \param  typelist         type list
     * \param  automate         element automate by data type
     */
    template<class JHead_t, class JTail_t, class JElement_t>
    void insert(JType< JTypeList<JHead_t, JTail_t> > typelist,
                const JAutomate<JElement_t>&         automate)
    {
      insert(JType<JHead_t>(), automate);
      insert(JType<JTail_t>(), automate);
    }
 
 
    /**
     * Template specialisation to terminate insertion of data types.
     *
     * \param  type             null type
     * \param  automate         element automate by data type
     */
    template<class JElement_t>
    void insert(JType<JNullType>             type,
                const JAutomate<JElement_t>& automate)
    {}
  };
}
 
#endif