source: lemon-0.x/src/hugo/default_map_factory.h @ 798:6d1abeb62dd3

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


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

namespace hugo {

#define DEFAULT_MAP_BODY(Factory, Val) \
  { \
    typedef typename Factory<MapRegistry>::template Map<Val> MapImpl; \
  \
  public: \
  \
    typedef typename MapRegistry::Graph Graph; \
    typedef typename MapRegistry::Key Key; \
    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*);

  template <typename MapRegistry>
  class DefaultMapFactory {
                
  public:
                
    typedef typename MapRegistry::Graph Graph;
    typedef typename MapRegistry::Key Key;
    typedef typename MapRegistry::KeyIt KeyIt;

    typedef typename MapRegistry::MapBase MapBase;

    template <typename V> 
    class Map : public DefaultMap<MapRegistry, V> {

      typedef DefaultMap<MapRegistry, V> MapImpl;

    public:
      
      typedef V Value;

      Map() : MapImpl() {}

      Map(const Graph& g, MapRegistry& r) : MapImpl(g, r) {}

      Map(const Graph& g, MapRegistry& r, const Value& v) : MapImpl(g, r, v) {}

      Map(const Map& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {}

      template <typename CMap> Map(const CMap& copy) : MapImpl(copy) {}

      Map& operator=(const Map& copy) {
        MapImpl::operator=(static_cast<const MapImpl&>(copy));
        return *this;
      }

      template <typename CMap> Map& operator=(const CMap& copy) {
        MapImpl::operator=(copy);
        return *this;
      }

    };

  };
}

#endif