lemon-0.x: src/work/deba/map_defines.h@a1abe9452199

     1 // -*- c++ -*-

     2 #ifndef MAP_DEFINES_H

     3 #define MAP_DEFINES_H

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

     6  *  named edge_maps.

     7  */

     8 #define CREATE_EDGE_MAP_REGISTRY \

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

    10 mutable EdgeMapRegistry edge_maps;

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

    13  *  named node_maps.

    14  */

    15 #define CREATE_NODE_MAP_REGISTRY \

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

    17 mutable NodeMapRegistry node_maps;

    19 /** Creates both map registries.

    20  */

    21 #define CREATE_MAP_REGISTRIES \

    22 CREATE_NODE_MAP_REGISTRY \

    23 CREATE_EDGE_MAP_REGISTRY

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

    26  *  factory to use as node map factory.

    27  */

    28 #define CREATE_NODE_MAP_FACTORY(TemplateFactory) \

    29 typedef TemplateFactory<NodeMapRegistry> NodeMapFactory;

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

    32  *  factory to use as edge map factory.

    33  */

    34 #define CREATE_EDGE_MAP_FACTORY(TemplateFactory) \

    35 typedef TemplateFactory<EdgeMapRegistry> EdgeMapFactory;

    37 /** Creates both map factories.

    38  */

    39 #define CREATE_MAP_FACTORIES(TemplateFactory) \

    40 CREATE_NODE_MAP_FACTORY(TemplateFactory) \

    41 CREATE_EDGE_MAP_FACTORY(TemplateFactory)

    43 /** Import a map from a concrete map factory. The import method is

    44  *  an overloading of the map type.

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

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

    47  *  supports this feature it should be fixed.

    48  */

    49 #define IMPORT_NODE_MAP(Factory) \

    50 template <typename V> \

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

    52 public: \

    53 NodeMap() {} \

    54 NodeMap(const Graph& g) : Factory::Map<V>(&g, &(g.node_maps)) {} \

    55 NodeMap(const Graph& g, const V& v) : Factory::Map<V>(g, g.node_maps, v) {} \

    56 NodeMap(const NodeMap& copy) \

    57   : Factory::Map<V>(static_cast<const Factory::Map<V>&>(copy)) {} \

    58 template <typename CMap> NodeMap(const CMap& copy) : Factory::Map<V>(copy) {} \

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

    60   this->Factory::Map<V>::operator=(static_cast<Factory::Map<V>&>(copy)); \

    61   return *this; \

    62 } \

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

    64   this->Factory::Map<V>::operator=<CMap>(static_cast<Factory::Map<V>&>(copy));\

    65   return *this; \

    66 } \

    67 };

    69 /** Import a map from a concrete map factory. The import method is

    70  *  an overloading of the map type.

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

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

    73  *  supports this feature it should be fixed.

    74  */

    75 #define IMPORT_EDGE_MAP(Factory) \

    76 template <typename V> \

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

    78 public: \

    79 EdgeMap() {} \

    80 EdgeMap(const Graph& g) : Factory::Map<V>(g, g.edge_maps) {} \

    81 EdgeMap(const Graph& g, const V& v) : Factory::Map<V>(g, g.node_maps, v) {} \

    82 EdgeMap(const EdgeMap& copy) \

    83   : Factory::Map<V>(static_cast<Factory::Map<V>&>(copy)) {} \

    84 template <typename CMap> EdgeMap(const CMap& copy) : Factory::Map<V>(copy) {} \

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

    86   this->Factory::Map<V>::operator=(static_cast<Factory::Map<V>&>(copy)); \

    87   return *this; \

    88 } \

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

    90   this->Factory::Map<V>::operator=<CMap>(static_cast<Factory::Map<V>&>(copy));\

    91   return *this; \

    92 } \

    93 };

    95 /** This macro creates both map factories and imports both maps.

    96  */

    97 #define CREATE_MAPS(TemplateFactory) \

    98 CREATE_MAP_FACTORIES(TemplateFactory) \

    99 IMPORT_NODE_MAP(NodeMapFactory) \

   100 IMPORT_EDGE_MAP(EdgeMapFactory)

   102 #endif

author	athos
	Thu, 03 Mar 2005 17:18:27 +0000
changeset 1182	a1abe9452199
parent 703	32f280a5ed7d
permissions	-rw-r--r--