1.1 --- a/lemon/concepts/bpgraph.h Thu Dec 01 09:05:47 2011 +0100
1.2 +++ b/lemon/concepts/bpgraph.h Wed Jan 11 22:21:07 2012 +0100
1.3 @@ -48,9 +48,9 @@
1.4 /// The bipartite graphs also fulfill the concept of \ref Graph
1.5 /// "undirected graphs". Bipartite graphs provide a bipartition of
1.6 /// the node set, namely a red and blue set of the nodes. The
1.7 - /// nodes can be iterated with the RedIt and BlueIt in the two
1.8 - /// node sets. With RedMap and BlueMap values can be assigned to
1.9 - /// the nodes in the two sets.
1.10 + /// nodes can be iterated with the RedNodeIt and BlueNodeIt in the
1.11 + /// two node sets. With RedNodeMap and BlueNodeMap values can be
1.12 + /// assigned to the nodes in the two sets.
1.13 ///
1.14 /// The edges of the graph cannot connect two nodes of the same
1.15 /// set. The edges inherent orientation is from the red nodes to
1.16 @@ -187,38 +187,38 @@
1.17 /// int count=0;
1.18 /// for (BpGraph::RedNodeIt n(g); n!=INVALID; ++n) ++count;
1.19 ///\endcode
1.20 - class RedIt : public RedNode {
1.21 + class RedNodeIt : public RedNode {
1.22 public:
1.23 /// Default constructor
1.24
1.25 /// Default constructor.
1.26 /// \warning It sets the iterator to an undefined value.
1.27 - RedIt() { }
1.28 + RedNodeIt() { }
1.29 /// Copy constructor.
1.30
1.31 /// Copy constructor.
1.32 ///
1.33 - RedIt(const RedIt& n) : RedNode(n) { }
1.34 + RedNodeIt(const RedNodeIt& n) : RedNode(n) { }
1.35 /// %Invalid constructor \& conversion.
1.36
1.37 /// Initializes the iterator to be invalid.
1.38 /// \sa Invalid for more details.
1.39 - RedIt(Invalid) { }
1.40 + RedNodeIt(Invalid) { }
1.41 /// Sets the iterator to the first red node.
1.42
1.43 /// Sets the iterator to the first red node of the given
1.44 /// digraph.
1.45 - explicit RedIt(const BpGraph&) { }
1.46 + explicit RedNodeIt(const BpGraph&) { }
1.47 /// Sets the iterator to the given red node.
1.48
1.49 /// Sets the iterator to the given red node of the given
1.50 /// digraph.
1.51 - RedIt(const BpGraph&, const RedNode&) { }
1.52 + RedNodeIt(const BpGraph&, const RedNode&) { }
1.53 /// Next node.
1.54
1.55 /// Assign the iterator to the next red node.
1.56 ///
1.57 - RedIt& operator++() { return *this; }
1.58 + RedNodeIt& operator++() { return *this; }
1.59 };
1.60
1.61 /// Iterator class for the blue nodes.
1.62 @@ -230,38 +230,38 @@
1.63 /// int count=0;
1.64 /// for (BpGraph::BlueNodeIt n(g); n!=INVALID; ++n) ++count;
1.65 ///\endcode
1.66 - class BlueIt : public BlueNode {
1.67 + class BlueNodeIt : public BlueNode {
1.68 public:
1.69 /// Default constructor
1.70
1.71 /// Default constructor.
1.72 /// \warning It sets the iterator to an undefined value.
1.73 - BlueIt() { }
1.74 + BlueNodeIt() { }
1.75 /// Copy constructor.
1.76
1.77 /// Copy constructor.
1.78 ///
1.79 - BlueIt(const BlueIt& n) : BlueNode(n) { }
1.80 + BlueNodeIt(const BlueNodeIt& n) : BlueNode(n) { }
1.81 /// %Invalid constructor \& conversion.
1.82
1.83 /// Initializes the iterator to be invalid.
1.84 /// \sa Invalid for more details.
1.85 - BlueIt(Invalid) { }
1.86 + BlueNodeIt(Invalid) { }
1.87 /// Sets the iterator to the first blue node.
1.88
1.89 /// Sets the iterator to the first blue node of the given
1.90 /// digraph.
1.91 - explicit BlueIt(const BpGraph&) { }
1.92 + explicit BlueNodeIt(const BpGraph&) { }
1.93 /// Sets the iterator to the given blue node.
1.94
1.95 /// Sets the iterator to the given blue node of the given
1.96 /// digraph.
1.97 - BlueIt(const BpGraph&, const BlueNode&) { }
1.98 + BlueNodeIt(const BpGraph&, const BlueNode&) { }
1.99 /// Next node.
1.100
1.101 /// Assign the iterator to the next blue node.
1.102 ///
1.103 - BlueIt& operator++() { return *this; }
1.104 + BlueNodeIt& operator++() { return *this; }
1.105 };
1.106
1.107 /// Iterator class for the nodes.
1.108 @@ -663,22 +663,22 @@
1.109 /// Standard graph map type for the red nodes.
1.110 /// It conforms to the ReferenceMap concept.
1.111 template<class T>
1.112 - class RedMap : public ReferenceMap<Node, T, T&, const T&>
1.113 + class RedNodeMap : public ReferenceMap<Node, T, T&, const T&>
1.114 {
1.115 public:
1.116
1.117 /// Constructor
1.118 - explicit RedMap(const BpGraph&) { }
1.119 + explicit RedNodeMap(const BpGraph&) { }
1.120 /// Constructor with given initial value
1.121 - RedMap(const BpGraph&, T) { }
1.122 + RedNodeMap(const BpGraph&, T) { }
1.123
1.124 private:
1.125 ///Copy constructor
1.126 - RedMap(const RedMap& nm) :
1.127 + RedNodeMap(const RedNodeMap& nm) :
1.128 ReferenceMap<Node, T, T&, const T&>(nm) { }
1.129 ///Assignment operator
1.130 template <typename CMap>
1.131 - RedMap& operator=(const CMap&) {
1.132 + RedNodeMap& operator=(const CMap&) {
1.133 checkConcept<ReadMap<Node, T>, CMap>();
1.134 return *this;
1.135 }
1.136 @@ -689,22 +689,22 @@
1.137 /// Standard graph map type for the blue nodes.
1.138 /// It conforms to the ReferenceMap concept.
1.139 template<class T>
1.140 - class BlueMap : public ReferenceMap<Node, T, T&, const T&>
1.141 + class BlueNodeMap : public ReferenceMap<Node, T, T&, const T&>
1.142 {
1.143 public:
1.144
1.145 /// Constructor
1.146 - explicit BlueMap(const BpGraph&) { }
1.147 + explicit BlueNodeMap(const BpGraph&) { }
1.148 /// Constructor with given initial value
1.149 - BlueMap(const BpGraph&, T) { }
1.150 + BlueNodeMap(const BpGraph&, T) { }
1.151
1.152 private:
1.153 ///Copy constructor
1.154 - BlueMap(const BlueMap& nm) :
1.155 + BlueNodeMap(const BlueNodeMap& nm) :
1.156 ReferenceMap<Node, T, T&, const T&>(nm) { }
1.157 ///Assignment operator
1.158 template <typename CMap>
1.159 - BlueMap& operator=(const CMap&) {
1.160 + BlueNodeMap& operator=(const CMap&) {
1.161 checkConcept<ReadMap<Node, T>, CMap>();
1.162 return *this;
1.163 }