lemon-0.x: src/lemon/iterable_graph_extender.h@b5ad821053a1

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

     2 #ifndef LEMON_ITERABLE_GRAPH_EXTENDER_H

     3 #define LEMON_ITERABLE_GRAPH_EXTENDER_H

     5 #include <lemon/invalid.h>

     7 namespace lemon {

     9   template <typename _Base>

    10   class IterableGraphExtender : public _Base {

    11   public:

    13     typedef _Base Parent;

    14     typedef IterableGraphExtender<_Base> Graph;

    16     typedef typename Parent::Node Node;

    17     typedef typename Parent::Edge Edge;

    20     class NodeIt : public Node {

    21       const Graph* graph;

    22     public:

    24       NodeIt() {}

    26       NodeIt(Invalid i) : Node(i) { }

    28       explicit NodeIt(const Graph& _graph) : graph(&_graph) {

    29 	_graph.first(*static_cast<Node*>(this));

    30       }

    32       NodeIt(const Graph& _graph, const Node& node)

    33 	: Node(node), graph(&_graph) {}

    35       NodeIt& operator++() {

    36 	graph->next(*this);

    37 	return *this;

    38       }

    40     };

    43     class EdgeIt : public Edge {

    44       const Graph* graph;

    45     public:

    47       EdgeIt() { }

    49       EdgeIt(Invalid i) : Edge(i) { }

    51       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {

    52 	_graph.first(*static_cast<Edge*>(this));

    53       }

    55       EdgeIt(const Graph& _graph, const Edge& e) :

    56 	Edge(e), graph(&_graph) { }

    58       EdgeIt& operator++() {

    59 	graph->next(*this);

    60 	return *this;

    61       }

    63     };

    66     class OutEdgeIt : public Edge {

    67       const Graph* graph;

    68     public:

    70       OutEdgeIt() { }

    72       OutEdgeIt(Invalid i) : Edge(i) { }

    74       OutEdgeIt(const Graph& _graph, const Node& node)

    75 	: graph(&_graph) {

    76 	_graph.firstOut(*this, node);

    77       }

    79       OutEdgeIt(const Graph& _graph, const Edge& edge)

    80 	: Edge(edge), graph(&_graph) {}

    82       OutEdgeIt& operator++() {

    83 	graph->nextOut(*this);

    84 	return *this;

    85       }

    87     };

    90     class InEdgeIt : public Edge {

    91       const Graph* graph;

    92     public:

    94       InEdgeIt() { }

    96       InEdgeIt(Invalid i) : Edge(i) { }

    98       InEdgeIt(const Graph& _graph, const Node& node)

    99 	: graph(&_graph) {

   100 	_graph.firstIn(*this, node);

   101       }

   103       InEdgeIt(const Graph& _graph, const Edge& edge) :

   104 	Edge(edge), graph(&_graph) {}

   106       InEdgeIt& operator++() {

   107 	graph->nextIn(*this);

   108 	return *this;

   109       }

   111     };

   113     using Parent::first;

   115   private:

   117     /// \todo When (and if) we change the iterators concept to use operator*,

   118     /// then the following shadowed methods will become superfluous.

   119     /// But for now these are important safety measures.

   121     void first(NodeIt &) const;

   122     void first(EdgeIt &) const;

   123     void first(OutEdgeIt &) const;

   124     void first(InEdgeIt &) const;

   126   };

   128   template <typename _Base>

   129   class IterableUndirGraphExtender : public IterableGraphExtender<_Base> {

   130   public:

   132     typedef IterableGraphExtender<_Base> Parent;

   133     typedef IterableUndirGraphExtender<_Base> Graph;

   134     typedef typename Parent::Node Node;

   136     typedef typename Parent::UndirEdge UndirEdge;

   138     class UndirEdgeIt : public UndirEdge {

   139       const Graph* graph;

   140     public:

   142       UndirEdgeIt() { }

   144       UndirEdgeIt(Invalid i) : UndirEdge(i) { }

   146       explicit UndirEdgeIt(const Graph& _graph) : graph(&_graph) {

   147 	_graph.first(*static_cast<UndirEdge*>(this));

   148       }

   150       UndirEdgeIt(const Graph& _graph, const UndirEdge& e) :

   151 	UndirEdge(e), graph(&_graph) { }

   153       UndirEdgeIt& operator++() {

   154 	graph->next(*this);

   155 	return *this;

   156       }

   158     };

   160     class IncEdgeIt : public UndirEdge {

   161       const Graph* graph;

   162       bool forward;

   163       friend class IterableUndirGraphExtender;

   164       template <typename G>

   165       friend class UndirGraphExtender;

   166     public:

   168       IncEdgeIt() { }

   170       IncEdgeIt(Invalid i) : UndirEdge(i), forward(false) { }

   172       explicit IncEdgeIt(const Graph& _graph, const Node &n)

   173 	: graph(&_graph)

   174       {

   175 	_graph._dirFirstOut(*this, n);

   176       }

   178       // FIXME: Do we need this type of constructor here?

   179       // IncEdgeIt(const Graph& _graph, const Edge& e) :

   180       //   UndirEdge(e), graph(&_graph), forward(_graph.forward(e)) { }

   181       // or

   182       // IncEdgeIt(const Graph& _graph, const Node& n,

   183       //    Const UndirEdge &e) ... ?

   185       IncEdgeIt& operator++() {

   186 	graph->_dirNextOut(*this);

   187 	return *this;

   188       }

   189     };

   191     Node source(const IncEdgeIt &e) const {

   192       return _dirSource(e);

   193     }

   195     /// \todo Shouldn't the "source" of an undirected edge be called "aNode"

   196     /// or something???

   197     using Parent::source;

   199     /// Target of the given Edge.

   200     Node target(const IncEdgeIt &e) const {

   201       return _dirTarget(e);

   202     }

   204     /// \todo Shouldn't the "target" of an undirected edge be called "bNode"

   205     /// or something???

   206     using Parent::target;

   208   };

   209 }

   211 #endif // LEMON_GRAPH_EXTENDER_H

author	marci
	Tue, 01 Feb 2005 15:43:14 +0000
changeset 1113	b5ad821053a1
parent 1022	567f392d1d2e
child 1158	29961fa390a3
permissions	-rw-r--r--