COIN-OR::LEMON - Graph Library

Changeset 75:87623302a68f in lemon-0.x for src/work/list_graph.hh


Ignore:
Timestamp:
02/16/04 12:29:48 (16 years ago)
Author:
marci
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@98
Message:

.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/work/list_graph.hh

    r69 r75  
    4545      NodeMap(const ListGraph& _G, T a) :
    4646        G(_G), container(G.node_id, a) { }
    47       void set(NodeIt nit, T a) { container[G.id(nit)]=a; }
    48       T get(NodeIt nit) const { return container[G.id(nit)]; }
     47      void set(NodeIt n, T a) { container[/*G.id(n)*/n.node->id]=a; }
     48      T get(NodeIt n) const { return container[/*G.id(n)*/n.node->id]; }
     49      T& operator[](NodeIt n) { return container[/*G.id(n)*/n.node->id]; }
     50      const T& operator[](NodeIt n) const { return container[/*G.id(n)*/n.node->id]; }
    4951      void resize() { container.resize(G.node_id); }
    5052      void resize(T a) { container.resize(G.node_id, a); }
     
    6163      EdgeMap(const ListGraph& _G, T a) :
    6264        G(_G), container(G.edge_id, a) { }
    63       void set(EdgeIt eit, T a) { container[G.id(eit)]=a; }
    64       T get(EdgeIt eit) const { return container[G.id(eit)]; }
     65      void set(EdgeIt e, T a) { container[/*G.id(e)*/e.edge->id]=a; }
     66      T get(EdgeIt e) const { return container[/*G.id(e)*/e.edge->id]; }
     67      T& operator[](EdgeIt e) { return container[/*G.id(e)*/e.edge->id]; }
     68      const T& operator[](EdgeIt e) const { return container[/*G.id(e)*/e.edge->id]; }
    6569      void resize() { container.resize(G.edge_id); }
    6670      void resize(T a) { container.resize(G.edge_id, a); }
     
    7781    class node_item {
    7882      friend class ListGraph;
     83      template <typename T> friend class NodeMap;
     84     
    7985      friend class NodeIt;
    8086      friend class EachNodeIt;
     
    100106    class edge_item {
    101107      friend class ListGraph;
     108      template <typename T> friend class EdgeMap;
     109
    102110      friend class NodeIt;
    103111      friend class EachNodeIt;
     
    255263    /* for experimental purpose */
    256264
    257     void getFirst(EachNodeIt& v) const { v=EachNodeIt(*this); }
    258     void getFirst(EachEdgeIt& e) const { e=EachEdgeIt(*this); }
    259     void getFirst(OutEdgeIt& e, NodeIt v) const { e=OutEdgeIt(v); }
    260     void getFirst(InEdgeIt& e, NodeIt v) const { e=InEdgeIt(v); }
    261     void getFirst(SymEdgeIt& e, NodeIt v) const { e=SymEdgeIt(v); }
     265    EachNodeIt& getFirst(EachNodeIt& v) const {
     266      v=EachNodeIt(*this); return v; }
     267    EachEdgeIt& getFirst(EachEdgeIt& e) const {
     268      e=EachEdgeIt(*this); return e; }
     269    OutEdgeIt& getFirst(OutEdgeIt& e, NodeIt v) const {
     270      e=OutEdgeIt(v); return e; }
     271    InEdgeIt& getFirst(InEdgeIt& e, NodeIt v) const {
     272      e=InEdgeIt(v); return e; }
     273    SymEdgeIt& getFirst(SymEdgeIt& e, NodeIt v) const {
     274      e=SymEdgeIt(v); return e; }
    262275    //void getTail(NodeIt& n, const EdgeIt& e) const { n=tail(e); }
    263276    //void getHead(NodeIt& n, const EdgeIt& e) const { n=head(e); }
     
    334347    class NodeIt {
    335348      friend class ListGraph;
     349      template <typename T> friend class NodeMap;
    336350
    337351      friend class EdgeIt;
     
    368382    class EdgeIt {
    369383      friend class ListGraph;
     384      template <typename T> friend class EdgeMap;
    370385     
    371386      friend class NodeIt;
     
    414429    class OutEdgeIt : public EdgeIt {
    415430      friend class ListGraph;
    416       node_item* v;
    417     protected:
    418       OutEdgeIt(const NodeIt& _v) : v(_v.node) { edge=v->_first_out_edge; }
    419     public:
    420       OutEdgeIt() : EdgeIt(), v(0) { }
    421       OutEdgeIt(const ListGraph& G, NodeIt _v) : v(_v.node) { edge=v->_first_out_edge; }
     431      //node_item* v;
     432    protected:
     433      OutEdgeIt(const NodeIt& _v) /*: v(_v.node)*/ { edge=_v.node->_first_out_edge; }
     434    public:
     435      OutEdgeIt() : EdgeIt()/*, v(0)*/ { }
     436      OutEdgeIt(const ListGraph& G, NodeIt _v) /*: v(_v.node)*/ { edge=_v.node->_first_out_edge; }
    422437      OutEdgeIt& operator++() { edge=edge->_next_out; return *this; }
    423438    protected:
    424       NodeIt aNode() const { return NodeIt(v); }
    425       NodeIt bNode() const {
    426         return (edge->_tail==v) ? NodeIt(edge->_head) : NodeIt(edge->_tail); }
     439      NodeIt aNode() const { return NodeIt(edge->_tail); }
     440      NodeIt bNode() const { return NodeIt(edge->_head); }
    427441    };
    428442   
    429443    class InEdgeIt : public EdgeIt {
    430444      friend class ListGraph;
    431       node_item* v;
    432     protected:
    433       InEdgeIt(const NodeIt& _v) : v(_v.node) { edge=v->_first_in_edge; }
    434     public:
    435       InEdgeIt() : EdgeIt(), v(0) { }
    436       InEdgeIt(const ListGraph& G, NodeIt _v) : v(_v.node) { edge=v->_first_in_edge; }
     445      //node_item* v;
     446    protected:
     447      InEdgeIt(const NodeIt& _v) /*: v(_v.node)*/ { edge=_v.node->_first_in_edge; }
     448    public:
     449      InEdgeIt() : EdgeIt()/*, v(0)*/ { }
     450      InEdgeIt(const ListGraph& G, NodeIt _v) /*: v(_v.node)*/ { edge=_v.node->_first_in_edge; }
    437451      InEdgeIt& operator++() { edge=edge->_next_in; return *this; }
    438452    protected:
    439       NodeIt aNode() const { return NodeIt(v); }
    440       NodeIt bNode() const {
    441         return (edge->_tail==v) ? NodeIt(edge->_head) : NodeIt(edge->_tail); }
     453      NodeIt aNode() const { return NodeIt(edge->_head); }
     454      NodeIt bNode() const { return NodeIt(edge->_tail); }
    442455    };
    443456
     
    445458      friend class ListGraph;
    446459      bool out_or_in; //1 iff out, 0 iff in
    447       node_item* v;
    448     protected:
    449       SymEdgeIt(const NodeIt& _v) : v(_v.node) {
     460      //node_item* v;
     461    protected:
     462      SymEdgeIt(const NodeIt& _v) /*: v(_v.node)*/ {
    450463        out_or_in=1;
    451         edge=v->_first_out_edge;
    452         if (!edge) { edge=v->_first_in_edge; out_or_in=0; }
     464        edge=_v.node->_first_out_edge;
     465        if (!edge) { edge=_v.node->_first_in_edge; out_or_in=0; }
    453466      }
    454467    public:
    455       SymEdgeIt() : EdgeIt(), v(0) { }
    456       SymEdgeIt(const ListGraph& G, NodeIt _v) : v(_v.node) {
     468      SymEdgeIt() : EdgeIt() /*, v(0)*/ { }
     469      SymEdgeIt(const ListGraph& G, NodeIt _v) /*: v(_v.node)*/ {
    457470        out_or_in=1;
    458         edge=v->_first_out_edge;
    459         if (!edge) { edge=v->_first_in_edge; out_or_in=0; }
     471        edge=_v.node->_first_out_edge;
     472        if (!edge) { edge=_v.node->_first_in_edge; out_or_in=0; }
    460473      }
    461474      SymEdgeIt& operator++() {
    462475        if (out_or_in) {
     476          node_item* v=edge->_tail;
    463477          edge=edge->_next_out;
    464478          if (!edge) { out_or_in=0; edge=v->_first_in_edge; }
     
    469483      }
    470484    protected:
    471       NodeIt aNode() const { return NodeIt(v); }
     485      NodeIt aNode() const {
     486        return (out_or_in) ? NodeIt(edge->_tail) : NodeIt(edge->_head); }
    472487      NodeIt bNode() const {
    473         return (edge->_tail==v) ? NodeIt(edge->_head) : NodeIt(edge->_tail); }
     488        return (out_or_in) ? NodeIt(edge->_head) : NodeIt(edge->_tail); }
    474489    };
    475490
Note: See TracChangeset for help on using the changeset viewer.