1.1 --- a/lemon/bits/graph_extender.h Thu Dec 01 09:05:47 2011 +0100
1.2 +++ b/lemon/bits/graph_extender.h Wed Jan 11 22:21:07 2012 +0100
1.3 @@ -913,44 +913,44 @@
1.4
1.5 };
1.6
1.7 - class RedIt : public RedNode {
1.8 + class RedNodeIt : public RedNode {
1.9 const BpGraph* _graph;
1.10 public:
1.11
1.12 - RedIt() {}
1.13 + RedNodeIt() {}
1.14
1.15 - RedIt(Invalid i) : RedNode(i) { }
1.16 + RedNodeIt(Invalid i) : RedNode(i) { }
1.17
1.18 - explicit RedIt(const BpGraph& graph) : _graph(&graph) {
1.19 + explicit RedNodeIt(const BpGraph& graph) : _graph(&graph) {
1.20 _graph->first(static_cast<RedNode&>(*this));
1.21 }
1.22
1.23 - RedIt(const BpGraph& graph, const RedNode& node)
1.24 + RedNodeIt(const BpGraph& graph, const RedNode& node)
1.25 : RedNode(node), _graph(&graph) {}
1.26
1.27 - RedIt& operator++() {
1.28 + RedNodeIt& operator++() {
1.29 _graph->next(static_cast<RedNode&>(*this));
1.30 return *this;
1.31 }
1.32
1.33 };
1.34
1.35 - class BlueIt : public BlueNode {
1.36 + class BlueNodeIt : public BlueNode {
1.37 const BpGraph* _graph;
1.38 public:
1.39
1.40 - BlueIt() {}
1.41 + BlueNodeIt() {}
1.42
1.43 - BlueIt(Invalid i) : BlueNode(i) { }
1.44 + BlueNodeIt(Invalid i) : BlueNode(i) { }
1.45
1.46 - explicit BlueIt(const BpGraph& graph) : _graph(&graph) {
1.47 + explicit BlueNodeIt(const BpGraph& graph) : _graph(&graph) {
1.48 _graph->first(static_cast<BlueNode&>(*this));
1.49 }
1.50
1.51 - BlueIt(const BpGraph& graph, const BlueNode& node)
1.52 + BlueNodeIt(const BpGraph& graph, const BlueNode& node)
1.53 : BlueNode(node), _graph(&graph) {}
1.54
1.55 - BlueIt& operator++() {
1.56 + BlueNodeIt& operator++() {
1.57 _graph->next(static_cast<BlueNode&>(*this));
1.58 return *this;
1.59 }
1.60 @@ -1144,23 +1144,23 @@
1.61 };
1.62
1.63 template <typename _Value>
1.64 - class RedMap
1.65 + class RedNodeMap
1.66 : public MapExtender<DefaultMap<BpGraph, RedNode, _Value> > {
1.67 typedef MapExtender<DefaultMap<BpGraph, RedNode, _Value> > Parent;
1.68
1.69 public:
1.70 - explicit RedMap(const BpGraph& bpgraph)
1.71 + explicit RedNodeMap(const BpGraph& bpgraph)
1.72 : Parent(bpgraph) {}
1.73 - RedMap(const BpGraph& bpgraph, const _Value& value)
1.74 + RedNodeMap(const BpGraph& bpgraph, const _Value& value)
1.75 : Parent(bpgraph, value) {}
1.76
1.77 private:
1.78 - RedMap& operator=(const RedMap& cmap) {
1.79 - return operator=<RedMap>(cmap);
1.80 + RedNodeMap& operator=(const RedNodeMap& cmap) {
1.81 + return operator=<RedNodeMap>(cmap);
1.82 }
1.83
1.84 template <typename CMap>
1.85 - RedMap& operator=(const CMap& cmap) {
1.86 + RedNodeMap& operator=(const CMap& cmap) {
1.87 Parent::operator=(cmap);
1.88 return *this;
1.89 }
1.90 @@ -1168,23 +1168,23 @@
1.91 };
1.92
1.93 template <typename _Value>
1.94 - class BlueMap
1.95 + class BlueNodeMap
1.96 : public MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > {
1.97 typedef MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > Parent;
1.98
1.99 public:
1.100 - explicit BlueMap(const BpGraph& bpgraph)
1.101 + explicit BlueNodeMap(const BpGraph& bpgraph)
1.102 : Parent(bpgraph) {}
1.103 - BlueMap(const BpGraph& bpgraph, const _Value& value)
1.104 + BlueNodeMap(const BpGraph& bpgraph, const _Value& value)
1.105 : Parent(bpgraph, value) {}
1.106
1.107 private:
1.108 - BlueMap& operator=(const BlueMap& cmap) {
1.109 - return operator=<BlueMap>(cmap);
1.110 + BlueNodeMap& operator=(const BlueNodeMap& cmap) {
1.111 + return operator=<BlueNodeMap>(cmap);
1.112 }
1.113
1.114 template <typename CMap>
1.115 - BlueMap& operator=(const CMap& cmap) {
1.116 + BlueNodeMap& operator=(const CMap& cmap) {
1.117 Parent::operator=(cmap);
1.118 return *this;
1.119 }
2.1 --- a/lemon/bits/traits.h Thu Dec 01 09:05:47 2011 +0100
2.2 +++ b/lemon/bits/traits.h Wed Jan 11 22:21:07 2012 +0100
2.3 @@ -172,16 +172,16 @@
2.4 typedef GR Digraph;
2.5
2.6 typedef typename GR::RedNode Item;
2.7 - typedef typename GR::RedIt ItemIt;
2.8 + typedef typename GR::RedNodeIt ItemIt;
2.9
2.10 typedef typename RedNodeNotifierIndicator<GR>::Type ItemNotifier;
2.11
2.12 template <typename V>
2.13 - class Map : public GR::template RedMap<V> {
2.14 - typedef typename GR::template RedMap<V> Parent;
2.15 + class Map : public GR::template RedNodeMap<V> {
2.16 + typedef typename GR::template RedNodeMap<V> Parent;
2.17
2.18 public:
2.19 - typedef typename GR::template RedMap<V> Type;
2.20 + typedef typename GR::template RedNodeMap<V> Type;
2.21 typedef typename Parent::Value Value;
2.22
2.23 Map(const GR& _bpgraph) : Parent(_bpgraph) {}
2.24 @@ -213,16 +213,16 @@
2.25 typedef GR Digraph;
2.26
2.27 typedef typename GR::BlueNode Item;
2.28 - typedef typename GR::BlueIt ItemIt;
2.29 + typedef typename GR::BlueNodeIt ItemIt;
2.30
2.31 typedef typename BlueNodeNotifierIndicator<GR>::Type ItemNotifier;
2.32
2.33 template <typename V>
2.34 - class Map : public GR::template BlueMap<V> {
2.35 - typedef typename GR::template BlueMap<V> Parent;
2.36 + class Map : public GR::template BlueNodeMap<V> {
2.37 + typedef typename GR::template BlueNodeMap<V> Parent;
2.38
2.39 public:
2.40 - typedef typename GR::template BlueMap<V> Type;
2.41 + typedef typename GR::template BlueNodeMap<V> Type;
2.42 typedef typename Parent::Value Value;
2.43
2.44 Map(const GR& _bpgraph) : Parent(_bpgraph) {}
3.1 --- a/lemon/concepts/bpgraph.h Thu Dec 01 09:05:47 2011 +0100
3.2 +++ b/lemon/concepts/bpgraph.h Wed Jan 11 22:21:07 2012 +0100
3.3 @@ -48,9 +48,9 @@
3.4 /// The bipartite graphs also fulfill the concept of \ref Graph
3.5 /// "undirected graphs". Bipartite graphs provide a bipartition of
3.6 /// the node set, namely a red and blue set of the nodes. The
3.7 - /// nodes can be iterated with the RedIt and BlueIt in the two
3.8 - /// node sets. With RedMap and BlueMap values can be assigned to
3.9 - /// the nodes in the two sets.
3.10 + /// nodes can be iterated with the RedNodeIt and BlueNodeIt in the
3.11 + /// two node sets. With RedNodeMap and BlueNodeMap values can be
3.12 + /// assigned to the nodes in the two sets.
3.13 ///
3.14 /// The edges of the graph cannot connect two nodes of the same
3.15 /// set. The edges inherent orientation is from the red nodes to
3.16 @@ -187,38 +187,38 @@
3.17 /// int count=0;
3.18 /// for (BpGraph::RedNodeIt n(g); n!=INVALID; ++n) ++count;
3.19 ///\endcode
3.20 - class RedIt : public RedNode {
3.21 + class RedNodeIt : public RedNode {
3.22 public:
3.23 /// Default constructor
3.24
3.25 /// Default constructor.
3.26 /// \warning It sets the iterator to an undefined value.
3.27 - RedIt() { }
3.28 + RedNodeIt() { }
3.29 /// Copy constructor.
3.30
3.31 /// Copy constructor.
3.32 ///
3.33 - RedIt(const RedIt& n) : RedNode(n) { }
3.34 + RedNodeIt(const RedNodeIt& n) : RedNode(n) { }
3.35 /// %Invalid constructor \& conversion.
3.36
3.37 /// Initializes the iterator to be invalid.
3.38 /// \sa Invalid for more details.
3.39 - RedIt(Invalid) { }
3.40 + RedNodeIt(Invalid) { }
3.41 /// Sets the iterator to the first red node.
3.42
3.43 /// Sets the iterator to the first red node of the given
3.44 /// digraph.
3.45 - explicit RedIt(const BpGraph&) { }
3.46 + explicit RedNodeIt(const BpGraph&) { }
3.47 /// Sets the iterator to the given red node.
3.48
3.49 /// Sets the iterator to the given red node of the given
3.50 /// digraph.
3.51 - RedIt(const BpGraph&, const RedNode&) { }
3.52 + RedNodeIt(const BpGraph&, const RedNode&) { }
3.53 /// Next node.
3.54
3.55 /// Assign the iterator to the next red node.
3.56 ///
3.57 - RedIt& operator++() { return *this; }
3.58 + RedNodeIt& operator++() { return *this; }
3.59 };
3.60
3.61 /// Iterator class for the blue nodes.
3.62 @@ -230,38 +230,38 @@
3.63 /// int count=0;
3.64 /// for (BpGraph::BlueNodeIt n(g); n!=INVALID; ++n) ++count;
3.65 ///\endcode
3.66 - class BlueIt : public BlueNode {
3.67 + class BlueNodeIt : public BlueNode {
3.68 public:
3.69 /// Default constructor
3.70
3.71 /// Default constructor.
3.72 /// \warning It sets the iterator to an undefined value.
3.73 - BlueIt() { }
3.74 + BlueNodeIt() { }
3.75 /// Copy constructor.
3.76
3.77 /// Copy constructor.
3.78 ///
3.79 - BlueIt(const BlueIt& n) : BlueNode(n) { }
3.80 + BlueNodeIt(const BlueNodeIt& n) : BlueNode(n) { }
3.81 /// %Invalid constructor \& conversion.
3.82
3.83 /// Initializes the iterator to be invalid.
3.84 /// \sa Invalid for more details.
3.85 - BlueIt(Invalid) { }
3.86 + BlueNodeIt(Invalid) { }
3.87 /// Sets the iterator to the first blue node.
3.88
3.89 /// Sets the iterator to the first blue node of the given
3.90 /// digraph.
3.91 - explicit BlueIt(const BpGraph&) { }
3.92 + explicit BlueNodeIt(const BpGraph&) { }
3.93 /// Sets the iterator to the given blue node.
3.94
3.95 /// Sets the iterator to the given blue node of the given
3.96 /// digraph.
3.97 - BlueIt(const BpGraph&, const BlueNode&) { }
3.98 + BlueNodeIt(const BpGraph&, const BlueNode&) { }
3.99 /// Next node.
3.100
3.101 /// Assign the iterator to the next blue node.
3.102 ///
3.103 - BlueIt& operator++() { return *this; }
3.104 + BlueNodeIt& operator++() { return *this; }
3.105 };
3.106
3.107 /// Iterator class for the nodes.
3.108 @@ -663,22 +663,22 @@
3.109 /// Standard graph map type for the red nodes.
3.110 /// It conforms to the ReferenceMap concept.
3.111 template<class T>
3.112 - class RedMap : public ReferenceMap<Node, T, T&, const T&>
3.113 + class RedNodeMap : public ReferenceMap<Node, T, T&, const T&>
3.114 {
3.115 public:
3.116
3.117 /// Constructor
3.118 - explicit RedMap(const BpGraph&) { }
3.119 + explicit RedNodeMap(const BpGraph&) { }
3.120 /// Constructor with given initial value
3.121 - RedMap(const BpGraph&, T) { }
3.122 + RedNodeMap(const BpGraph&, T) { }
3.123
3.124 private:
3.125 ///Copy constructor
3.126 - RedMap(const RedMap& nm) :
3.127 + RedNodeMap(const RedNodeMap& nm) :
3.128 ReferenceMap<Node, T, T&, const T&>(nm) { }
3.129 ///Assignment operator
3.130 template <typename CMap>
3.131 - RedMap& operator=(const CMap&) {
3.132 + RedNodeMap& operator=(const CMap&) {
3.133 checkConcept<ReadMap<Node, T>, CMap>();
3.134 return *this;
3.135 }
3.136 @@ -689,22 +689,22 @@
3.137 /// Standard graph map type for the blue nodes.
3.138 /// It conforms to the ReferenceMap concept.
3.139 template<class T>
3.140 - class BlueMap : public ReferenceMap<Node, T, T&, const T&>
3.141 + class BlueNodeMap : public ReferenceMap<Node, T, T&, const T&>
3.142 {
3.143 public:
3.144
3.145 /// Constructor
3.146 - explicit BlueMap(const BpGraph&) { }
3.147 + explicit BlueNodeMap(const BpGraph&) { }
3.148 /// Constructor with given initial value
3.149 - BlueMap(const BpGraph&, T) { }
3.150 + BlueNodeMap(const BpGraph&, T) { }
3.151
3.152 private:
3.153 ///Copy constructor
3.154 - BlueMap(const BlueMap& nm) :
3.155 + BlueNodeMap(const BlueNodeMap& nm) :
3.156 ReferenceMap<Node, T, T&, const T&>(nm) { }
3.157 ///Assignment operator
3.158 template <typename CMap>
3.159 - BlueMap& operator=(const CMap&) {
3.160 + BlueNodeMap& operator=(const CMap&) {
3.161 checkConcept<ReadMap<Node, T>, CMap>();
3.162 return *this;
3.163 }
4.1 --- a/lemon/concepts/graph_components.h Thu Dec 01 09:05:47 2011 +0100
4.2 +++ b/lemon/concepts/graph_components.h Wed Jan 11 22:21:07 2012 +0100
4.3 @@ -1206,12 +1206,12 @@
4.4 /// \brief This iterator goes through each red node.
4.5 ///
4.6 /// This iterator goes through each red node.
4.7 - typedef GraphItemIt<BpGraph, RedNode> RedIt;
4.8 + typedef GraphItemIt<BpGraph, RedNode> RedNodeIt;
4.9
4.10 /// \brief This iterator goes through each blue node.
4.11 ///
4.12 /// This iterator goes through each blue node.
4.13 - typedef GraphItemIt<BpGraph, BlueNode> BlueIt;
4.14 + typedef GraphItemIt<BpGraph, BlueNode> BlueNodeIt;
4.15
4.16 /// @}
4.17
4.18 @@ -1228,9 +1228,9 @@
4.19 bpgraph.next(bn);
4.20
4.21 checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
4.22 - typename _BpGraph::RedIt>();
4.23 + typename _BpGraph::RedNodeIt>();
4.24 checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
4.25 - typename _BpGraph::BlueIt>();
4.26 + typename _BpGraph::BlueNodeIt>();
4.27 }
4.28
4.29 const _BpGraph& bpgraph;
4.30 @@ -1715,7 +1715,8 @@
4.31 /// This class describes the interface of mappable undirected
4.32 /// bipartite graphs. It extends \ref MappableGraphComponent with
4.33 /// the standard graph map class for red and blue nodes (\c
4.34 - /// RedMap and BlueMap). This concept is part of the BpGraph concept.
4.35 + /// RedNodeMap and BlueNodeMap). This concept is part of the
4.36 + /// BpGraph concept.
4.37 template <typename BAS = BaseBpGraphComponent>
4.38 class MappableBpGraphComponent : public MappableGraphComponent<BAS> {
4.39 public:
4.40 @@ -1730,33 +1731,33 @@
4.41 /// Standard graph map for the red nodes.
4.42 /// It conforms to the ReferenceMap concept.
4.43 template <typename V>
4.44 - class RedMap : public GraphMap<MappableBpGraphComponent, Node, V> {
4.45 + class RedNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
4.46 typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
4.47
4.48 public:
4.49 /// \brief Construct a new map.
4.50 ///
4.51 /// Construct a new map for the graph.
4.52 - explicit RedMap(const MappableBpGraphComponent& graph)
4.53 + explicit RedNodeMap(const MappableBpGraphComponent& graph)
4.54 : Parent(graph) {}
4.55
4.56 /// \brief Construct a new map with default value.
4.57 ///
4.58 /// Construct a new map for the graph and initalize the values.
4.59 - RedMap(const MappableBpGraphComponent& graph, const V& value)
4.60 + RedNodeMap(const MappableBpGraphComponent& graph, const V& value)
4.61 : Parent(graph, value) {}
4.62
4.63 private:
4.64 /// \brief Copy constructor.
4.65 ///
4.66 /// Copy Constructor.
4.67 - RedMap(const RedMap& nm) : Parent(nm) {}
4.68 + RedNodeMap(const RedNodeMap& nm) : Parent(nm) {}
4.69
4.70 /// \brief Assignment operator.
4.71 ///
4.72 /// Assignment operator.
4.73 template <typename CMap>
4.74 - RedMap& operator=(const CMap&) {
4.75 + RedNodeMap& operator=(const CMap&) {
4.76 checkConcept<ReadMap<Node, V>, CMap>();
4.77 return *this;
4.78 }
4.79 @@ -1768,33 +1769,33 @@
4.80 /// Standard graph map for the blue nodes.
4.81 /// It conforms to the ReferenceMap concept.
4.82 template <typename V>
4.83 - class BlueMap : public GraphMap<MappableBpGraphComponent, Node, V> {
4.84 + class BlueNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
4.85 typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
4.86
4.87 public:
4.88 /// \brief Construct a new map.
4.89 ///
4.90 /// Construct a new map for the graph.
4.91 - explicit BlueMap(const MappableBpGraphComponent& graph)
4.92 + explicit BlueNodeMap(const MappableBpGraphComponent& graph)
4.93 : Parent(graph) {}
4.94
4.95 /// \brief Construct a new map with default value.
4.96 ///
4.97 /// Construct a new map for the graph and initalize the values.
4.98 - BlueMap(const MappableBpGraphComponent& graph, const V& value)
4.99 + BlueNodeMap(const MappableBpGraphComponent& graph, const V& value)
4.100 : Parent(graph, value) {}
4.101
4.102 private:
4.103 /// \brief Copy constructor.
4.104 ///
4.105 /// Copy Constructor.
4.106 - BlueMap(const BlueMap& nm) : Parent(nm) {}
4.107 + BlueNodeMap(const BlueNodeMap& nm) : Parent(nm) {}
4.108
4.109 /// \brief Assignment operator.
4.110 ///
4.111 /// Assignment operator.
4.112 template <typename CMap>
4.113 - BlueMap& operator=(const CMap&) {
4.114 + BlueNodeMap& operator=(const CMap&) {
4.115 checkConcept<ReadMap<Node, V>, CMap>();
4.116 return *this;
4.117 }
4.118 @@ -1815,31 +1816,37 @@
4.119 checkConcept<MappableGraphComponent<Base>, _BpGraph>();
4.120
4.121 { // int map test
4.122 - typedef typename _BpGraph::template RedMap<int> IntRedMap;
4.123 + typedef typename _BpGraph::template RedNodeMap<int>
4.124 + IntRedNodeMap;
4.125 checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
4.126 - IntRedMap >();
4.127 + IntRedNodeMap >();
4.128 } { // bool map test
4.129 - typedef typename _BpGraph::template RedMap<bool> BoolRedMap;
4.130 + typedef typename _BpGraph::template RedNodeMap<bool>
4.131 + BoolRedNodeMap;
4.132 checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
4.133 - BoolRedMap >();
4.134 + BoolRedNodeMap >();
4.135 } { // Dummy map test
4.136 - typedef typename _BpGraph::template RedMap<Dummy> DummyRedMap;
4.137 + typedef typename _BpGraph::template RedNodeMap<Dummy>
4.138 + DummyRedNodeMap;
4.139 checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
4.140 - DummyRedMap >();
4.141 + DummyRedNodeMap >();
4.142 }
4.143
4.144 { // int map test
4.145 - typedef typename _BpGraph::template BlueMap<int> IntBlueMap;
4.146 + typedef typename _BpGraph::template BlueNodeMap<int>
4.147 + IntBlueNodeMap;
4.148 checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
4.149 - IntBlueMap >();
4.150 + IntBlueNodeMap >();
4.151 } { // bool map test
4.152 - typedef typename _BpGraph::template BlueMap<bool> BoolBlueMap;
4.153 + typedef typename _BpGraph::template BlueNodeMap<bool>
4.154 + BoolBlueNodeMap;
4.155 checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
4.156 - BoolBlueMap >();
4.157 + BoolBlueNodeMap >();
4.158 } { // Dummy map test
4.159 - typedef typename _BpGraph::template BlueMap<Dummy> DummyBlueMap;
4.160 + typedef typename _BpGraph::template BlueNodeMap<Dummy>
4.161 + DummyBlueNodeMap;
4.162 checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
4.163 - DummyBlueMap >();
4.164 + DummyBlueNodeMap >();
4.165 }
4.166 }
4.167
5.1 --- a/lemon/core.h Thu Dec 01 09:05:47 2011 +0100
5.2 +++ b/lemon/core.h Wed Jan 11 22:21:07 2012 +0100
5.3 @@ -150,10 +150,11 @@
5.4
5.5 ///Create convenience typedefs for the bipartite graph types and iterators
5.6
5.7 - ///This \c \#define creates the same convenient type definitions as defined
5.8 - ///by \ref GRAPH_TYPEDEFS(BpGraph) and ten more, namely it creates
5.9 - ///\c RedNode, \c RedIt, \c BoolRedMap, \c IntRedMap, \c DoubleRedMap,
5.10 - ///\c BlueNode, \c BlueIt, \c BoolBlueMap, \c IntBlueMap, \c DoubleBlueMap.
5.11 + ///This \c \#define creates the same convenient type definitions as
5.12 + ///defined by \ref GRAPH_TYPEDEFS(BpGraph) and ten more, namely it
5.13 + ///creates \c RedNode, \c RedNodeIt, \c BoolRedNodeMap,
5.14 + ///\c IntRedNodeMap, \c DoubleRedNodeMap, \c BlueNode, \c BlueNodeIt,
5.15 + ///\c BoolBlueNodeMap, \c IntBlueNodeMap, \c DoubleBlueNodeMap.
5.16 ///
5.17 ///\note If the graph type is a dependent type, ie. the graph type depend
5.18 ///on a template parameter, then use \c TEMPLATE_BPGRAPH_TYPEDEFS()
5.19 @@ -161,15 +162,15 @@
5.20 #define BPGRAPH_TYPEDEFS(BpGraph) \
5.21 GRAPH_TYPEDEFS(BpGraph); \
5.22 typedef BpGraph::RedNode RedNode; \
5.23 - typedef BpGraph::RedIt RedIt; \
5.24 - typedef BpGraph::RedMap<bool> BoolRedMap; \
5.25 - typedef BpGraph::RedMap<int> IntRedMap; \
5.26 - typedef BpGraph::RedMap<double> DoubleRedMap; \
5.27 + typedef BpGraph::RedNodeIt RedNodeIt; \
5.28 + typedef BpGraph::RedNodeMap<bool> BoolRedNodeMap; \
5.29 + typedef BpGraph::RedNodeMap<int> IntRedNodeMap; \
5.30 + typedef BpGraph::RedNodeMap<double> DoubleRedNodeMap; \
5.31 typedef BpGraph::BlueNode BlueNode; \
5.32 - typedef BpGraph::BlueIt BlueIt; \
5.33 - typedef BpGraph::BlueMap<bool> BoolBlueMap; \
5.34 - typedef BpGraph::BlueMap<int> IntBlueMap; \
5.35 - typedef BpGraph::BlueMap<double> DoubleBlueMap
5.36 + typedef BpGraph::BlueNodeIt BlueNodeIt; \
5.37 + typedef BpGraph::BlueNodeMap<bool> BoolBlueNodeMap; \
5.38 + typedef BpGraph::BlueNodeMap<int> IntBlueNodeMap; \
5.39 + typedef BpGraph::BlueNodeMap<double> DoubleBlueNodeMap
5.40
5.41 ///Create convenience typedefs for the bipartite graph types and iterators
5.42
5.43 @@ -177,18 +178,18 @@
5.44 ///
5.45 ///\note Use this macro, if the graph type is a dependent type,
5.46 ///ie. the graph type depend on a template parameter.
5.47 -#define TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph) \
5.48 - TEMPLATE_GRAPH_TYPEDEFS(BpGraph); \
5.49 - typedef typename BpGraph::RedNode RedNode; \
5.50 - typedef typename BpGraph::RedIt RedIt; \
5.51 - typedef typename BpGraph::template RedMap<bool> BoolRedMap; \
5.52 - typedef typename BpGraph::template RedMap<int> IntRedMap; \
5.53 - typedef typename BpGraph::template RedMap<double> DoubleRedMap; \
5.54 - typedef typename BpGraph::BlueNode BlueNode; \
5.55 - typedef typename BpGraph::BlueIt BlueIt; \
5.56 - typedef typename BpGraph::template BlueMap<bool> BoolBlueMap; \
5.57 - typedef typename BpGraph::template BlueMap<int> IntBlueMap; \
5.58 - typedef typename BpGraph::template BlueMap<double> DoubleBlueMap
5.59 +#define TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph) \
5.60 + TEMPLATE_GRAPH_TYPEDEFS(BpGraph); \
5.61 + typedef typename BpGraph::RedNode RedNode; \
5.62 + typedef typename BpGraph::RedNodeIt RedNodeIt; \
5.63 + typedef typename BpGraph::template RedNodeMap<bool> BoolRedNodeMap; \
5.64 + typedef typename BpGraph::template RedNodeMap<int> IntRedNodeMap; \
5.65 + typedef typename BpGraph::template RedNodeMap<double> DoubleRedNodeMap; \
5.66 + typedef typename BpGraph::BlueNode BlueNode; \
5.67 + typedef typename BpGraph::BlueNodeIt BlueNodeIt; \
5.68 + typedef typename BpGraph::template BlueNodeMap<bool> BoolBlueNodeMap; \
5.69 + typedef typename BpGraph::template BlueNodeMap<int> IntBlueNodeMap; \
5.70 + typedef typename BpGraph::template BlueNodeMap<double> DoubleBlueNodeMap
5.71
5.72 /// \brief Function to count the items in a graph.
5.73 ///
5.74 @@ -565,10 +566,10 @@
5.75 BlueNodeRefMap& blueNodeRefMap,
5.76 EdgeRefMap& edgeRefMap) {
5.77 to.clear();
5.78 - for (typename From::RedIt it(from); it != INVALID; ++it) {
5.79 + for (typename From::RedNodeIt it(from); it != INVALID; ++it) {
5.80 redNodeRefMap[it] = to.addRedNode();
5.81 }
5.82 - for (typename From::BlueIt it(from); it != INVALID; ++it) {
5.83 + for (typename From::BlueNodeIt it(from); it != INVALID; ++it) {
5.84 blueNodeRefMap[it] = to.addBlueNode();
5.85 }
5.86 for (typename From::EdgeIt it(from); it != INVALID; ++it) {
5.87 @@ -1164,10 +1165,10 @@
5.88 /// // Create cross references (inverse) for the edges
5.89 /// NewBpGraph::EdgeMap<OrigBpGraph::Edge> ecr(new_graph);
5.90 /// cg.edgeCrossRef(ecr);
5.91 - /// // Copy a red map
5.92 - /// OrigBpGraph::RedMap<double> ormap(orig_graph);
5.93 - /// NewBpGraph::RedMap<double> nrmap(new_graph);
5.94 - /// cg.edgeMap(ormap, nrmap);
5.95 + /// // Copy a red node map
5.96 + /// OrigBpGraph::RedNodeMap<double> ormap(orig_graph);
5.97 + /// NewBpGraph::RedNodeMap<double> nrmap(new_graph);
5.98 + /// cg.redNodeMap(ormap, nrmap);
5.99 /// // Copy a node
5.100 /// OrigBpGraph::Node on;
5.101 /// NewBpGraph::Node nn;
5.102 @@ -1194,8 +1195,8 @@
5.103 typedef typename To::Arc TArc;
5.104 typedef typename To::Edge TEdge;
5.105
5.106 - typedef typename From::template RedMap<TRedNode> RedNodeRefMap;
5.107 - typedef typename From::template BlueMap<TBlueNode> BlueNodeRefMap;
5.108 + typedef typename From::template RedNodeMap<TRedNode> RedNodeRefMap;
5.109 + typedef typename From::template BlueNodeMap<TBlueNode> BlueNodeRefMap;
5.110 typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
5.111
5.112 struct NodeRefMap {
5.113 @@ -1352,7 +1353,7 @@
5.114 /// the original map \c map should be the Node type of the source
5.115 /// graph.
5.116 template <typename FromMap, typename ToMap>
5.117 - BpGraphCopy& redMap(const FromMap& map, ToMap& tmap) {
5.118 + BpGraphCopy& redNodeMap(const FromMap& map, ToMap& tmap) {
5.119 _red_maps.push_back(new _core_bits::MapCopy<From, RedNode,
5.120 RedNodeRefMap, FromMap, ToMap>(map, tmap));
5.121 return *this;
5.122 @@ -1403,7 +1404,7 @@
5.123 /// the original map \c map should be the Node type of the source
5.124 /// graph.
5.125 template <typename FromMap, typename ToMap>
5.126 - BpGraphCopy& blueMap(const FromMap& map, ToMap& tmap) {
5.127 + BpGraphCopy& blueNodeMap(const FromMap& map, ToMap& tmap) {
5.128 _blue_maps.push_back(new _core_bits::MapCopy<From, BlueNode,
5.129 BlueNodeRefMap, FromMap, ToMap>(map, tmap));
5.130 return *this;
6.1 --- a/lemon/lgf_reader.h Thu Dec 01 09:05:47 2011 +0100
6.2 +++ b/lemon/lgf_reader.h Wed Jan 11 22:21:07 2012 +0100
6.3 @@ -2148,7 +2148,7 @@
6.4 /// reads the red and blue nodes from separate sections, and these
6.5 /// sections can contain different set of maps.
6.6 ///
6.7 - /// The red and blue maps are read from the corresponding
6.8 + /// The red and blue node maps are read from the corresponding
6.9 /// sections. If a map is defined with the same name in both of
6.10 /// these sections, then it can be read as a node map.
6.11 template <typename BGR>
6.12 @@ -2337,9 +2337,9 @@
6.13 return *this;
6.14 }
6.15
6.16 - /// Add a red map reading rule to the reader.
6.17 + /// Add a red node map reading rule to the reader.
6.18 template <typename Map>
6.19 - BpGraphReader& redMap(const std::string& caption, Map& map) {
6.20 + BpGraphReader& redNodeMap(const std::string& caption, Map& map) {
6.21 checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
6.22 _reader_bits::MapStorageBase<Node>* storage =
6.23 new _reader_bits::MapStorage<Node, Map>(map);
6.24 @@ -2347,13 +2347,13 @@
6.25 return *this;
6.26 }
6.27
6.28 - /// \brief Red map reading rule
6.29 + /// \brief Red node map reading rule
6.30 ///
6.31 - /// Add a red map reading rule with specialized converter to the
6.32 - /// reader.
6.33 + /// Add a red node map node reading rule with specialized converter to
6.34 + /// the reader.
6.35 template <typename Map, typename Converter>
6.36 - BpGraphReader& redMap(const std::string& caption, Map& map,
6.37 - const Converter& converter = Converter()) {
6.38 + BpGraphReader& redNodeMap(const std::string& caption, Map& map,
6.39 + const Converter& converter = Converter()) {
6.40 checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
6.41 _reader_bits::MapStorageBase<Node>* storage =
6.42 new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
6.43 @@ -2361,9 +2361,9 @@
6.44 return *this;
6.45 }
6.46
6.47 - /// Add a blue map reading rule to the reader.
6.48 + /// Add a blue node map reading rule to the reader.
6.49 template <typename Map>
6.50 - BpGraphReader& blueMap(const std::string& caption, Map& map) {
6.51 + BpGraphReader& blueNodeMap(const std::string& caption, Map& map) {
6.52 checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
6.53 _reader_bits::MapStorageBase<Node>* storage =
6.54 new _reader_bits::MapStorage<Node, Map>(map);
6.55 @@ -2371,13 +2371,13 @@
6.56 return *this;
6.57 }
6.58
6.59 - /// \brief Blue map reading rule
6.60 + /// \brief Blue node map reading rule
6.61 ///
6.62 - /// Add a blue map reading rule with specialized converter to the
6.63 - /// reader.
6.64 + /// Add a blue node map reading rule with specialized converter to
6.65 + /// the reader.
6.66 template <typename Map, typename Converter>
6.67 - BpGraphReader& blueMap(const std::string& caption, Map& map,
6.68 - const Converter& converter = Converter()) {
6.69 + BpGraphReader& blueNodeMap(const std::string& caption, Map& map,
6.70 + const Converter& converter = Converter()) {
6.71 checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
6.72 _reader_bits::MapStorageBase<Node>* storage =
6.73 new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
6.74 @@ -2684,7 +2684,7 @@
6.75 while (_reader_bits::readToken(line, map)) {
6.76 if (maps.find(map) != maps.end()) {
6.77 std::ostringstream msg;
6.78 - msg << "Multiple occurence of red map: " << map;
6.79 + msg << "Multiple occurence of red node map: " << map;
6.80 throw FormatError(msg.str());
6.81 }
6.82 maps.insert(std::make_pair(map, index));
6.83 @@ -2777,7 +2777,7 @@
6.84 while (_reader_bits::readToken(line, map)) {
6.85 if (maps.find(map) != maps.end()) {
6.86 std::ostringstream msg;
6.87 - msg << "Multiple occurence of blue map: " << map;
6.88 + msg << "Multiple occurence of blue node map: " << map;
6.89 throw FormatError(msg.str());
6.90 }
6.91 maps.insert(std::make_pair(map, index));
7.1 --- a/lemon/lgf_writer.h Thu Dec 01 09:05:47 2011 +0100
7.2 +++ b/lemon/lgf_writer.h Wed Jan 11 22:21:07 2012 +0100
7.3 @@ -1629,7 +1629,7 @@
7.4 /// reads the red and blue nodes from separate sections, and these
7.5 /// sections can contain different set of maps.
7.6 ///
7.7 - /// The red and blue maps are written to the corresponding
7.8 + /// The red and blue node maps are written to the corresponding
7.9 /// sections. The node maps are written to both of these sections
7.10 /// with the same map name.
7.11 template <typename BGR>
7.12 @@ -1805,11 +1805,11 @@
7.13 return *this;
7.14 }
7.15
7.16 - /// \brief Red map writing rule
7.17 + /// \brief Red node map writing rule
7.18 ///
7.19 - /// Add a red map writing rule to the writer.
7.20 + /// Add a red node map writing rule to the writer.
7.21 template <typename Map>
7.22 - BpGraphWriter& redMap(const std::string& caption, const Map& map) {
7.23 + BpGraphWriter& redNodeMap(const std::string& caption, const Map& map) {
7.24 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
7.25 _writer_bits::MapStorageBase<Node>* storage =
7.26 new _writer_bits::MapStorage<Node, Map>(map);
7.27 @@ -1817,13 +1817,13 @@
7.28 return *this;
7.29 }
7.30
7.31 - /// \brief Red map writing rule
7.32 + /// \brief Red node map writing rule
7.33 ///
7.34 - /// Add a red map writing rule with specialized converter to the
7.35 + /// Add a red node map writing rule with specialized converter to the
7.36 /// writer.
7.37 template <typename Map, typename Converter>
7.38 - BpGraphWriter& redMap(const std::string& caption, const Map& map,
7.39 - const Converter& converter = Converter()) {
7.40 + BpGraphWriter& redNodeMap(const std::string& caption, const Map& map,
7.41 + const Converter& converter = Converter()) {
7.42 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
7.43 _writer_bits::MapStorageBase<Node>* storage =
7.44 new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
7.45 @@ -1831,11 +1831,11 @@
7.46 return *this;
7.47 }
7.48
7.49 - /// \brief Blue map writing rule
7.50 + /// \brief Blue node map writing rule
7.51 ///
7.52 - /// Add a blue map writing rule to the writer.
7.53 + /// Add a blue node map writing rule to the writer.
7.54 template <typename Map>
7.55 - BpGraphWriter& blueMap(const std::string& caption, const Map& map) {
7.56 + BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map) {
7.57 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
7.58 _writer_bits::MapStorageBase<Node>* storage =
7.59 new _writer_bits::MapStorage<Node, Map>(map);
7.60 @@ -1843,13 +1843,13 @@
7.61 return *this;
7.62 }
7.63
7.64 - /// \brief Blue map writing rule
7.65 + /// \brief Blue node map writing rule
7.66 ///
7.67 - /// Add a blue map writing rule with specialized converter to the
7.68 + /// Add a blue node map writing rule with specialized converter to the
7.69 /// writer.
7.70 template <typename Map, typename Converter>
7.71 - BpGraphWriter& blueMap(const std::string& caption, const Map& map,
7.72 - const Converter& converter = Converter()) {
7.73 + BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map,
7.74 + const Converter& converter = Converter()) {
7.75 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
7.76 _writer_bits::MapStorageBase<Node>* storage =
7.77 new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
7.78 @@ -2058,7 +2058,7 @@
7.79 *_os << std::endl;
7.80
7.81 std::vector<Node> nodes;
7.82 - for (RedIt n(_graph); n != INVALID; ++n) {
7.83 + for (RedNodeIt n(_graph); n != INVALID; ++n) {
7.84 nodes.push_back(n);
7.85 }
7.86
7.87 @@ -2118,7 +2118,7 @@
7.88 *_os << std::endl;
7.89
7.90 std::vector<Node> nodes;
7.91 - for (BlueIt n(_graph); n != INVALID; ++n) {
7.92 + for (BlueNodeIt n(_graph); n != INVALID; ++n) {
7.93 nodes.push_back(n);
7.94 }
7.95
8.1 --- a/test/bpgraph_test.cc Thu Dec 01 09:05:47 2011 +0100
8.2 +++ b/test/bpgraph_test.cc Wed Jan 11 22:21:07 2012 +0100
8.3 @@ -101,8 +101,8 @@
8.4 checkEdgeIds(G);
8.5
8.6 checkGraphNodeMap(G);
8.7 - checkGraphRedMap(G);
8.8 - checkGraphBlueMap(G);
8.9 + checkGraphRedNodeMap(G);
8.10 + checkGraphBlueNodeMap(G);
8.11 checkGraphArcMap(G);
8.12 checkGraphEdgeMap(G);
8.13 }
8.14 @@ -260,8 +260,8 @@
8.15 checkEdgeIds(G);
8.16
8.17 checkGraphNodeMap(G);
8.18 - checkGraphRedMap(G);
8.19 - checkGraphBlueMap(G);
8.20 + checkGraphRedNodeMap(G);
8.21 + checkGraphBlueNodeMap(G);
8.22 checkGraphArcMap(G);
8.23 checkGraphEdgeMap(G);
8.24
8.25 @@ -369,13 +369,13 @@
8.26 checkGraphEdgeList(G, redNum * blueNum);
8.27 checkGraphArcList(G, 2 * redNum * blueNum);
8.28
8.29 - for (RedIt n(G); n != INVALID; ++n) {
8.30 + for (RedNodeIt n(G); n != INVALID; ++n) {
8.31 checkGraphOutArcList(G, n, blueNum);
8.32 checkGraphInArcList(G, n, blueNum);
8.33 checkGraphIncEdgeList(G, n, blueNum);
8.34 }
8.35
8.36 - for (BlueIt n(G); n != INVALID; ++n) {
8.37 + for (BlueNodeIt n(G); n != INVALID; ++n) {
8.38 checkGraphOutArcList(G, n, redNum);
8.39 checkGraphInArcList(G, n, redNum);
8.40 checkGraphIncEdgeList(G, n, redNum);
8.41 @@ -393,8 +393,8 @@
8.42 checkEdgeIds(G);
8.43
8.44 checkGraphNodeMap(G);
8.45 - checkGraphRedMap(G);
8.46 - checkGraphBlueMap(G);
8.47 + checkGraphRedNodeMap(G);
8.48 + checkGraphBlueNodeMap(G);
8.49 checkGraphArcMap(G);
8.50 checkGraphEdgeMap(G);
8.51
9.1 --- a/test/graph_copy_test.cc Thu Dec 01 09:05:47 2011 +0100
9.2 +++ b/test/graph_copy_test.cc Wed Jan 11 22:21:07 2012 +0100
9.3 @@ -216,8 +216,8 @@
9.4 // Build a graph
9.5 SmartBpGraph from;
9.6 SmartBpGraph::NodeMap<int> fnm(from);
9.7 - SmartBpGraph::RedMap<int> frnm(from);
9.8 - SmartBpGraph::BlueMap<int> fbnm(from);
9.9 + SmartBpGraph::RedNodeMap<int> frnm(from);
9.10 + SmartBpGraph::BlueNodeMap<int> fbnm(from);
9.11 SmartBpGraph::ArcMap<int> fam(from);
9.12 SmartBpGraph::EdgeMap<int> fem(from);
9.13 SmartBpGraph::Node fn = INVALID;
9.14 @@ -261,8 +261,8 @@
9.15 // Test graph copy
9.16 GR to;
9.17 typename GR::template NodeMap<int> tnm(to);
9.18 - typename GR::template RedMap<int> trnm(to);
9.19 - typename GR::template BlueMap<int> tbnm(to);
9.20 + typename GR::template RedNodeMap<int> trnm(to);
9.21 + typename GR::template BlueNodeMap<int> tbnm(to);
9.22 typename GR::template ArcMap<int> tam(to);
9.23 typename GR::template EdgeMap<int> tem(to);
9.24 typename GR::Node tn;
9.25 @@ -272,19 +272,20 @@
9.26 typename GR::Edge te;
9.27
9.28 SmartBpGraph::NodeMap<typename GR::Node> nr(from);
9.29 - SmartBpGraph::RedMap<typename GR::RedNode> rnr(from);
9.30 - SmartBpGraph::BlueMap<typename GR::BlueNode> bnr(from);
9.31 + SmartBpGraph::RedNodeMap<typename GR::RedNode> rnr(from);
9.32 + SmartBpGraph::BlueNodeMap<typename GR::BlueNode> bnr(from);
9.33 SmartBpGraph::ArcMap<typename GR::Arc> ar(from);
9.34 SmartBpGraph::EdgeMap<typename GR::Edge> er(from);
9.35
9.36 typename GR::template NodeMap<SmartBpGraph::Node> ncr(to);
9.37 - typename GR::template RedMap<SmartBpGraph::RedNode> rncr(to);
9.38 - typename GR::template BlueMap<SmartBpGraph::BlueNode> bncr(to);
9.39 + typename GR::template RedNodeMap<SmartBpGraph::RedNode> rncr(to);
9.40 + typename GR::template BlueNodeMap<SmartBpGraph::BlueNode> bncr(to);
9.41 typename GR::template ArcMap<SmartBpGraph::Arc> acr(to);
9.42 typename GR::template EdgeMap<SmartBpGraph::Edge> ecr(to);
9.43
9.44 bpGraphCopy(from, to).
9.45 - nodeMap(fnm, tnm).redMap(frnm, trnm).blueMap(fbnm, tbnm).
9.46 + nodeMap(fnm, tnm).
9.47 + redNodeMap(frnm, trnm).blueNodeMap(fbnm, tbnm).
9.48 arcMap(fam, tam).edgeMap(fem, tem).
9.49 nodeRef(nr).redRef(rnr).blueRef(bnr).
9.50 arcRef(ar).edgeRef(er).
9.51 @@ -304,7 +305,7 @@
9.52 check(fnm[it] == tnm[nr[it]], "Wrong copy.");
9.53 }
9.54
9.55 - for (SmartBpGraph::RedIt it(from); it != INVALID; ++it) {
9.56 + for (SmartBpGraph::RedNodeIt it(from); it != INVALID; ++it) {
9.57 check(ncr[nr[it]] == it, "Wrong copy.");
9.58 check(fnm[it] == tnm[nr[it]], "Wrong copy.");
9.59 check(rnr[it] == nr[it], "Wrong copy.");
9.60 @@ -313,7 +314,7 @@
9.61 check(to.red(rnr[it]), "Wrong copy.");
9.62 }
9.63
9.64 - for (SmartBpGraph::BlueIt it(from); it != INVALID; ++it) {
9.65 + for (SmartBpGraph::BlueNodeIt it(from); it != INVALID; ++it) {
9.66 check(ncr[nr[it]] == it, "Wrong copy.");
9.67 check(fnm[it] == tnm[nr[it]], "Wrong copy.");
9.68 check(bnr[it] == nr[it], "Wrong copy.");
9.69 @@ -343,11 +344,11 @@
9.70 for (typename GR::NodeIt it(to); it != INVALID; ++it) {
9.71 check(nr[ncr[it]] == it, "Wrong copy.");
9.72 }
9.73 - for (typename GR::RedIt it(to); it != INVALID; ++it) {
9.74 + for (typename GR::RedNodeIt it(to); it != INVALID; ++it) {
9.75 check(rncr[it] == ncr[it], "Wrong copy.");
9.76 check(rnr[rncr[it]] == it, "Wrong copy.");
9.77 }
9.78 - for (typename GR::BlueIt it(to); it != INVALID; ++it) {
9.79 + for (typename GR::BlueNodeIt it(to); it != INVALID; ++it) {
9.80 check(bncr[it] == ncr[it], "Wrong copy.");
9.81 check(bnr[bncr[it]] == it, "Wrong copy.");
9.82 }
10.1 --- a/test/graph_test.h Thu Dec 01 09:05:47 2011 +0100
10.2 +++ b/test/graph_test.h Wed Jan 11 22:21:07 2012 +0100
10.3 @@ -43,7 +43,7 @@
10.4 template<class Graph>
10.5 void checkGraphRedNodeList(const Graph &G, int cnt)
10.6 {
10.7 - typename Graph::RedIt n(G);
10.8 + typename Graph::RedNodeIt n(G);
10.9 for(int i=0;i<cnt;i++) {
10.10 check(n!=INVALID,"Wrong red Node list linking.");
10.11 check(G.red(n),"Wrong node set check.");
10.12 @@ -65,7 +65,7 @@
10.13 template<class Graph>
10.14 void checkGraphBlueNodeList(const Graph &G, int cnt)
10.15 {
10.16 - typename Graph::BlueIt n(G);
10.17 + typename Graph::BlueNodeIt n(G);
10.18 for(int i=0;i<cnt;i++) {
10.19 check(n!=INVALID,"Wrong blue Node list linking.");
10.20 check(G.blue(n),"Wrong node set check.");
10.21 @@ -225,7 +225,7 @@
10.22 void checkRedNodeIds(const Graph& G) {
10.23 typedef typename Graph::RedNode RedNode;
10.24 std::set<int> values;
10.25 - for (typename Graph::RedIt n(G); n != INVALID; ++n) {
10.26 + for (typename Graph::RedNodeIt n(G); n != INVALID; ++n) {
10.27 check(G.red(n), "Wrong partition");
10.28 check(values.find(G.id(n)) == values.end(), "Wrong id");
10.29 check(G.id(n) <= G.maxRedId(), "Wrong maximum id");
10.30 @@ -238,7 +238,7 @@
10.31 void checkBlueNodeIds(const Graph& G) {
10.32 typedef typename Graph::BlueNode BlueNode;
10.33 std::set<int> values;
10.34 - for (typename Graph::BlueIt n(G); n != INVALID; ++n) {
10.35 + for (typename Graph::BlueNodeIt n(G); n != INVALID; ++n) {
10.36 check(G.blue(n), "Wrong partition");
10.37 check(values.find(G.id(n)) == values.end(), "Wrong id");
10.38 check(G.id(n) <= G.maxBlueId(), "Wrong maximum id");
10.39 @@ -304,17 +304,17 @@
10.40 }
10.41
10.42 template <typename Graph>
10.43 - void checkGraphRedMap(const Graph& G) {
10.44 + void checkGraphRedNodeMap(const Graph& G) {
10.45 typedef typename Graph::Node Node;
10.46 - typedef typename Graph::RedIt RedIt;
10.47 + typedef typename Graph::RedNodeIt RedNodeIt;
10.48
10.49 - typedef typename Graph::template RedMap<int> IntRedMap;
10.50 - IntRedMap map(G, 42);
10.51 - for (RedIt it(G); it != INVALID; ++it) {
10.52 + typedef typename Graph::template RedNodeMap<int> IntRedNodeMap;
10.53 + IntRedNodeMap map(G, 42);
10.54 + for (RedNodeIt it(G); it != INVALID; ++it) {
10.55 check(map[it] == 42, "Wrong map constructor.");
10.56 }
10.57 int s = 0;
10.58 - for (RedIt it(G); it != INVALID; ++it) {
10.59 + for (RedNodeIt it(G); it != INVALID; ++it) {
10.60 map[it] = 0;
10.61 check(map[it] == 0, "Wrong operator[].");
10.62 map.set(it, s);
10.63 @@ -322,7 +322,7 @@
10.64 ++s;
10.65 }
10.66 s = s * (s - 1) / 2;
10.67 - for (RedIt it(G); it != INVALID; ++it) {
10.68 + for (RedNodeIt it(G); it != INVALID; ++it) {
10.69 s -= map[it];
10.70 }
10.71 check(s == 0, "Wrong sum.");
10.72 @@ -334,17 +334,17 @@
10.73 }
10.74
10.75 template <typename Graph>
10.76 - void checkGraphBlueMap(const Graph& G) {
10.77 + void checkGraphBlueNodeMap(const Graph& G) {
10.78 typedef typename Graph::Node Node;
10.79 - typedef typename Graph::BlueIt BlueIt;
10.80 + typedef typename Graph::BlueNodeIt BlueNodeIt;
10.81
10.82 - typedef typename Graph::template BlueMap<int> IntBlueMap;
10.83 - IntBlueMap map(G, 42);
10.84 - for (BlueIt it(G); it != INVALID; ++it) {
10.85 + typedef typename Graph::template BlueNodeMap<int> IntBlueNodeMap;
10.86 + IntBlueNodeMap map(G, 42);
10.87 + for (BlueNodeIt it(G); it != INVALID; ++it) {
10.88 check(map[it] == 42, "Wrong map constructor.");
10.89 }
10.90 int s = 0;
10.91 - for (BlueIt it(G); it != INVALID; ++it) {
10.92 + for (BlueNodeIt it(G); it != INVALID; ++it) {
10.93 map[it] = 0;
10.94 check(map[it] == 0, "Wrong operator[].");
10.95 map.set(it, s);
10.96 @@ -352,7 +352,7 @@
10.97 ++s;
10.98 }
10.99 s = s * (s - 1) / 2;
10.100 - for (BlueIt it(G); it != INVALID; ++it) {
10.101 + for (BlueNodeIt it(G); it != INVALID; ++it) {
10.102 s -= map[it];
10.103 }
10.104 check(s == 0, "Wrong sum.");