#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;


  /**
   * \cond NEVER
   * Forward declaration for specialisation of class JAutomate.
   * \endcond
   */
  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.\n
   * There should be a corresponding constructor
   * <pre>
   *    JElement_t::JElement_t(JType<T>);
   * </pre> 
   * 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
   * by calling 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 types.
     *
     * \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