// -*- c++ -*-
#ifndef DEFAULT_MAP_FACTORY_H
#define DEFAULT_MAP_FACTORY_H


#include <hugo/array_map_factory.h>
#include <hugo/vector_map_factory.h>

///\ingroup graphmapfactory
///\file
///\brief Graph maps that construates and destruates
///their elements dynamically.

namespace hugo {

/// \addtogroup graphmapfactory
/// @{

#define DEFAULT_MAP_BODY(Factory, Val) \
  { \
    typedef typename Factory<MapRegistry>::template Map<Val> MapImpl; \
  \
  public: \
  \
    typedef typename MapRegistry::Graph Graph; \
    typedef typename MapRegistry::KeyType KeyType; \
    typedef typename MapRegistry::KeyIt KeyIt; \
    typedef Val Value; \
  \
    typedef typename MapRegistry::MapBase MapBase; \
  \
    DefaultMap() : MapImpl() {} \
  \
    DefaultMap(const Graph& g, MapRegistry& r) : MapImpl(g, r) {} \
  \
    DefaultMap(const Graph& g, MapRegistry& r, const Value& v) \
      : MapImpl(g, r, v) {} \
  \
    DefaultMap(const DefaultMap& copy) \
      : MapImpl(static_cast<const MapImpl&>(copy)) {} \
  \
    template <typename CMap> DefaultMap(const CMap& copy) : MapImpl(copy) {} \
  \
    DefaultMap& operator=(const DefaultMap& copy) { \
      MapImpl::operator=(static_cast<const MapImpl&>(copy)); \
      return *this; \
    } \
  \
    template <typename CMap> DefaultMap& operator=(const CMap& copy) { \
      MapImpl::operator=(copy); \
      return *this; \
    } \
  \
  };


  template <typename MapRegistry, typename Type>
  class DefaultMap : public ArrayMapFactory<MapRegistry>::template Map<Type> 
  DEFAULT_MAP_BODY(ArrayMapFactory, Type);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, bool> 
    : public VectorMapFactory<MapRegistry>::template Map<bool> 
  DEFAULT_MAP_BODY(VectorMapFactory, bool);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, char> 
    : public VectorMapFactory<MapRegistry>::template Map<char> 
  DEFAULT_MAP_BODY(VectorMapFactory, char);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, int> 
    : public VectorMapFactory<MapRegistry>::template Map<int> 
  DEFAULT_MAP_BODY(VectorMapFactory, int);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, short> 
    : public VectorMapFactory<MapRegistry>::template Map<short> 
  DEFAULT_MAP_BODY(VectorMapFactory, short);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, long> 
    : public VectorMapFactory<MapRegistry>::template Map<long> 
  DEFAULT_MAP_BODY(VectorMapFactory, long);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, float> 
    : public VectorMapFactory<MapRegistry>::template Map<float> 
  DEFAULT_MAP_BODY(VectorMapFactory, float);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, double> 
    : public VectorMapFactory<MapRegistry>::template Map<double> 
  DEFAULT_MAP_BODY(VectorMapFactory, double);

  template <typename MapRegistry>
  class DefaultMap<MapRegistry, long double> 
    : public VectorMapFactory<MapRegistry>::template Map<long double> 
  DEFAULT_MAP_BODY(VectorMapFactory, long double);

  template <typename MapRegistry, typename Type>
  class DefaultMap<MapRegistry, Type*>
    : public VectorMapFactory<MapRegistry>::template Map<Type*> 
  DEFAULT_MAP_BODY(VectorMapFactory, Type*);


  /** The DefaultMapFactory template class is a factory class
   *  to create maps for the edge and nodes. This map factory
   *  uses the VectorMapFactory if the ValueType is a primitive
   *  type and the ArrayMapFactory for the other cases.
   *
   *  The template parameter is the MapRegistry that the maps
   *  will belong to.
   */

  template <typename MapRegistry>
  class DefaultMapFactory {
		
  public:
    /// The graph type of the maps. 
    typedef typename MapRegistry::Graph Graph;
    /// The key type of the maps.
    typedef typename MapRegistry::KeyType KeyType;
    /// The iterator to iterate on the keys.
    typedef typename MapRegistry::KeyIt KeyIt;

    /// The MapBase of the Map which imlements the core regisitry function.
    typedef typename MapRegistry::MapBase MapBase;
		

    /** The template Map type.
     */
    template <typename V> 
    class Map : public DefaultMap<MapRegistry, V> {

      typedef DefaultMap<MapRegistry, V> MapImpl;

    public:
      
      typedef V Value;

      /** Default constructor for the map.
       */
      Map() : MapImpl() {}

      /** Graph and Registry initialized map constructor.
       */
      Map(const Graph& g, MapRegistry& r) : MapImpl(g, r) {}

      /** Constructor to use default value to initialize the map. 
       */
      Map(const Graph& g, MapRegistry& r, const Value& v) : MapImpl(g, r, v) {}

      /** Constructor to copy a map of the same map type.
       */
      Map(const Map& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {}

      /** Constructor to copy a map of an other map type.
       */
      template <typename CMap> Map(const CMap& copy) : MapImpl(copy) {}

      /** Assign operator to copy a map of the same map type.
       */
      Map& operator=(const Map& copy) {
	MapImpl::operator=(static_cast<const MapImpl&>(copy));
	return *this;
      }

      /** Assign operator to copy a map an other map type.
       */
      template <typename CMap> Map& operator=(const CMap& copy) {
	MapImpl::operator=(copy);
	return *this;
      }

    };

  };
}

#endif