lemon-0.x: comparison lemon/concept/bpugraph.h

equal deleted inserted replaced

-:62718195a916
+:a2bf8b5c61f7
 ///
 /// You can assume that all undirected bipartite graph can be handled
 /// as an undirected graph and consequently as a static graph.
 ///
 /// The bipartite graph stores two types of nodes which are named
-/// ANode and BNode. Even so the graph type does not contain ANode
+/// ANode and BNode. The graph type contains two types ANode and BNode
-/// and BNode classes, becaue the nodes can be accessed just with the
+/// which are inherited from Node type. Moreover they have
-/// common Node class.
+/// constructor which converts Node to either ANode or BNode when it is
+/// possible. Therefor everywhere the Node type can be used instead of
+/// ANode and BNode. So the usage of the ANode and BNode is suggested.
 ///
 /// The iteration on the partition can be done with the ANodeIt and
 /// BNodeIt classes. The node map can be used to map values to the nodes
 /// and similarly we can use to map values for just the ANodes and
 /// BNodes the ANodeMap and BNodeMap template classes.
 	///
 	/// \bug This is a technical requirement. Do we really need this?
 	bool operator<(Node) const { return false; }
 };
+/// \brief The base type of anode iterators,
+/// or in other words, the trivial anode iterator.
+///
+/// This is the base type of each anode iterator,
+/// thus each kind of anode iterator converts to this.
+/// More precisely each kind of node iterator should be inherited
+/// from the trivial anode iterator. The ANode class should be used
+/// only in special cases. Usually the Node type should be used insted
+/// of it.
+class ANode {
+public:
+/// Default constructor
+/// @warning The default constructor sets the iterator
+/// to an undefined value.
+ANode() { }
+/// Copy constructor.
+/// Copy constructor.
+///
+ANode(const ANode&) { }
+/// Construct the same node as ANode.
+/// Construct the same node as ANode. It may throws assertion
+/// when the given node is from the BNode set.
+ANode(const Node&) { }
+/// Invalid constructor \& conversion.
+/// This constructor initializes the iterator to be invalid.
+/// \sa Invalid for more details.
+ANode(Invalid) { }
+/// Equality operator
+/// Two iterators are equal if and only if they point to the
+/// same object or both are invalid.
+bool operator==(ANode) const { return true; }
+/// Inequality operator
+/// \sa operator==(ANode n)
+///
+bool operator!=(ANode) const { return true; }
+	/// Artificial ordering operator.
+	/// To allow the use of graph descriptors as key type in std::map or
+	/// similar associative container we require this.
+	///
+	/// \note This operator only have to define some strict ordering of
+	/// the items; this order has nothing to do with the iteration
+	/// ordering of the items.
+	bool operator<(ANode) const { return false; }
+};
+/// \brief The base type of bnode iterators,
+/// or in other words, the trivial bnode iterator.
+///
+/// This is the base type of each anode iterator,
+/// thus each kind of anode iterator converts to this.
+/// More precisely each kind of node iterator should be inherited
+/// from the trivial anode iterator. The BNode class should be used
+/// only in special cases. Usually the Node type should be used insted
+/// of it.
+class BNode {
+public:
+/// Default constructor
+/// @warning The default constructor sets the iterator
+/// to an undefined value.
+BNode() { }
+/// Copy constructor.
+/// Copy constructor.
+///
+BNode(const BNode&) { }
+/// Construct the same node as BNode.
+/// Construct the same node as BNode. It may throws assertion
+/// when the given node is from the ANode set.
+BNode(const Node&) { }
+/// Invalid constructor \& conversion.
+/// This constructor initializes the iterator to be invalid.
+/// \sa Invalid for more details.
+BNode(Invalid) { }
+/// Equality operator
+/// Two iterators are equal if and only if they point to the
+/// same object or both are invalid.
+bool operator==(BNode) const { return true; }
+/// Inequality operator
+/// \sa operator==(BNode n)
+///
+bool operator!=(BNode) const { return true; }
+	/// Artificial ordering operator.
+	/// To allow the use of graph descriptors as key type in std::map or
+	/// similar associative container we require this.
+	///
+	/// \note This operator only have to define some strict ordering of
+	/// the items; this order has nothing to do with the iteration
+	/// ordering of the items.
+	bool operator<(BNode) const { return false; }
+};
 /// This iterator goes through each node.
 /// This iterator goes through each node.
 /// Its usage is quite simple, for example you can count the number
 /// of nodes in graph \c g of type \c Graph like this:
 /// \code
 /// int count=0;
 /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count;
 /// \endcode
-class ANodeIt : public Node {
+class ANodeIt : public ANode {
 public:
 /// Default constructor
 /// @warning The default constructor sets the iterator
 /// to an undefined value.
 /// of nodes in graph \c g of type \c Graph like this:
 /// \code
 /// int count=0;
 /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count;
 /// \endcode
-class BNodeIt : public Node {
+class BNodeIt : public BNode {
 public:
 /// Default constructor
 /// @warning The default constructor sets the iterator
 /// to an undefined value.

changeset 1941	9fe177e0437d
parent 1911	c925a077cf73
child 1946	17eb3eaad9f8