// -*- c++ -*-

 #ifndef MAP_DEFINES_H

 #define MAP_DEFINES_H

 ///\ingroup graphmapfactory

 ///\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 concrete factory type from a template map

  *  factory to use as node map factory.

  */

 #define CREATE_NODE_MAP_FACTORY(TemplateFactory) \

 typedef TemplateFactory<NodeMapRegistry> NodeMapFactory;

 /** Creates a concrete factory type from a template map

  *  factory to use as edge map factory.

  */

 #define CREATE_EDGE_MAP_FACTORY(TemplateFactory) \

 typedef TemplateFactory<EdgeMapRegistry> EdgeMapFactory;

 /** Creates both map factories.

  */

 #define CREATE_MAP_FACTORIES(TemplateFactory) \

 CREATE_NODE_MAP_FACTORY(TemplateFactory) \

 CREATE_EDGE_MAP_FACTORY(TemplateFactory) 

 /** Import a map from a concrete map factory. 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 IMPORT_NODE_MAP(Factory) \

 template <typename V> \

 class NodeMap : public Factory::template Map<V> { \

 typedef typename Factory::template Map<V> MapImpl; \

 public: \

 NodeMap() {} \

 NodeMap(const Graph& g) : MapImpl(g, g.node_maps) {} \

 NodeMap(const Graph& g, const V& 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; \

 } \

 };

 /** Import a map from a concrete map factory. 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 IMPORT_EDGE_MAP(Factory) \

 template <typename V> \

 class EdgeMap : public Factory::template Map<V> { \

 typedef typename Factory::template Map<V> MapImpl; \

 public: \

 EdgeMap() {} \

 EdgeMap(const Graph& g) : MapImpl(g, g.edge_maps) {} \

 EdgeMap(const Graph& g, const V& 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 map factories and imports both maps.

  */

 #define CREATE_MAPS(TemplateFactory) \

 CREATE_MAP_FACTORIES(TemplateFactory) \

 IMPORT_NODE_MAP(NodeMapFactory) \

 IMPORT_EDGE_MAP(EdgeMapFactory)

 /** 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 EdgeMapRegistry sym_edge_maps;

 /** Creates a concrete factory type from a template map

  *  factory to use as edge map factory.

  */

 #define CREATE_SYM_EDGE_MAP_FACTORY(TemplateFactory) \

 typedef SymMapFactory<SymEdgeMapRegistry, TemplateFactory > \

 SymEdgeMapFactory;

 /** Import a map from a concrete map factory. 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 IMPORT_SYM_EDGE_MAP(Factory) \

 template <typename V> \

 class SymEdgeMap : public Factory::template Map<V> { \

 typedef typename Factory::template Map<V> MapImpl; \

 public: \

 SymEdgeMap() {} \

 SymEdgeMap(const Graph& g) : MapImpl(g, g.sym_edge_maps) {} \

 SymEdgeMap(const Graph& g, const V& 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; \

 } \

 };

 #define KEEP_NODE_MAP(GraphBase) \

     template <typename V> class NodeMap \

       : public GraphBase::template NodeMap<V> \

     { \

       typedef typename GraphBase::template NodeMap<V> MapImpl; \

       typedef V Value; \

     public: \

       NodeMap() : MapImpl() {} \

 \

       NodeMap(const Graph& graph) \

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

 \

       NodeMap(const Graph& graph, const Value& value) \

 	: MapImpl(static_cast<const GraphBase&>(graph), 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; \

       } \

     };

 #define KEEP_EDGE_MAP(GraphBase) \

     template <typename V> class EdgeMap \

       : public GraphBase::template EdgeMap<V> \

     { \

       typedef typename GraphBase::template EdgeMap<V> MapImpl; \

       typedef V Value; \

     public: \

       EdgeMap() : MapImpl() {} \

 \

       EdgeMap(const Graph& graph) \

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

 \

       EdgeMap(const Graph& graph, const Value& value) \

 	: MapImpl(static_cast<const GraphBase&>(graph), 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; \

       } \

     };

 /// @}

 #endif