// -*- c++ -*-

#ifndef MAP_DEFINES_H

#define MAP_DEFINES_H

///\ingroup graphmaps

///\file

///\brief Defines to help creating graph maps.

/// \addtogroup graphmapfactory

/// @{

/** Creates the EdgeMapRegistry type an declare a mutable instance 

 *  named edge_maps.

 */

#define CREATE_EDGE_MAP_REGISTRY \

typedef MapRegistry<Graph, Edge, EdgeIt> EdgeMapRegistry; \

mutable EdgeMapRegistry edge_maps;

/** Creates the NodeMapRegistry type an declare a mutable instance 

 *  named node_maps.

 */

#define CREATE_NODE_MAP_REGISTRY \

typedef MapRegistry<Graph, Node, NodeIt> NodeMapRegistry; \

mutable NodeMapRegistry node_maps;

/** Creates both map registries.

 */

#define CREATE_MAP_REGISTRIES \

CREATE_NODE_MAP_REGISTRY \

CREATE_EDGE_MAP_REGISTRY

/** Creates a map from a template map. The import method is

 *  an overloading of the map type.

 *  The reason to use these macro is that the c++ does not support

 *  the template typedefs. If a future release of the c++ 

 *  supports this feature it should be fixed.

 */

#define CREATE_NODE_MAP(DynMap) \

template <typename Value> \

class NodeMap : public DynMap<NodeMapRegistry, Value> { \

typedef DynMap<NodeMapRegistry, Value> MapImpl; \

public: \

NodeMap() {} \

NodeMap(const typename MapImpl::Graph& g) \

  : MapImpl(g, g.node_maps) {} \

NodeMap(const typename MapImpl::Graph& g, const Value& v) \

  : MapImpl(g, g.node_maps, v) {} \

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

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

NodeMap& operator=(const NodeMap& copy) { \

  MapImpl::operator=(static_cast<const MapImpl&>(copy));\

  return *this; \

} \

template <typename CMap> NodeMap& operator=(const CMap& copy) { \

  MapImpl::operator=(copy);\

  return *this; \

} \

};

/** Creates a map from a template map. The import method is

 *  an overloading of the map type.

 *  The reason to use these macro is that the c++ does not support

 *  the template typedefs. If a future release of the c++ 

 *  supports this feature it should be fixed.

 */

#define CREATE_EDGE_MAP(DynMap) \

template <typename Value> \

class EdgeMap : public DynMap<EdgeMapRegistry, Value> { \

typedef DynMap<EdgeMapRegistry, Value> MapImpl; \

public: \

EdgeMap() {} \

EdgeMap(const typename MapImpl::Graph& g) \

  : MapImpl(g, g.edge_maps) {} \

EdgeMap(const typename MapImpl::Graph& g, const Value& v) \

  : MapImpl(g, g.edge_maps, v) {} \

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

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

EdgeMap& operator=(const EdgeMap& copy) { \

  MapImpl::operator=(static_cast<const MapImpl&>(copy));\

  return *this; \

} \

template <typename CMap> EdgeMap& operator=(const CMap& copy) { \

  MapImpl::operator=(copy);\

  return *this; \

} \

};

/** This macro creates both maps.

 */

#define CREATE_MAPS(DynMap) \

CREATE_NODE_MAP(DynMap) \

CREATE_EDGE_MAP(DynMap)

/** This macro creates MapRegistry for Symmetric Edge Maps.

 */

#define CREATE_SYM_EDGE_MAP_REGISTRY \

typedef SymEdgeIt<Graph, Edge, EdgeIt> SymEdgeIt; \

typedef MapRegistry<Graph, Edge, SymEdgeIt> SymEdgeMapRegistry; \

mutable SymEdgeMapRegistry sym_edge_maps;

/** Creates a map from a template map. The import method is

 *  an overloading of the map type.

 *  The reason to use these macro is that the c++ does not support

 *  the template typedefs. If a future release of the c++ 

 *  supports this feature it should be fixed.

 */

#define CREATE_SYM_EDGE_MAP(DynMap) \

template <typename Value> \

class SymEdgeMap : public SymMap<DynMap, SymEdgeMapRegistry, Value> { \

  typedef SymMap<DynMap, SymEdgeMapRegistry, Value> MapImpl; \

 public: \

\

  SymEdgeMap() {} \

\

  SymEdgeMap(const typename MapImpl::Graph& g) \

    : MapImpl(g, g.sym_edge_maps) {} \

\

  SymEdgeMap(const typename MapImpl::Graph& g, const Value& v) \

    : MapImpl(g, g.sym_edge_maps, v) {} \

\

  SymEdgeMap(const SymEdgeMap& copy) \

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

\

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

  SymEdgeMap& operator=(const SymEdgeMap& copy) { \

    MapImpl::operator=(static_cast<const MapImpl&>(copy));\

    return *this; \

  } \

\

  template <typename CMap> SymEdgeMap& operator=(const CMap& copy) { \

    MapImpl::operator=(copy);\

    return *this; \

  } \

};

/** This is a macro to import an node map into a graph class.

 */

#define IMPORT_NODE_MAP(From, from, To, to) \

template <typename Value> \

class NodeMap \

  : public From::template NodeMap<Value> { \

  typedef typename From::template NodeMap<Value> MapImpl; \

 public: \

   NodeMap() : MapImpl() {} \

\

   NodeMap(const To& to) \

     : MapImpl(static_cast<const From&>(from)) { } \

\

   NodeMap(const To& to, const Value& value) \

     : MapImpl(static_cast<const From&>(from), value) { } \

\

   NodeMap(const NodeMap& copy) \

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

\

   template<typename CMap> \

   NodeMap(const CMap& copy) \

     : MapImpl(copy) {} \

\

   NodeMap& operator=(const NodeMap& copy) { \

     MapImpl::operator=(static_cast<const MapImpl&>(copy)); \

     return *this; \

   } \

\

   template <typename CMap> \

   NodeMap& operator=(const CMap& copy) { \

     MapImpl::operator=(copy); \

     return *this; \

   } \

};

/** This is a macro to import an edge map into a graph class.

 */

#define IMPORT_EDGE_MAP(From, from, To, to) \

template <typename Value> \

class EdgeMap \

  : public From::template EdgeMap<Value> { \

  typedef typename From::template EdgeMap<Value> MapImpl; \

 public: \

   EdgeMap() : MapImpl() {} \

\

   EdgeMap(const To& to) \

     : MapImpl(static_cast<const From&>(from)) { } \

\

   EdgeMap(const To& to, const Value& value) \

     : MapImpl(static_cast<const From&>(from), value) { } \

\

   EdgeMap(const EdgeMap& copy) \

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

\

   template<typename CMap> \

   EdgeMap(const CMap& copy) \

     : MapImpl(copy) {} \

\

   EdgeMap& operator=(const EdgeMap& copy) { \

     MapImpl::operator=(static_cast<const MapImpl&>(copy)); \

     return *this; \

   } \

\

   template <typename CMap> \

   EdgeMap& operator=(const CMap& copy) { \

     MapImpl::operator=(copy); \

     return *this; \

   } \

};

#define KEEP_EDGE_MAP(From, To) \

IMPORT_EDGE_MAP(From, graph, To, graph)

#define KEEP_NODE_MAP(From, To) \

IMPORT_NODE_MAP(From, graph, To, graph)

/** This is a macro to keep the node and edge maps for a graph class.

 */

#define KEEP_MAPS(From, To) \

KEEP_EDGE_MAP(From, To) \

KEEP_NODE_MAP(From, To)

/// @}

#endif