COIN-OR::LEMON - Graph Library

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


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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/ugraph_adaptor.h

    r1993 r2031  
    102102    typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
    103103    int edgeNum() const { return graph->edgeNum(); }
     104    int uEdgeNum() const { return graph->uEdgeNum(); }
    104105
    105106    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
     
    119120
    120121    void erase(const Node& i) const { graph->erase(i); }
    121     void erase(const Edge& i) const { graph->erase(i); }
     122    void erase(const UEdge& i) const { graph->erase(i); }
    122123 
    123124    void clear() const { graph->clear(); }
    124125   
    125     int id(const Node& v) const { return graph->id(v); }
    126     int id(const UEdge& e) const { return graph->id(e); }
    127 
    128126    bool direction(const Edge& e) const { return graph->direction(e); }
    129127    Edge direct(const UEdge& e, bool d) const { return graph->direct(e, d); }
     128
     129    int id(const Node& v) const { return graph->id(v); }
     130    int id(const Edge& e) const { return graph->id(e); }
     131    int id(const UEdge& e) const { return graph->id(e); }
     132
     133    Node fromNodeId(int id) const {
     134      return graph->fromNodeId(id);
     135    }
     136
     137    Edge fromEdgeId(int id) const {
     138      return graph->fromEdgeId(id);
     139    }
     140
     141    UEdge fromUEdgeId(int id) const {
     142      return graph->fromUEdgeId(id);
     143    }
    130144
    131145    int maxNodeId() const {
     
    174188      template <typename CMap>
    175189      NodeMap& operator=(const CMap& cmap) {
    176         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
    177         const typename Parent::Graph* graph = Parent::getGraph();
    178         Node it;
    179         for (graph->first(it); it != INVALID; graph->next(it)) {
    180           Parent::set(it, cmap[it]);
    181         }
    182         return *this;
    183       }
     190        Parent::operator=(cmap);
     191        return *this;
     192      }
     193
    184194    };
    185195
     
    199209      template <typename CMap>
    200210      EdgeMap& operator=(const CMap& cmap) {
    201         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    202         const typename Parent::Graph* graph = Parent::getGraph();
    203         Edge it;
    204         for (graph->first(it); it != INVALID; graph->next(it)) {
    205           Parent::set(it, cmap[it]);
    206         }
     211        Parent::operator=(cmap);
    207212        return *this;
    208213      }
     
    224229      template <typename CMap>
    225230      UEdgeMap& operator=(const CMap& cmap) {
    226         checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
    227         const typename Parent::Graph* graph = Parent::getGraph();
    228         UEdge it;
    229         for (graph->first(it); it != INVALID; graph->next(it)) {
    230           Parent::set(it, cmap[it]);
    231         }
    232         return *this;
     231        Parent::operator=(cmap);
     232        return *this;
    233233      }
    234234    };
     
    255255  public:
    256256    typedef _UGraph Graph;
     257    typedef SubUGraphAdaptorBase Adaptor;
    257258    typedef UGraphAdaptorBase<_UGraph> Parent;
    258259  protected:
     
    417418      return uedge;
    418419    }
     420
     421    template <typename _Value>
     422    class NodeMap
     423      : public SubMapExtender<Adaptor,
     424                              typename Parent::template NodeMap<_Value> >
     425    {
     426    public:
     427      typedef Adaptor Graph;
     428      typedef SubMapExtender<Adaptor, typename Parent::
     429                             template NodeMap<_Value> > Parent;
     430   
     431      NodeMap(const Graph& graph)
     432        : Parent(graph) {}
     433      NodeMap(const Graph& graph, const _Value& value)
     434        : Parent(graph, value) {}
     435   
     436      NodeMap& operator=(const NodeMap& cmap) {
     437        return operator=<NodeMap>(cmap);
     438      }
     439   
     440      template <typename CMap>
     441      NodeMap& operator=(const CMap& cmap) {
     442        Parent::operator=(cmap);
     443        return *this;
     444      }
     445    };
     446
     447    template <typename _Value>
     448    class EdgeMap
     449      : public SubMapExtender<Adaptor,
     450                              typename Parent::template EdgeMap<_Value> >
     451    {
     452    public:
     453      typedef Adaptor Graph;
     454      typedef SubMapExtender<Adaptor, typename Parent::
     455                             template EdgeMap<_Value> > Parent;
     456   
     457      EdgeMap(const Graph& graph)
     458        : Parent(graph) {}
     459      EdgeMap(const Graph& graph, const _Value& value)
     460        : Parent(graph, value) {}
     461   
     462      EdgeMap& operator=(const EdgeMap& cmap) {
     463        return operator=<EdgeMap>(cmap);
     464      }
     465   
     466      template <typename CMap>
     467      EdgeMap& operator=(const CMap& cmap) {
     468        Parent::operator=(cmap);
     469        return *this;
     470      }
     471    };
     472
     473    template <typename _Value>
     474    class UEdgeMap
     475      : public SubMapExtender<Adaptor,
     476                              typename Parent::template UEdgeMap<_Value> >
     477    {
     478    public:
     479      typedef Adaptor Graph;
     480      typedef SubMapExtender<Adaptor, typename Parent::
     481                             template UEdgeMap<_Value> > Parent;
     482   
     483      UEdgeMap(const Graph& graph)
     484        : Parent(graph) {}
     485      UEdgeMap(const Graph& graph, const _Value& value)
     486        : Parent(graph, value) {}
     487   
     488      UEdgeMap& operator=(const UEdgeMap& cmap) {
     489        return operator=<UEdgeMap>(cmap);
     490      }
     491   
     492      template <typename CMap>
     493      UEdgeMap& operator=(const CMap& cmap) {
     494        Parent::operator=(cmap);
     495        return *this;
     496      }
     497    };
     498
    419499  };
    420500
     
    424504  public:
    425505    typedef _UGraph Graph;
     506    typedef SubUGraphAdaptorBase Adaptor;
    426507    typedef UGraphAdaptorBase<_UGraph> Parent;
    427508  protected:
     
    560641      return uedge;
    561642    }
     643
     644    template <typename _Value>
     645    class NodeMap
     646      : public SubMapExtender<Adaptor,
     647                              typename Parent::template NodeMap<_Value> >
     648    {
     649    public:
     650      typedef Adaptor Graph;
     651      typedef SubMapExtender<Adaptor, typename Parent::
     652                             template NodeMap<_Value> > Parent;
     653   
     654      NodeMap(const Graph& graph)
     655        : Parent(graph) {}
     656      NodeMap(const Graph& graph, const _Value& value)
     657        : Parent(graph, value) {}
     658   
     659      NodeMap& operator=(const NodeMap& cmap) {
     660        return operator=<NodeMap>(cmap);
     661      }
     662   
     663      template <typename CMap>
     664      NodeMap& operator=(const CMap& cmap) {
     665        Parent::operator=(cmap);
     666        return *this;
     667      }
     668    };
     669
     670    template <typename _Value>
     671    class EdgeMap
     672      : public SubMapExtender<Adaptor,
     673                              typename Parent::template EdgeMap<_Value> >
     674    {
     675    public:
     676      typedef Adaptor Graph;
     677      typedef SubMapExtender<Adaptor, typename Parent::
     678                             template EdgeMap<_Value> > Parent;
     679   
     680      EdgeMap(const Graph& graph)
     681        : Parent(graph) {}
     682      EdgeMap(const Graph& graph, const _Value& value)
     683        : Parent(graph, value) {}
     684   
     685      EdgeMap& operator=(const EdgeMap& cmap) {
     686        return operator=<EdgeMap>(cmap);
     687      }
     688   
     689      template <typename CMap>
     690      EdgeMap& operator=(const CMap& cmap) {
     691        Parent::operator=(cmap);
     692        return *this;
     693      }
     694    };
     695
     696    template <typename _Value>
     697    class UEdgeMap
     698      : public SubMapExtender<Adaptor,
     699                              typename Parent::template UEdgeMap<_Value> >
     700    {
     701    public:
     702      typedef Adaptor Graph;
     703      typedef SubMapExtender<Adaptor, typename Parent::
     704                             template UEdgeMap<_Value> > Parent;
     705   
     706      UEdgeMap(const Graph& graph)
     707        : Parent(graph) {}
     708      UEdgeMap(const Graph& graph, const _Value& value)
     709        : Parent(graph, value) {}
     710   
     711      UEdgeMap& operator=(const UEdgeMap& cmap) {
     712        return operator=<UEdgeMap>(cmap);
     713      }
     714   
     715      template <typename CMap>
     716      UEdgeMap& operator=(const CMap& cmap) {
     717        Parent::operator=(cmap);
     718        return *this;
     719      }
     720    };
    562721  };
    563722
     
    679838  }
    680839
    681 
    682840  /// \brief An adaptor for hiding undirected edges from an undirected graph.
    683841  ///
     
    705863
    706864  public:
     865
    707866    EdgeSubUGraphAdaptor(Graph& _graph, UEdgeFilterMap& _uedge_filter_map) :
    708867      Parent(), const_true_map(true) {
     
    711870      Parent::setUEdgeFilterMap(_uedge_filter_map);
    712871    }
     872
    713873  };
    714874
     
    838998    class NodeMap : public _UGraph::template NodeMap<_Value> {
    839999    public:
     1000
    8401001      typedef typename _UGraph::template NodeMap<_Value> Parent;
     1002
    8411003      explicit NodeMap(const DirUGraphAdaptorBase& ga)
    842         : Parent(*ga.graph) { }
     1004        : Parent(*ga.graph) {}
     1005
    8431006      NodeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
    844         : Parent(*ga.graph, value) { }
     1007        : Parent(*ga.graph, value) {}
     1008
     1009      NodeMap& operator=(const NodeMap& cmap) {
     1010        return operator=<NodeMap>(cmap);
     1011      }
     1012
     1013      template <typename CMap>
     1014      NodeMap& operator=(const CMap& cmap) {
     1015        Parent::operator=(cmap);
     1016        return *this;
     1017      }
     1018
    8451019    };
    8461020
     
    8481022    class EdgeMap : public _UGraph::template UEdgeMap<_Value> {
    8491023    public:
     1024
    8501025      typedef typename _UGraph::template UEdgeMap<_Value> Parent;
     1026
    8511027      explicit EdgeMap(const DirUGraphAdaptorBase& ga)
    8521028        : Parent(*ga.graph) { }
     1029
    8531030      EdgeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
    8541031        : Parent(*ga.graph, value) { }
     1032
     1033      EdgeMap& operator=(const EdgeMap& cmap) {
     1034        return operator=<EdgeMap>(cmap);
     1035      }
     1036
     1037      template <typename CMap>
     1038      EdgeMap& operator=(const CMap& cmap) {
     1039        Parent::operator=(cmap);
     1040        return *this;
     1041      }
    8551042    };
    8561043
Note: See TracChangeset for help on using the changeset viewer.