COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changeset 822:88226d9fe821 in lemon-0.x for src/hugo/map_defines.h


Ignore:
Timestamp:
09/08/04 14:06:45 (20 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1118
Message:

The MapFactories? have been removed from the code because
if we use macros then they increases only the complexity.

The pair iterators of the maps are separeted from the maps.

Some macros and comments has been changed.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/hugo/map_defines.h

    r785 r822  
    33#define MAP_DEFINES_H
    44
    5 ///\ingroup graphmapfactory
     5///\ingroup graphmaps
    66///\file
    77///\brief Defines to help creating graph maps.
    … …  
    3030CREATE_EDGE_MAP_REGISTRY
    3131
    32 /** Creates a concrete factory type from a template map
    33  *  factory to use as node map factory.
    34  */
    35 #define CREATE_NODE_MAP_FACTORY(TemplateFactory) \
    36 typedef TemplateFactory<NodeMapRegistry> NodeMapFactory;
    37 
    38 /** Creates a concrete factory type from a template map
    39  *  factory to use as edge map factory.
    40  */
    41 #define CREATE_EDGE_MAP_FACTORY(TemplateFactory) \
    42 typedef TemplateFactory<EdgeMapRegistry> EdgeMapFactory;
    43 
    44 /** Creates both map factories.
    45  */
    46 #define CREATE_MAP_FACTORIES(TemplateFactory) \
    47 CREATE_NODE_MAP_FACTORY(TemplateFactory) \
    48 CREATE_EDGE_MAP_FACTORY(TemplateFactory)
    49 
    50 /** Import a map from a concrete map factory. The import method is
     32/** Creates a map from a template map. The import method is
    5133 *  an overloading of the map type.
    5234 *  The reason to use these macro is that the c++ does not support
    … …  
    5436 *  supports this feature it should be fixed.
    5537 */
    56 #define IMPORT_NODE_MAP(Factory) \
    57 template <typename V> \
    58 class NodeMap : public Factory::template Map<V> { \
    59 typedef typename Factory::template Map<V> MapImpl; \
     38#define CREATE_NODE_MAP(DynMap) \
     39template <typename Value> \
     40class NodeMap : public DynMap<NodeMapRegistry, Value> { \
     41typedef DynMap<NodeMapRegistry, Value> MapImpl; \
    6042public: \
    6143NodeMap() {} \
    62 NodeMap(const Graph& g) : MapImpl(g, g.node_maps) {} \
    63 NodeMap(const Graph& g, const V& v) : MapImpl(g, g.node_maps, v) {} \
     44NodeMap(const typename MapImpl::Graph& g) \
     45  : MapImpl(g, g.node_maps) {} \
     46NodeMap(const typename MapImpl::Graph& g, const Value& v) \
     47  : MapImpl(g, g.node_maps, v) {} \
    6448NodeMap(const NodeMap& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {} \
    6549template <typename CMap> NodeMap(const CMap& copy) : MapImpl(copy) {} \
    … …  
    7458};
    7559
    76 /** Import a map from a concrete map factory. The import method is
     60/** Creates a map from a template map. The import method is
    7761 *  an overloading of the map type.
    7862 *  The reason to use these macro is that the c++ does not support
    … …  
    8064 *  supports this feature it should be fixed.
    8165 */
    82 #define IMPORT_EDGE_MAP(Factory) \
    83 template <typename V> \
    84 class EdgeMap : public Factory::template Map<V> { \
    85 typedef typename Factory::template Map<V> MapImpl; \
     66#define CREATE_EDGE_MAP(DynMap) \
     67template <typename Value> \
     68class EdgeMap : public DynMap<EdgeMapRegistry, Value> { \
     69typedef DynMap<EdgeMapRegistry, Value> MapImpl; \
    8670public: \
    8771EdgeMap() {} \
    88 EdgeMap(const Graph& g) : MapImpl(g, g.edge_maps) {} \
    89 EdgeMap(const Graph& g, const V& v) : MapImpl(g, g.edge_maps, v) {} \
     72EdgeMap(const typename MapImpl::Graph& g) \
     73  : MapImpl(g, g.edge_maps) {} \
     74EdgeMap(const typename MapImpl::Graph& g, const Value& v) \
     75  : MapImpl(g, g.edge_maps, v) {} \
    9076EdgeMap(const EdgeMap& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {} \
    9177template <typename CMap> EdgeMap(const CMap& copy) : MapImpl(copy) {} \
    … …  
    10086};
    10187
    102 /** This macro creates both map factories and imports both maps.
    103  */
    104 #define CREATE_MAPS(TemplateFactory) \
    105 CREATE_MAP_FACTORIES(TemplateFactory) \
    106 IMPORT_NODE_MAP(NodeMapFactory) \
    107 IMPORT_EDGE_MAP(EdgeMapFactory)
     88/** This macro creates both maps.
     89 */
     90#define CREATE_MAPS(DynMap) \
     91CREATE_NODE_MAP(DynMap) \
     92CREATE_EDGE_MAP(DynMap)
    10893
    10994/** This macro creates MapRegistry for Symmetric Edge Maps.
    … …  
    11499mutable EdgeMapRegistry sym_edge_maps;
    115100
    116 /** Creates a concrete factory type from a template map
    117  *  factory to use as edge map factory.
    118  */
    119 #define CREATE_SYM_EDGE_MAP_FACTORY(TemplateFactory) \
    120 typedef SymMapFactory<SymEdgeMapRegistry, TemplateFactory > \
    121 SymEdgeMapFactory;
    122 
    123 /** Import a map from a concrete map factory. The import method is
     101
     102/** Creates a map from a template map. The import method is
    124103 *  an overloading of the map type.
    125104 *  The reason to use these macro is that the c++ does not support
    … …  
    127106 *  supports this feature it should be fixed.
    128107 */
    129 #define IMPORT_SYM_EDGE_MAP(Factory) \
    130 template <typename V> \
    131 class SymEdgeMap : public Factory::template Map<V> { \
    132 typedef typename Factory::template Map<V> MapImpl; \
    133 public: \
    134 SymEdgeMap() {} \
    135 SymEdgeMap(const Graph& g) : MapImpl(g, g.sym_edge_maps) {} \
    136 SymEdgeMap(const Graph& g, const V& v) : MapImpl(g, g.sym_edge_maps, v) {} \
    137 SymEdgeMap(const SymEdgeMap& copy) \
    138   : MapImpl(static_cast<const MapImpl&>(copy)) {} \
    139 template <typename CMap> SymEdgeMap(const CMap& copy) : MapImpl(copy) {} \
    140 SymEdgeMap& operator=(const SymEdgeMap& copy) { \
    141   MapImpl::operator=(static_cast<const MapImpl&>(copy));\
    142   return *this; \
    143 } \
    144 template <typename CMap> SymEdgeMap& operator=(const CMap& copy) { \
    145   MapImpl::operator=(copy);\
    146   return *this; \
    147 } \
    148 };
    149 
    150 
    151 #define KEEP_NODE_MAP(GraphBase) \
    152     template <typename V> class NodeMap \
    153       : public GraphBase::template NodeMap<V> \
    154     { \
    155       typedef typename GraphBase::template NodeMap<V> MapImpl; \
    156       typedef V Value; \
    157     public: \
    158       NodeMap() : MapImpl() {} \
    159 \
    160       NodeMap(const Graph& graph) \
    161         : MapImpl(static_cast<const GraphBase&>(graph)) { } \
    162 \
    163       NodeMap(const Graph& graph, const Value& value) \
    164         : MapImpl(static_cast<const GraphBase&>(graph), value) { } \
    165 \
    166       NodeMap(const NodeMap& copy) \
    167         : MapImpl(static_cast<const MapImpl&>(copy)) {} \
    168 \
    169       template<typename CMap> \
    170       NodeMap(const CMap& copy) \
    171         : MapImpl(copy) {} \
    172 \
    173       NodeMap& operator=(const NodeMap& copy) { \
    174         MapImpl::operator=(static_cast<const MapImpl&>(copy)); \
    175         return *this; \
    176       } \
    177 \
    178       template <typename CMap> \
    179       NodeMap& operator=(const CMap& copy) { \
    180         MapImpl::operator=(copy); \
    181         return *this; \
    182       } \
    183     };
    184 
    185 #define KEEP_EDGE_MAP(GraphBase) \
    186     template <typename V> class EdgeMap \
    187       : public GraphBase::template EdgeMap<V> \
    188     { \
    189       typedef typename GraphBase::template EdgeMap<V> MapImpl; \
    190       typedef V Value; \
    191     public: \
    192       EdgeMap() : MapImpl() {} \
    193 \
    194       EdgeMap(const Graph& graph) \
    195         : MapImpl(static_cast<const GraphBase&>(graph)) { } \
    196 \
    197       EdgeMap(const Graph& graph, const Value& value) \
    198         : MapImpl(static_cast<const GraphBase&>(graph), value) { } \
    199 \
    200       EdgeMap(const EdgeMap& copy) \
    201         : MapImpl(static_cast<const MapImpl&>(copy)) {} \
    202 \
    203       template<typename CMap> \
    204       EdgeMap(const CMap& copy) \
    205         : MapImpl(copy) {} \
    206 \
    207       EdgeMap& operator=(const EdgeMap& copy) { \
    208         MapImpl::operator=(static_cast<const MapImpl&>(copy)); \
    209         return *this; \
    210       } \
    211 \
    212       template <typename CMap> \
    213       EdgeMap& operator=(const CMap& copy) { \
    214         MapImpl::operator=(copy); \
    215         return *this; \
    216       } \
    217     };
    218 
     108#define CREATE_SYM_EDGE_MAP(DynMap) \
     109template <typename Value> \
     110class SymEdgeMap : public SymMap<DynMap, SymEdgeMapRegistry, Value> { \
     111  typedef SymMap<DynMap, SymEdgeMapRegistry, Value> MapImpl; \
     112 public: \
     113\
     114  SymEdgeMap() {} \
     115\
     116  SymEdgeMap(const typename MapImpl::Graph& g) \
     117    : MapImpl(g, g.sym_edge_maps) {} \
     118\
     119  SymEdgeMap(const typename MapImpl::Graph& g, const Value& v) \
     120    : MapImpl(g, g.sym_edge_maps, v) {} \
     121\
     122  SymEdgeMap(const SymEdgeMap& copy) \
     123    : MapImpl(static_cast<const MapImpl&>(copy)) {} \
     124\
     125  template <typename CMap> SymEdgeMap(const CMap& copy) : MapImpl(copy) {} \
     126  SymEdgeMap& operator=(const SymEdgeMap& copy) { \
     127    MapImpl::operator=(static_cast<const MapImpl&>(copy));\
     128    return *this; \
     129  } \
     130\
     131  template <typename CMap> SymEdgeMap& operator=(const CMap& copy) { \
     132    MapImpl::operator=(copy);\
     133    return *this; \
     134  } \
     135};
     136
     137
     138/** This is a macro to import an node map into a graph class.
     139 */
     140#define IMPORT_NODE_MAP(From, from, To, to) \
     141template <typename Value> \
     142class NodeMap \
     143  : public From::template NodeMap<Value> { \
     144  typedef typename From::template NodeMap<Value> MapImpl; \
     145 public: \
     146   NodeMap() : MapImpl() {} \
     147\
     148   NodeMap(const To& to) \
     149     : MapImpl(static_cast<const From&>(from)) { } \
     150\
     151   NodeMap(const To& to, const Value& value) \
     152     : MapImpl(static_cast<const From&>(from), value) { } \
     153\
     154   NodeMap(const NodeMap& copy) \
     155     : MapImpl(static_cast<const MapImpl&>(copy)) {} \
     156\
     157   template<typename CMap> \
     158   NodeMap(const CMap& copy) \
     159     : MapImpl(copy) {} \
     160\
     161   NodeMap& operator=(const NodeMap& copy) { \
     162     MapImpl::operator=(static_cast<const MapImpl&>(copy)); \
     163     return *this; \
     164   } \
     165\
     166   template <typename CMap> \
     167   NodeMap& operator=(const CMap& copy) { \
     168     MapImpl::operator=(copy); \
     169     return *this; \
     170   } \
     171};
     172
     173/** This is a macro to import an edge map into a graph class.
     174 */
     175#define IMPORT_EDGE_MAP(From, from, To, to) \
     176template <typename Value> \
     177class EdgeMap \
     178  : public From::template EdgeMap<Value> { \
     179  typedef typename From::template EdgeMap<Value> MapImpl; \
     180 public: \
     181   EdgeMap() : MapImpl() {} \
     182\
     183   EdgeMap(const To& to) \
     184     : MapImpl(static_cast<const From&>(from)) { } \
     185\
     186   EdgeMap(const To& to, const Value& value) \
     187     : MapImpl(static_cast<const From&>(from), value) { } \
     188\
     189   EdgeMap(const EdgeMap& copy) \
     190     : MapImpl(static_cast<const MapImpl&>(copy)) {} \
     191\
     192   template<typename CMap> \
     193   EdgeMap(const CMap& copy) \
     194     : MapImpl(copy) {} \
     195\
     196   EdgeMap& operator=(const EdgeMap& copy) { \
     197     MapImpl::operator=(static_cast<const MapImpl&>(copy)); \
     198     return *this; \
     199   } \
     200\
     201   template <typename CMap> \
     202   EdgeMap& operator=(const CMap& copy) { \
     203     MapImpl::operator=(copy); \
     204     return *this; \
     205   } \
     206};
     207
     208
     209/** This is a macro to keep the node and edge maps for a graph class.
     210 */
     211#define KEEP_MAPS(From, To) \
     212IMPORT_EDGE_MAP(From, graph, To, graph) \
     213IMPORT_NODE_MAP(From, graph, To, graph)
    219214 
    220215/// @}
Note: See TracChangeset for help on using the changeset viewer.