COIN-OR::LEMON - Graph Library

Changeset 2031:080d51024ac5 in lemon-0.x for lemon/bits


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

Correcting the structure of the graph's and adaptor's map.
The template assign operators and map iterators can be used for adaptors also.

Some bugfix in the adaptors

New class SwapBpUGraphAdaptor which swaps the two nodeset of the graph.

Location:
lemon/bits
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • lemon/bits/array_map.h

    r1999 r2031  
    2424#include <lemon/bits/traits.h>
    2525#include <lemon/bits/alteration_notifier.h>
     26#include <lemon/concept_check.h>
     27#include <lemon/concept/maps.h>
    2628
    2729/// \ingroup graphbits
     
    120122    }
    121123
     124    /// \brief Assign operator.
     125    ///
     126    /// This operator assigns for each item in the map the
     127    /// value mapped to the same item in the copied map. 
     128    /// The parameter map should be indiced with the same
     129    /// itemset because this assign operator does not change
     130    /// the container of the map.
     131    ArrayMap& operator=(const ArrayMap& cmap) {
     132      return operator=<ArrayMap>(cmap);
     133    }
     134
     135
     136    /// \brief Template assign operator.
     137    ///
     138    /// The given parameter should be conform to the ReadMap
     139    /// concecpt and could be indiced by the current item set of
     140    /// the NodeMap. In this case the value for each item
     141    /// is assigned by the value of the given ReadMap.
     142    template <typename CMap>
     143    ArrayMap& operator=(const CMap& cmap) {
     144      checkConcept<concept::ReadMap<Key, _Value>, CMap>();
     145      const typename Parent::Notifier* notifier = Parent::getNotifier();
     146      Item it;
     147      for (notifier->first(it); it != INVALID; notifier->next(it)) {
     148        set(it, cmap[it]);
     149      }
     150      return *this;
     151    }
     152
    122153    /// \brief The destructor of the map.
    123154    ///     
     
    130161    }
    131162               
    132   private:
    133 
    134     ArrayMap& operator=(const ArrayMap&);
    135 
    136163  protected:
    137164
  • lemon/bits/base_extender.h

    r1999 r2031  
    467467      return Edge(edge, direction);
    468468    }
     469
     470    int edgeNum() const {
     471      return 2 * Parent::edgeNum();
     472    }
     473
     474    int uEdgeNum() const {
     475      return Parent::edgeNum();
     476    }
     477
    469478  };
    470479
  • lemon/bits/default_map.h

    r1999 r2031  
    164164      : Parent(graph, value) {}
    165165
     166    DefaultMap& operator=(const DefaultMap& cmap) {
     167      return operator=<DefaultMap>(cmap);
     168    }
     169
     170    template <typename CMap>
     171    DefaultMap& operator=(const CMap& cmap) {
     172      Parent::operator=(cmap);
     173      return *this;
     174    }
     175
    166176  };
    167177
  • lemon/bits/edge_set_extender.h

    r1999 r2031  
    102102
    103103      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
    104         _graph.first(*static_cast<Node*>(this));
     104        _graph.first(static_cast<Node&>(*this));
    105105      }
    106106
     
    125125
    126126      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
    127         _graph.first(*static_cast<Edge*>(this));
     127        _graph.first(static_cast<Edge&>(*this));
    128128      }
    129129
     
    236236      template <typename CMap>
    237237      EdgeMap& operator=(const CMap& cmap) {
    238         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    239         const typename Parent::Graph* graph = Parent::getGraph();
    240         Edge it;
    241         for (graph->first(it); it != INVALID; graph->next(it)) {
    242           Parent::set(it, cmap[it]);
    243         }
     238        Parent::operator=(cmap);
    244239        return *this;
    245240      }
     241
    246242    };
    247243
     
    365361
    366362      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
    367         _graph.first(*static_cast<Node*>(this));
     363        _graph.first(static_cast<Node&>(*this));
    368364      }
    369365
     
    388384
    389385      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
    390         _graph.first(*static_cast<Edge*>(this));
     386        _graph.first(static_cast<Edge&>(*this));
    391387      }
    392388
     
    459455
    460456      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
    461         _graph.first(*static_cast<UEdge*>(this));
     457        _graph.first(static_cast<UEdge&>(*this));
    462458      }
    463459
     
    557553      template <typename CMap>
    558554      EdgeMap& operator=(const CMap& cmap) {
    559         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    560         const typename Parent::Graph* graph = Parent::getGraph();
    561         Edge it;
    562         for (graph->first(it); it != INVALID; graph->next(it)) {
    563           Parent::set(it, cmap[it]);
    564         }
     555        Parent::operator=(cmap);
    565556        return *this;
    566557      }
     558
    567559    };
    568560
     
    577569      UEdgeMap(const Graph& _g)
    578570        : Parent(_g) {}
     571
    579572      UEdgeMap(const Graph& _g, const _Value& _v)
    580573        : Parent(_g, _v) {}
     
    586579      template <typename CMap>
    587580      UEdgeMap& operator=(const CMap& cmap) {
    588         checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
    589         const typename Parent::Graph* graph = Parent::getGraph();
    590         UEdge it;
    591         for (graph->first(it); it != INVALID; graph->next(it)) {
    592           Parent::set(it, cmap[it]);
    593         }
     581        Parent::operator=(cmap);
    594582        return *this;
    595583      }
     584
    596585    };
    597586
  • lemon/bits/graph_adaptor_extender.h

    r1996 r2031  
    3434  ///
    3535  /// \brief Extender for the GraphAdaptors
    36   template <typename Base>
    37   class GraphAdaptorExtender : public Base {
     36  template <typename _Graph>
     37  class GraphAdaptorExtender : public _Graph {
    3838  public:
    3939
    40     typedef Base Parent;
    41     typedef GraphAdaptorExtender Graph;
     40    typedef _Graph Parent;
     41    typedef _Graph Graph;
     42    typedef GraphAdaptorExtender Adaptor;
    4243
    4344    // Base extensions
     
    7273
    7374    class NodeIt : public Node {
    74       const Graph* graph;
     75      const Adaptor* graph;
    7576    public:
    7677
     
    7980      NodeIt(Invalid i) : Node(i) { }
    8081
    81       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
    82         _graph.first(*static_cast<Node*>(this));
    83       }
    84 
    85       NodeIt(const Graph& _graph, const Node& node)
     82      explicit NodeIt(const Adaptor& _graph) : graph(&_graph) {
     83        _graph.first(static_cast<Node&>(*this));
     84      }
     85
     86      NodeIt(const Adaptor& _graph, const Node& node)
    8687        : Node(node), graph(&_graph) {}
    8788
     
    9596
    9697    class EdgeIt : public Edge {
    97       const Graph* graph;
     98      const Adaptor* graph;
    9899    public:
    99100
     
    102103      EdgeIt(Invalid i) : Edge(i) { }
    103104
    104       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
    105         _graph.first(*static_cast<Edge*>(this));
    106       }
    107 
    108       EdgeIt(const Graph& _graph, const Edge& e) :
     105      explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) {
     106        _graph.first(static_cast<Edge&>(*this));
     107      }
     108
     109      EdgeIt(const Adaptor& _graph, const Edge& e) :
    109110        Edge(e), graph(&_graph) { }
    110111
     
    118119
    119120    class OutEdgeIt : public Edge {
    120       const Graph* graph;
     121      const Adaptor* graph;
    121122    public:
    122123
     
    125126      OutEdgeIt(Invalid i) : Edge(i) { }
    126127
    127       OutEdgeIt(const Graph& _graph, const Node& node)
     128      OutEdgeIt(const Adaptor& _graph, const Node& node)
    128129        : graph(&_graph) {
    129130        _graph.firstOut(*this, node);
    130131      }
    131132
    132       OutEdgeIt(const Graph& _graph, const Edge& edge)
     133      OutEdgeIt(const Adaptor& _graph, const Edge& edge)
    133134        : Edge(edge), graph(&_graph) {}
    134135
     
    142143
    143144    class InEdgeIt : public Edge {
    144       const Graph* graph;
     145      const Adaptor* graph;
    145146    public:
    146147
     
    149150      InEdgeIt(Invalid i) : Edge(i) { }
    150151
    151       InEdgeIt(const Graph& _graph, const Node& node)
     152      InEdgeIt(const Adaptor& _graph, const Node& node)
    152153        : graph(&_graph) {
    153154        _graph.firstIn(*this, node);
    154155      }
    155156
    156       InEdgeIt(const Graph& _graph, const Edge& edge) :
     157      InEdgeIt(const Adaptor& _graph, const Edge& edge) :
    157158        Edge(edge), graph(&_graph) {}
    158159
     
    198199  ///
    199200  /// \brief Extender for the UGraphAdaptors
    200   template <typename Base>
    201   class UGraphAdaptorExtender : public Base {
     201  template <typename _UGraph>
     202  class UGraphAdaptorExtender : public _UGraph {
    202203  public:
    203204   
    204     typedef Base Parent;
    205     typedef UGraphAdaptorExtender Graph;
     205    typedef _UGraph Parent;
     206    typedef _UGraph UGraph;
     207    typedef UGraphAdaptorExtender Adaptor;
    206208
    207209    typedef typename Parent::Node Node;
     
    255257
    256258    class NodeIt : public Node {
    257       const Graph* graph;
     259      const Adaptor* graph;
    258260    public:
    259261
     
    262264      NodeIt(Invalid i) : Node(i) { }
    263265
    264       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
    265         _graph.first(*static_cast<Node*>(this));
    266       }
    267 
    268       NodeIt(const Graph& _graph, const Node& node)
     266      explicit NodeIt(const Adaptor& _graph) : graph(&_graph) {
     267        _graph.first(static_cast<Node&>(*this));
     268      }
     269
     270      NodeIt(const Adaptor& _graph, const Node& node)
    269271        : Node(node), graph(&_graph) {}
    270272
     
    278280
    279281    class EdgeIt : public Edge {
    280       const Graph* graph;
     282      const Adaptor* graph;
    281283    public:
    282284
     
    285287      EdgeIt(Invalid i) : Edge(i) { }
    286288
    287       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
    288         _graph.first(*static_cast<Edge*>(this));
    289       }
    290 
    291       EdgeIt(const Graph& _graph, const Edge& e) :
     289      explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) {
     290        _graph.first(static_cast<Edge&>(*this));
     291      }
     292
     293      EdgeIt(const Adaptor& _graph, const Edge& e) :
    292294        Edge(e), graph(&_graph) { }
    293295
     
    301303
    302304    class OutEdgeIt : public Edge {
    303       const Graph* graph;
     305      const Adaptor* graph;
    304306    public:
    305307
     
    308310      OutEdgeIt(Invalid i) : Edge(i) { }
    309311
    310       OutEdgeIt(const Graph& _graph, const Node& node)
     312      OutEdgeIt(const Adaptor& _graph, const Node& node)
    311313        : graph(&_graph) {
    312314        _graph.firstOut(*this, node);
    313315      }
    314316
    315       OutEdgeIt(const Graph& _graph, const Edge& edge)
     317      OutEdgeIt(const Adaptor& _graph, const Edge& edge)
    316318        : Edge(edge), graph(&_graph) {}
    317319
     
    325327
    326328    class InEdgeIt : public Edge {
    327       const Graph* graph;
     329      const Adaptor* graph;
    328330    public:
    329331
     
    332334      InEdgeIt(Invalid i) : Edge(i) { }
    333335
    334       InEdgeIt(const Graph& _graph, const Node& node)
     336      InEdgeIt(const Adaptor& _graph, const Node& node)
    335337        : graph(&_graph) {
    336338        _graph.firstIn(*this, node);
    337339      }
    338340
    339       InEdgeIt(const Graph& _graph, const Edge& edge) :
     341      InEdgeIt(const Adaptor& _graph, const Edge& edge) :
    340342        Edge(edge), graph(&_graph) {}
    341343
     
    348350
    349351    class UEdgeIt : public Parent::UEdge {
    350       const Graph* graph;
     352      const Adaptor* graph;
    351353    public:
    352354
     
    355357      UEdgeIt(Invalid i) : UEdge(i) { }
    356358
    357       explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
    358         _graph.first(*static_cast<UEdge*>(this));
    359       }
    360 
    361       UEdgeIt(const Graph& _graph, const UEdge& e) :
     359      explicit UEdgeIt(const Adaptor& _graph) : graph(&_graph) {
     360        _graph.first(static_cast<UEdge&>(*this));
     361      }
     362
     363      UEdgeIt(const Adaptor& _graph, const UEdge& e) :
    362364        UEdge(e), graph(&_graph) { }
    363365
     
    371373    class IncEdgeIt : public Parent::UEdge {
    372374      friend class UGraphAdaptorExtender;
    373       const Graph* graph;
     375      const Adaptor* graph;
    374376      bool direction;
    375377    public:
     
    379381      IncEdgeIt(Invalid i) : UEdge(i), direction(false) { }
    380382
    381       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
     383      IncEdgeIt(const Adaptor& _graph, const Node &n) : graph(&_graph) {
    382384        _graph.firstInc(static_cast<UEdge&>(*this), direction, n);
    383385      }
    384386
    385       IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
     387      IncEdgeIt(const Adaptor& _graph, const UEdge &ue, const Node &n)
    386388        : graph(&_graph), UEdge(ue) {
    387389        direction = (_graph.source(ue) == n);
     
    437439  };
    438440
     441  /// \ingroup graphbits
     442  ///
     443  /// \brief Extender for the BpUGraphAdaptors
     444  template <typename Base>
     445  class BpUGraphAdaptorExtender : public Base {
     446  public:
     447    typedef Base Parent;
     448    typedef BpUGraphAdaptorExtender Graph;
     449
     450    typedef typename Parent::Node Node;
     451    typedef typename Parent::BNode BNode;
     452    typedef typename Parent::ANode ANode;
     453    typedef typename Parent::Edge Edge;
     454    typedef typename Parent::UEdge UEdge;
     455
     456    Node oppositeNode(const UEdge& edge, const Node& node) const {
     457      return source(edge) == node ?
     458        target(edge) : source(edge);
     459    }
     460
     461
     462    int maxId(Node) const {
     463      return Parent::maxNodeId();
     464    }
     465    int maxId(BNode) const {
     466      return Parent::maxBNodeId();
     467    }
     468    int maxId(ANode) const {
     469      return Parent::maxANodeId();
     470    }
     471    int maxId(Edge) const {
     472      return Parent::maxEdgeId();
     473    }
     474    int maxId(UEdge) const {
     475      return Parent::maxUEdgeId();
     476    }
     477
     478
     479    Node fromId(int id, Node) const {
     480      return Parent::nodeFromId(id);
     481    }
     482    ANode fromId(int id, ANode) const {
     483      return Parent::fromANodeId(id);
     484    }
     485    BNode fromId(int id, BNode) const {
     486      return Parent::fromBNodeId(id);
     487    }
     488    Edge fromId(int id, Edge) const {
     489      return Parent::edgeFromId(id);
     490    }
     491    UEdge fromId(int id, UEdge) const {
     492      return Parent::uEdgeFromId(id);
     493    } 
     494 
     495    class NodeIt : public Node {
     496      const Graph* graph;
     497    public:
     498   
     499      NodeIt() { }
     500   
     501      NodeIt(Invalid i) : Node(INVALID) { }
     502   
     503      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
     504        graph->first(static_cast<Node&>(*this));
     505      }
     506
     507      NodeIt(const Graph& _graph, const Node& node)
     508        : Node(node), graph(&_graph) { }
     509   
     510      NodeIt& operator++() {
     511        graph->next(*this);
     512        return *this;
     513      }
     514
     515    };
     516
     517    class ANodeIt : public Node {
     518      friend class BpUGraphAdaptorExtender;
     519      const Graph* graph;
     520    public:
     521   
     522      ANodeIt() { }
     523   
     524      ANodeIt(Invalid i) : Node(INVALID) { }
     525   
     526      explicit ANodeIt(const Graph& _graph) : graph(&_graph) {
     527        graph->firstANode(static_cast<Node&>(*this));
     528      }
     529
     530      ANodeIt(const Graph& _graph, const Node& node)
     531        : Node(node), graph(&_graph) {}
     532   
     533      ANodeIt& operator++() {
     534        graph->nextANode(*this);
     535        return *this;
     536      }
     537    };
     538
     539    class BNodeIt : public Node {
     540      friend class BpUGraphAdaptorExtender;
     541      const Graph* graph;
     542    public:
     543   
     544      BNodeIt() { }
     545   
     546      BNodeIt(Invalid i) : Node(INVALID) { }
     547   
     548      explicit BNodeIt(const Graph& _graph) : graph(&_graph) {
     549        graph->firstBNode(static_cast<Node&>(*this));
     550      }
     551
     552      BNodeIt(const Graph& _graph, const Node& node)
     553        : Node(node), graph(&_graph) {}
     554   
     555      BNodeIt& operator++() {
     556        graph->nextBNode(*this);
     557        return *this;
     558      }
     559    };
     560
     561    class EdgeIt : public Edge {
     562      friend class BpUGraphAdaptorExtender;
     563      const Graph* graph;
     564    public:
     565   
     566      EdgeIt() { }
     567   
     568      EdgeIt(Invalid i) : Edge(INVALID) { }
     569   
     570      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
     571        graph->first(static_cast<Edge&>(*this));
     572      }
     573
     574      EdgeIt(const Graph& _graph, const Edge& edge)
     575        : Edge(edge), graph(&_graph) { }
     576   
     577      EdgeIt& operator++() {
     578        graph->next(*this);
     579        return *this;
     580      }
     581
     582    };
     583
     584    class UEdgeIt : public UEdge {
     585      friend class BpUGraphAdaptorExtender;
     586      const Graph* graph;
     587    public:
     588   
     589      UEdgeIt() { }
     590   
     591      UEdgeIt(Invalid i) : UEdge(INVALID) { }
     592   
     593      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
     594        graph->first(static_cast<UEdge&>(*this));
     595      }
     596
     597      UEdgeIt(const Graph& _graph, const UEdge& edge)
     598        : UEdge(edge), graph(&_graph) { }
     599   
     600      UEdgeIt& operator++() {
     601        graph->next(*this);
     602        return *this;
     603      }
     604    };
     605
     606    class OutEdgeIt : public Edge {
     607      friend class BpUGraphAdaptorExtender;
     608      const Graph* graph;
     609    public:
     610   
     611      OutEdgeIt() { }
     612   
     613      OutEdgeIt(Invalid i) : Edge(i) { }
     614   
     615      OutEdgeIt(const Graph& _graph, const Node& node)
     616        : graph(&_graph) {
     617        graph->firstOut(*this, node);
     618      }
     619   
     620      OutEdgeIt(const Graph& _graph, const Edge& edge)
     621        : Edge(edge), graph(&_graph) {}
     622   
     623      OutEdgeIt& operator++() {
     624        graph->nextOut(*this);
     625        return *this;
     626      }
     627
     628    };
     629
     630
     631    class InEdgeIt : public Edge {
     632      friend class BpUGraphAdaptorExtender;
     633      const Graph* graph;
     634    public:
     635   
     636      InEdgeIt() { }
     637   
     638      InEdgeIt(Invalid i) : Edge(i) { }
     639   
     640      InEdgeIt(const Graph& _graph, const Node& node)
     641        : graph(&_graph) {
     642        graph->firstIn(*this, node);
     643      }
     644   
     645      InEdgeIt(const Graph& _graph, const Edge& edge) :
     646        Edge(edge), graph(&_graph) {}
     647   
     648      InEdgeIt& operator++() {
     649        graph->nextIn(*this);
     650        return *this;
     651      }
     652
     653    };
     654 
     655    /// \brief Base node of the iterator
     656    ///
     657    /// Returns the base node (ie. the source in this case) of the iterator
     658    Node baseNode(const OutEdgeIt &e) const {
     659      return Parent::source((Edge&)e);
     660    }
     661    /// \brief Running node of the iterator
     662    ///
     663    /// Returns the running node (ie. the target in this case) of the
     664    /// iterator
     665    Node runningNode(const OutEdgeIt &e) const {
     666      return Parent::target((Edge&)e);
     667    }
     668 
     669    /// \brief Base node of the iterator
     670    ///
     671    /// Returns the base node (ie. the target in this case) of the iterator
     672    Node baseNode(const InEdgeIt &e) const {
     673      return Parent::target((Edge&)e);
     674    }
     675    /// \brief Running node of the iterator
     676    ///
     677    /// Returns the running node (ie. the source in this case) of the
     678    /// iterator
     679    Node runningNode(const InEdgeIt &e) const {
     680      return Parent::source((Edge&)e);
     681    }
     682 
     683    class IncEdgeIt : public Parent::UEdge {
     684      friend class BpUGraphAdaptorExtender;
     685      const Graph* graph;
     686      bool direction;
     687    public:
     688   
     689      IncEdgeIt() { }
     690   
     691      IncEdgeIt(Invalid i) : UEdge(i), direction(true) { }
     692   
     693      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
     694        graph->firstInc(*this, direction, n);
     695      }
     696
     697      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
     698        : graph(&_graph), UEdge(ue) {
     699        direction = (graph->source(ue) == n);
     700      }
     701
     702      IncEdgeIt& operator++() {
     703        graph->nextInc(*this, direction);
     704        return *this;
     705      }
     706    };
     707 
     708
     709    /// Base node of the iterator
     710    ///
     711    /// Returns the base node of the iterator
     712    Node baseNode(const IncEdgeIt &e) const {
     713      return e.direction ? source(e) : target(e);
     714    }
     715
     716    /// Running node of the iterator
     717    ///
     718    /// Returns the running node of the iterator
     719    Node runningNode(const IncEdgeIt &e) const {
     720      return e.direction ? target(e) : source(e);
     721    }
     722
     723  };
     724
    439725
    440726}
  • lemon/bits/graph_extender.h

    r1999 r2031  
    104104
    105105      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
    106         _graph.first(*static_cast<Node*>(this));
     106        _graph.first(static_cast<Node&>(*this));
    107107      }
    108108
     
    127127
    128128      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
    129         _graph.first(*static_cast<Edge*>(this));
     129        _graph.first(static_cast<Edge&>(*this));
    130130      }
    131131
     
    233233      }
    234234
    235 
    236       /// \brief Template assign operator.
    237       ///
    238       /// The given parameter should be conform to the ReadMap
    239       /// concecpt and could be indiced by the current item set of
    240       /// the NodeMap. In this case the value for each item
    241       /// is assigned by the value of the given ReadMap.
    242235      template <typename CMap>
    243236      NodeMap& operator=(const CMap& cmap) {
    244         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
    245         const typename Parent::Notifier* notifier = Parent::getNotifier();
    246         Node it;
    247         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    248           Parent::set(it, cmap[it]);
    249         }
     237        Parent::operator=(cmap);
    250238        return *this;
    251239      }
     
    271259      template <typename CMap>
    272260      EdgeMap& operator=(const CMap& cmap) {
    273         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    274         const typename Parent::Notifier* notifier = Parent::getNotifier();
    275         Edge it;
    276         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    277           Parent::set(it, cmap[it]);
    278         }
     261        Parent::operator=(cmap);
    279262        return *this;
    280263      }
     
    432415
    433416      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
    434         _graph.first(*static_cast<Node*>(this));
     417        _graph.first(static_cast<Node&>(*this));
    435418      }
    436419
     
    455438
    456439      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
    457         _graph.first(*static_cast<Edge*>(this));
     440        _graph.first(static_cast<Edge&>(*this));
    458441      }
    459442
     
    526509
    527510      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
    528         _graph.first(*static_cast<UEdge*>(this));
     511        _graph.first(static_cast<UEdge&>(*this));
    529512      }
    530513
     
    623606      }
    624607
    625 
    626       /// \brief Template assign operator.
    627       ///
    628       /// The given parameter should be conform to the ReadMap
    629       /// concecpt and could be indiced by the current item set of
    630       /// the NodeMap. In this case the value for each item
    631       /// is assigned by the value of the given ReadMap.
    632608      template <typename CMap>
    633609      NodeMap& operator=(const CMap& cmap) {
    634         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
    635         const typename Parent::Notifier* notifier = Parent::getNotifier();
    636         Node it;
    637         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    638           Parent::set(it, cmap[it]);
    639         }
     610        Parent::operator=(cmap);
    640611        return *this;
    641612      }
     
    661632      template <typename CMap>
    662633      EdgeMap& operator=(const CMap& cmap) {
    663         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    664         const typename Parent::Notifier* notifier = Parent::getNotifier();
    665         Edge it;
    666         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    667           Parent::set(it, cmap[it]);
    668         }
     634        Parent::operator=(cmap);
    669635        return *this;
    670636      }
     
    681647      UEdgeMap(const Graph& graph)
    682648        : Parent(graph) {}
     649
    683650      UEdgeMap(const Graph& graph, const _Value& value)
    684651        : Parent(graph, value) {}
     
    690657      template <typename CMap>
    691658      UEdgeMap& operator=(const CMap& cmap) {
    692         checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
    693         const typename Parent::Notifier* notifier = Parent::getNotifier();
    694         Edge it;
    695         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    696           Parent::set(it, cmap[it]);
    697         }
     659        Parent::operator=(cmap);
    698660        return *this;
    699661      }
     662
    700663    };
    701664
     
    11051068      }
    11061069   
    1107 
    1108       /// \brief Template assign operator.
    1109       ///
    1110       /// The given parameter should be conform to the ReadMap
    1111       /// concept and could be indiced by the current item set of
    1112       /// the ANodeMap. In this case the value for each item
    1113       /// is assigned by the value of the given ReadMap.
    11141070      template <typename CMap>
    11151071      ANodeMap& operator=(const CMap& cmap) {
    1116         checkConcept<concept::ReadMap<ANode, _Value>, CMap>();
    1117         const typename Parent::Graph* graph = Parent::getGraph();
    1118         ANode it;
    1119         for (graph->first(it); it != INVALID; graph->next(it)) {
    1120           Parent::set(it, cmap[it]);
    1121         }
     1072        Parent::operator=(cmap);
    11221073        return *this;
    11231074      }
     
    11411092      }
    11421093   
    1143 
    1144       /// \brief Template assign operator.
    1145       ///
    1146       /// The given parameter should be conform to the ReadMap
    1147       /// concept and could be indiced by the current item set of
    1148       /// the BNodeMap. In this case the value for each item
    1149       /// is assigned by the value of the given ReadMap.
    11501094      template <typename CMap>
    11511095      BNodeMap& operator=(const CMap& cmap) {
    1152         checkConcept<concept::ReadMap<BNode, _Value>, CMap>();
    1153         const typename Parent::Graph* graph = Parent::getGraph();
    1154         BNode it;
    1155         for (graph->first(it); it != INVALID; graph->next(it)) {
    1156           Parent::set(it, cmap[it]);
    1157         }
     1096        Parent::operator=(cmap);
    11581097        return *this;
    11591098      }
     
    11611100    };
    11621101
    1163   protected:
     1102  public:
    11641103
    11651104    template <typename _Value>
    1166     class NodeMapBase {
     1105    class NodeMap {
    11671106    public:
    11681107      typedef BpUGraphExtender Graph;
     
    11781117      typedef True ReferenceMapTag;
    11791118
    1180       NodeMapBase(const Graph& graph)
    1181         : aNodeMap(graph), bNodeMap(graph) {}
    1182       NodeMapBase(const Graph& graph, const _Value& value)
    1183         : aNodeMap(graph, value), bNodeMap(graph, value) {}
     1119      NodeMap(const Graph& _graph)
     1120        : graph(_graph), aNodeMap(_graph), bNodeMap(_graph) {}
     1121      NodeMap(const Graph& _graph, const _Value& _value)
     1122        : graph(_graph), aNodeMap(_graph, _value), bNodeMap(_graph, _value) {}
     1123
     1124      NodeMap& operator=(const NodeMap& cmap) {
     1125        return operator=<NodeMap>(cmap);
     1126      }
     1127   
     1128      template <typename CMap>
     1129      NodeMap& operator=(const CMap& cmap) {
     1130        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
     1131        const typename Parent::Notifier* notifier = Parent::getNotifier();
     1132        Edge it;
     1133        for (graph.first(it); it != INVALID; graph.next(it)) {
     1134          Parent::set(it, cmap[it]);
     1135        }
     1136        return *this;
     1137      }
    11841138
    11851139      ConstReference operator[](const Key& node) const {
     
    12071161      }
    12081162
    1209       const Graph* getGraph() const {
    1210         return aNodeMap.getGraph();
    1211       }
    1212 
     1163      class MapIt : public NodeIt {
     1164      public:
     1165
     1166        typedef NodeIt Parent;
     1167       
     1168        explicit MapIt(NodeMap& _map)
     1169          : Parent(_map.graph), map(_map) {}
     1170       
     1171        typename MapTraits<NodeMap>::ConstReturnValue operator*() const {
     1172          return map[*this];
     1173        }
     1174       
     1175        typename MapTraits<NodeMap>::ReturnValue operator*() {
     1176          return map[*this];
     1177        }
     1178       
     1179        void set(const Value& value) {
     1180          map.set(*this, value);
     1181        }
     1182
     1183      private:
     1184        NodeMap& map;
     1185      };
     1186
     1187      class ConstMapIt : public NodeIt {
     1188      public:
     1189
     1190        typedef NodeIt Parent;
     1191       
     1192        explicit ConstMapIt(const NodeMap& _map)
     1193          : Parent(_map.graph), map(_map) {}
     1194       
     1195        typename MapTraits<NodeMap>::ConstReturnValue operator*() const {
     1196          return map[*this];
     1197        }
     1198       
     1199      private:
     1200        const NodeMap& map;
     1201      };
     1202
     1203      class ItemIt : public NodeIt {
     1204      public:
     1205
     1206        typedef NodeIt Parent;
     1207
     1208        explicit ItemIt(const NodeMap& _map)
     1209          : Parent(_map.graph) {}
     1210       
     1211      };
     1212     
    12131213    private:
     1214      const Graph& graph;
    12141215      ANodeMap<_Value> aNodeMap;
    12151216      BNodeMap<_Value> bNodeMap;
    12161217    };
    12171218   
    1218   public:
    1219 
    1220     template <typename _Value>
    1221     class NodeMap
    1222       : public MapExtender<NodeMapBase<_Value> > {
    1223     public:
    1224       typedef BpUGraphExtender Graph;
    1225       typedef MapExtender< NodeMapBase<_Value> > Parent;
    1226    
    1227       NodeMap(const Graph& graph)
    1228         : Parent(graph) {}
    1229       NodeMap(const Graph& graph, const _Value& value)
    1230         : Parent(graph, value) {}
    1231    
    1232       NodeMap& operator=(const NodeMap& cmap) {
    1233         return operator=<NodeMap>(cmap);
    1234       }
    1235    
    1236 
    1237       /// \brief Template assign operator.
    1238       ///
    1239       /// The given parameter should be conform to the ReadMap
    1240       /// concept and could be indiced by the current item set of
    1241       /// the NodeMap. In this case the value for each item
    1242       /// is assigned by the value of the given ReadMap.
    1243       template <typename CMap>
    1244       NodeMap& operator=(const CMap& cmap) {
    1245         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
    1246         const typename Parent::Notifier* notifier = Parent::getNotifier();
    1247         Edge it;
    1248         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    1249           Parent::set(it, cmap[it]);
    1250         }
    1251         return *this;
    1252       }
    1253    
    1254     };
    1255 
    1256 
    12571219
    12581220    template <typename _Value>
     
    12741236      template <typename CMap>
    12751237      EdgeMap& operator=(const CMap& cmap) {
    1276         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    1277         const typename Parent::Notifier* notifier = Parent::getNotifier();
    1278         Edge it;
    1279         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    1280           Parent::set(it, cmap[it]);
    1281         }
     1238        Parent::operator=(cmap);
    12821239        return *this;
    12831240      }
     
    13021259      template <typename CMap>
    13031260      UEdgeMap& operator=(const CMap& cmap) {
    1304         checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
    1305         const typename Parent::Notifier* notifier = Parent::getNotifier();
    1306         Edge it;
    1307         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    1308           Parent::set(it, cmap[it]);
    1309         }
     1261        Parent::operator=(cmap);
    13101262        return *this;
    13111263      }
  • lemon/bits/map_extender.h

    r1999 r2031  
    2323
    2424#include <lemon/bits/traits.h>
     25
     26#include <lemon/concept_check.h>
     27#include <lemon/concept/maps.h>
    2528
    2629///\file
     
    6063      : Parent(graph, value) {}
    6164
     65    MapExtender& operator=(const MapExtender& cmap) {
     66      return operator=<MapExtender>(cmap);
     67    }
     68
     69    template <typename CMap>
     70    MapExtender& operator=(const CMap& cmap) {
     71      Parent::operator=(cmap);
     72      return *this;
     73    }
    6274
    6375    class MapIt : public Item {
     
    131143    };
    132144
    133     class ItemIt : Item {
     145    class ItemIt : public Item {
    134146    public:
    135147     
     
    141153
    142154      explicit ItemIt(Map& _map) : map(_map) {
    143         map->getNotifier()->first(*this);
     155        map.getNotifier()->first(*this);
    144156      }
    145157
     
    158170  };
    159171
     172  /// \ingroup graphbits
     173  ///
     174  /// \brief Extender for maps which use a subset of the items.
     175  template <typename _Graph, typename _Map>
     176  class SubMapExtender : public _Map {
     177  public:
     178
     179    typedef _Map Parent;
     180    typedef SubMapExtender Map;
     181
     182    typedef _Graph Graph;
     183
     184    typedef typename Parent::Key Item;
     185
     186    typedef typename Parent::Key Key;
     187    typedef typename Parent::Value Value;
     188
     189    class MapIt;
     190    class ConstMapIt;
     191
     192    friend class MapIt;
     193    friend class ConstMapIt;
     194
     195  public:
     196
     197    SubMapExtender(const Graph& _graph)
     198      : Parent(_graph), graph(_graph) {}
     199
     200    SubMapExtender(const Graph& _graph, const Value& _value)
     201      : Parent(_graph, _value), graph(_graph) {}
     202
     203    SubMapExtender& operator=(const SubMapExtender& cmap) {
     204      return operator=<MapExtender>(cmap);
     205    }
     206
     207    template <typename CMap>
     208    SubMapExtender& operator=(const CMap& cmap) {
     209      checkConcept<concept::ReadMap<Key, Value>, CMap>();
     210      Item it;
     211      for (graph.first(it); it != INVALID; graph.next(it)) {
     212        Parent::set(it, cmap[it]);
     213      }
     214      return *this;
     215    }
     216
     217    class MapIt : public Item {
     218    public:
     219     
     220      typedef Item Parent;
     221      typedef typename Map::Value Value;
     222     
     223      MapIt() {}
     224
     225      MapIt(Invalid i) : Parent(i) { }
     226
     227      explicit MapIt(Map& _map) : map(_map) {
     228        map.graph.first(*this);
     229      }
     230
     231      MapIt(const Map& _map, const Item& item)
     232        : Parent(item), map(_map) {}
     233
     234      MapIt& operator++() {
     235        map.graph.next(*this);
     236        return *this;
     237      }
     238     
     239      typename MapTraits<Map>::ConstReturnValue operator*() const {
     240        return map[*this];
     241      }
     242
     243      typename MapTraits<Map>::ReturnValue operator*() {
     244        return map[*this];
     245      }
     246     
     247      void set(const Value& value) {
     248        map.set(*this, value);
     249      }
     250     
     251    protected:
     252      Map& map;
     253     
     254    };
     255
     256    class ConstMapIt : public Item {
     257    public:
     258
     259      typedef Item Parent;
     260
     261      typedef typename Map::Value Value;
     262     
     263      ConstMapIt() {}
     264
     265      ConstMapIt(Invalid i) : Parent(i) { }
     266
     267      explicit ConstMapIt(Map& _map) : map(_map) {
     268        map.graph.first(*this);
     269      }
     270
     271      ConstMapIt(const Map& _map, const Item& item)
     272        : Parent(item), map(_map) {}
     273
     274      ConstMapIt& operator++() {
     275        map.graph.next(*this);
     276        return *this;
     277      }
     278
     279      typename MapTraits<Map>::ConstReturnValue operator*() const {
     280        return map[*this];
     281      }
     282
     283    protected:
     284      const Map& map;
     285    };
     286
     287    class ItemIt : public Item {
     288    public:
     289     
     290      typedef Item Parent;
     291     
     292      ItemIt() {}
     293
     294      ItemIt(Invalid i) : Parent(i) { }
     295
     296      explicit ItemIt(Map& _map) : map(_map) {
     297        map.graph.first(*this);
     298      }
     299
     300      ItemIt(const Map& _map, const Item& item)
     301        : Parent(item), map(_map) {}
     302
     303      ItemIt& operator++() {
     304        map.graph.next(*this);
     305        return *this;
     306      }
     307
     308    protected:
     309      const Map& map;
     310     
     311    };
     312   
     313  private:
     314
     315    const Graph& graph;
     316   
     317  };
     318
    160319}
    161320
  • lemon/bits/vector_map.h

    r1999 r2031  
    2727
    2828#include <lemon/bits/alteration_notifier.h>
     29
     30#include <lemon/concept_check.h>
     31#include <lemon/concept/maps.h>
    2932
    3033///\ingroup graphbits
     
    113116    }
    114117
    115   private:
    116 
    117     VectorMap& operator=(const VectorMap&);
    118 
     118    /// \brief Assign operator.
     119    ///
     120    /// This operator assigns for each item in the map the
     121    /// value mapped to the same item in the copied map. 
     122    /// The parameter map should be indiced with the same
     123    /// itemset because this assign operator does not change
     124    /// the container of the map.
     125    VectorMap& operator=(const VectorMap& cmap) {
     126      return operator=<VectorMap>(cmap);
     127    }
     128
     129
     130    /// \brief Template assign operator.
     131    ///
     132    /// The given parameter should be conform to the ReadMap
     133    /// concecpt and could be indiced by the current item set of
     134    /// the NodeMap. In this case the value for each item
     135    /// is assigned by the value of the given ReadMap.
     136    template <typename CMap>
     137    VectorMap& operator=(const CMap& cmap) {
     138      checkConcept<concept::ReadMap<Key, _Value>, CMap>();
     139      const typename Parent::Notifier* notifier = Parent::getNotifier();
     140      Item it;
     141      for (notifier->first(it); it != INVALID; notifier->next(it)) {
     142        set(it, cmap[it]);
     143      }
     144      return *this;
     145    }
     146   
    119147  public:
    120148
Note: See TracChangeset for help on using the changeset viewer.