lemon-0.x: comparison src/lemon/concept/graph.h

equal deleted inserted replaced

-:6330f3c92b2d
+:f78244d75571
 /// @{
 /**************** The full-featured graph concepts ****************/
-/// \brief Modular builded static graph class.
+/// \brief Modular static graph class.
 ///
 /// It should be the same as the \c StaticGraph class.
 class _StaticGraph
 :  virtual public BaseGraphComponent,
-	 public IterableGraphComponent, public MappableGraphComponent {
+public IterableGraphComponent, public MappableGraphComponent {
 public:
 typedef BaseGraphComponent::Node Node;
 typedef BaseGraphComponent::Edge Edge;
 template <typename _Graph>
 struct Constraints {
-	void constraints() {
+void constraints() {
-	  checkConcept<IterableGraphComponent, _Graph>();
+checkConcept<IterableGraphComponent, _Graph>();
-	  checkConcept<MappableGraphComponent, _Graph>();
+checkConcept<MappableGraphComponent, _Graph>();
-	}
+}
 };
 };
-/// \brief Modular builded extendable graph class.
+/// \brief Modular extendable graph class.
 ///
 /// It should be the same as the \c ExtendableGraph class.
 class _ExtendableGraph
 :  virtual public BaseGraphComponent, public _StaticGraph,
-	 public ExtendableGraphComponent, public ClearableGraphComponent {
+public ExtendableGraphComponent, public ClearableGraphComponent {
 public:
 typedef BaseGraphComponent::Node Node;
 typedef BaseGraphComponent::Edge Edge;
 template <typename _Graph>
 struct Constraints {
-	void constraints() {
+void constraints() {
-	  checkConcept<_StaticGraph, _Graph >();
+checkConcept<_StaticGraph, _Graph >();
-	  checkConcept<ExtendableGraphComponent, _Graph >();
+checkConcept<ExtendableGraphComponent, _Graph >();
-	  checkConcept<ClearableGraphComponent, _Graph >();
+checkConcept<ClearableGraphComponent, _Graph >();
-	}
+}
 };
 };
-/// \brief Modular builded erasable graph class.
+/// \brief Modular erasable graph class.
 ///
 /// It should be the same as the \c ErasableGraph class.
 class _ErasableGraph
 :  virtual public BaseGraphComponent, public _ExtendableGraph,
-	 public ErasableGraphComponent {
+public ErasableGraphComponent {
 public:
 typedef BaseGraphComponent::Node Node;
 typedef BaseGraphComponent::Edge Edge;
 template <typename _Graph>
 struct Constraints {
-	void constraints() {
+void constraints() {
-	  checkConcept<_ExtendableGraph, _Graph >();
+checkConcept<_ExtendableGraph, _Graph >();
-	  checkConcept<ErasableGraphComponent, _Graph >();
+checkConcept<ErasableGraphComponent, _Graph >();
-	}
+}
 };
 };
 /// An empty static graph class.
 /// thus each kind of node iterator converts to this.
 /// More precisely each kind of node iterator should be inherited
 /// from the trivial node iterator.
 class Node {
 public:
-	/// Default constructor
+/// Default constructor
-	/// @warning The default constructor sets the iterator
+/// @warning The default constructor sets the iterator
-	/// to an undefined value.
+/// to an undefined value.
-	Node() { }
+Node() { }
-	/// Copy constructor.
+/// Copy constructor.
-	/// Copy constructor.
+/// Copy constructor.
-	///
+///
-	Node(const Node&) { }
+Node(const Node&) { }
-	/// Invalid constructor \& conversion.
+/// Invalid constructor \& conversion.
-	/// This constructor initializes the iterator to be invalid.
+/// This constructor initializes the iterator to be invalid.
-	/// \sa Invalid for more details.
+/// \sa Invalid for more details.
-	Node(Invalid) { }
+Node(Invalid) { }
-	/// Equality operator
+/// Equality operator
-	/// Two iterators are equal if and only if they point to the
+/// Two iterators are equal if and only if they point to the
-	/// same object or both are invalid.
+/// same object or both are invalid.
-	bool operator==(Node) const { return true; }
+bool operator==(Node) const { return true; }
-	/// Inequality operator
+/// Inequality operator
-	/// \sa operator==(Node n)
+/// \sa operator==(Node n)
-	///
+///
-	bool operator!=(Node) const { return true; }
+bool operator!=(Node) const { return true; }
 };
 /// 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::NodeIt n(g); n!=INVALID ++n) ++count;
+/// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
 /// \endcode
 class NodeIt : public Node {
 public:
-	/// Default constructor
+/// Default constructor
-	/// @warning The default constructor sets the iterator
+/// @warning The default constructor sets the iterator
-	/// to an undefined value.
+/// to an undefined value.
-	NodeIt() { }
+NodeIt() { }
-	/// Copy constructor.
+/// Copy constructor.
-	/// Copy constructor.
+/// Copy constructor.
-	///
+///
-	NodeIt(const NodeIt& n) : Node(n) { }
+NodeIt(const NodeIt& n) : Node(n) { }
-	/// Invalid constructor \& conversion.
+/// Invalid constructor \& conversion.
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	/// \sa Invalid for more details.
+/// \sa Invalid for more details.
-	NodeIt(Invalid) { }
+NodeIt(Invalid) { }
-	/// Sets the iterator to the first node.
+/// Sets the iterator to the first node.
-	/// Sets the iterator to the first node of \c g.
+/// Sets the iterator to the first node of \c g.
-	///
+///
-	NodeIt(const StaticGraph&) { }
+NodeIt(const StaticGraph&) { }
-	/// Node -> NodeIt conversion.
+/// Node -> NodeIt conversion.
-	/// Sets the iterator to the node of \c g pointed by the trivial
+/// Sets the iterator to the node of \c g pointed by the trivial
-	/// iterator n.
+/// iterator n.
-	/// This feature necessitates that each time we
+/// This feature necessitates that each time we
-	/// iterate the edge-set, the iteration order is the same.
+/// iterate the edge-set, the iteration order is the same.
-	NodeIt(const StaticGraph& g, const Node& n) { }
+NodeIt(const StaticGraph& g, const Node& n) { }
-	/// Next node.
+/// Next node.
-	/// Assign the iterator to the next node.
+/// Assign the iterator to the next node.
-	///
+///
-	NodeIt& operator++() { return *this; }
+NodeIt& operator++() { return *this; }
 };
 /// The base type of the edge iterators.
 /// The base type of the edge iterators.
 ///
 class Edge {
 public:
-	/// Default constructor
+/// Default constructor
-	/// @warning The default constructor sets the iterator
+/// @warning The default constructor sets the iterator
-	/// to an undefined value.
+/// to an undefined value.
-	Edge() { }
+Edge() { }
-	/// Copy constructor.
+/// Copy constructor.
-	/// Copy constructor.
+/// Copy constructor.
-	///
+///
-	Edge(const Edge&) { }
+Edge(const Edge&) { }
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	///
+///
-	Edge(Invalid) { }
+Edge(Invalid) { }
-	/// Equality operator
+/// Equality operator
-	/// Two iterators are equal if and only if they point to the
+/// Two iterators are equal if and only if they point to the
-	/// same object or both are invalid.
+/// same object or both are invalid.
-	bool operator==(Edge) const { return true; }
+bool operator==(Edge) const { return true; }
-	/// Inequality operator
+/// Inequality operator
-	/// \sa operator==(Node n)
+/// \sa operator==(Node n)
-	///
+///
-	bool operator!=(Edge) const { return true; }
+bool operator!=(Edge) const { return true; }
 };
 /// This iterator goes trough the outgoing edges of a node.
 /// This iterator goes trough the \e outgoing edges of a certain node
 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
 /// \endcode
 class OutEdgeIt : public Edge {
 public:
-	/// Default constructor
+/// Default constructor
-	/// @warning The default constructor sets the iterator
+/// @warning The default constructor sets the iterator
-	/// to an undefined value.
+/// to an undefined value.
-	OutEdgeIt() { }
+OutEdgeIt() { }
-	/// Copy constructor.
+/// Copy constructor.
-	/// Copy constructor.
+/// Copy constructor.
-	///
+///
-	OutEdgeIt(const OutEdgeIt& e) : Edge(e) { }
+OutEdgeIt(const OutEdgeIt& e) : Edge(e) { }
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	///
+///
-	OutEdgeIt(Invalid) { }
+OutEdgeIt(Invalid) { }
-	/// This constructor sets the iterator to first outgoing edge.
+/// This constructor sets the iterator to the first outgoing edge.
-	/// This constructor set the iterator to the first outgoing edge of
+/// This constructor sets the iterator to the first outgoing edge of
-	/// node
+/// the node.
-	///@param n the node
+///@param n the node
-	///@param g the graph
+///@param g the graph
-	OutEdgeIt(const StaticGraph&, const Node&) { }
+OutEdgeIt(const StaticGraph&, const Node&) { }
-	/// Edge -> OutEdgeIt conversion
+/// Edge -> OutEdgeIt conversion
-	/// Sets the iterator to the value of the trivial iterator \c e.
+/// Sets the iterator to the value of the trivial iterator \c e.
-	/// This feature necessitates that each time we
+/// This feature necessitates that each time we
-	/// iterate the edge-set, the iteration order is the same.
+/// iterate the edge-set, the iteration order is the same.
-	OutEdgeIt(const StaticGraph& g, const Edge& e) { }
+OutEdgeIt(const StaticGraph& g, const Edge& e) { }
-	///Next outgoing edge
+///Next outgoing edge
-	/// Assign the iterator to the next
+/// Assign the iterator to the next
-	/// outgoing edge of the corresponding node.
+/// outgoing edge of the corresponding node.
-	OutEdgeIt& operator++() { return *this; }
+OutEdgeIt& operator++() { return *this; }
 };
 /// This iterator goes trough the incoming edges of a node.
 /// This iterator goes trough the \e incoming edges of a certain node
 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
 /// \endcode
 class InEdgeIt : public Edge {
 public:
-	/// Default constructor
+/// Default constructor
-	/// @warning The default constructor sets the iterator
+/// @warning The default constructor sets the iterator
-	/// to an undefined value.
+/// to an undefined value.
-	InEdgeIt() { }
+InEdgeIt() { }
-	/// Copy constructor.
+/// Copy constructor.
-	/// Copy constructor.
+/// Copy constructor.
-	///
+///
-	InEdgeIt(const InEdgeIt& e) : Edge(e) { }
+InEdgeIt(const InEdgeIt& e) : Edge(e) { }
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	///
+///
-	InEdgeIt(Invalid) { }
+InEdgeIt(Invalid) { }
-	/// This constructor sets the iterator to first incoming edge.
+/// This constructor sets the iterator to first incoming edge.
-	/// This constructor set the iterator to the first incoming edge of
+/// This constructor set the iterator to the first incoming edge of
-	/// node
+/// the node.
-	///@param n the node
+///@param n the node
-	///@param g the graph
+///@param g the graph
-	InEdgeIt(const StaticGraph&, const Node&) { }
+InEdgeIt(const StaticGraph&, const Node&) { }
-	/// Edge -> InEdgeIt conversion
+/// Edge -> InEdgeIt conversion
-	/// Sets the iterator to the value of the trivial iterator \c e.
+/// Sets the iterator to the value of the trivial iterator \c e.
-	/// This feature necessitates that each time we
+/// This feature necessitates that each time we
-	/// iterate the edge-set, the iteration order is the same.
+/// iterate the edge-set, the iteration order is the same.
-	InEdgeIt(const StaticGraph&, const Edge&) { }
+InEdgeIt(const StaticGraph&, const Edge&) { }
-	/// Next incoming edge
+/// Next incoming edge
-	/// Assign the iterator to the next inedge of the corresponding node.
+/// Assign the iterator to the next inedge of the corresponding node.
-	///
+///
-	InEdgeIt& operator++() { return *this; }
+InEdgeIt& operator++() { return *this; }
 };
 /// This iterator goes through each edge.
 /// This iterator goes through each edge of a graph.
 /// Its usage is quite simple, for example you can count the number
 /// int count=0;
 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
 /// \endcode
 class EdgeIt : public Edge {
 public:
-	/// Default constructor
+/// Default constructor
-	/// @warning The default constructor sets the iterator
+/// @warning The default constructor sets the iterator
-	/// to an undefined value.
+/// to an undefined value.
-	EdgeIt() { }
+EdgeIt() { }
-	/// Copy constructor.
+/// Copy constructor.
-	/// Copy constructor.
+/// Copy constructor.
-	///
+///
-	EdgeIt(const EdgeIt& e) : Edge(e) { }
+EdgeIt(const EdgeIt& e) : Edge(e) { }
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	/// Initialize the iterator to be invalid.
+/// Initialize the iterator to be invalid.
-	///
+///
-	EdgeIt(Invalid) { }
+EdgeIt(Invalid) { }
-	/// This constructor sets the iterator to first edge.
+/// This constructor sets the iterator to the first edge.
-	/// This constructor set the iterator to the first edge of
+/// This constructor sets the iterator to the first edge of \c g.
-	/// node
+///@param g the graph
-	///@param g the graph
+EdgeIt(const StaticGraph&) { }
-	EdgeIt(const StaticGraph&) { }
+/// Edge -> EdgeIt conversion
-	/// Edge -> EdgeIt conversion
+/// Sets the iterator to the value of the trivial iterator \c e.
-	/// Sets the iterator to the value of the trivial iterator \c e.
+/// This feature necessitates that each time we
-	/// This feature necessitates that each time we
+/// iterate the edge-set, the iteration order is the same.
-	/// iterate the edge-set, the iteration order is the same.
+EdgeIt(const StaticGraph&, const Edge&) { }
-	EdgeIt(const StaticGraph&, const Edge&) { }
+///Next edge
-	///Next edge
+/// Assign the iterator to the next edge.
-	/// Assign the iterator to the next
+EdgeIt& operator++() { return *this; }
-	/// edge of the corresponding node.
-	EdgeIt& operator++() { return *this; }
 };
 ///Gives back the target node of an edge.
 ///Gives back the target node of an edge.
 ///
 template<class T>
 class NodeMap : public ReadWriteMap< Node, T >
 {
 public:
-	///\e
+///\e
-	NodeMap(const StaticGraph&) { }
+NodeMap(const StaticGraph&) { }
-	///\e
+///\e
-	NodeMap(const StaticGraph&, T) { }
+NodeMap(const StaticGraph&, T) { }
-	///Copy constructor
+///Copy constructor
-	NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
+NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
-	///Assignment operator
+///Assignment operator
-	NodeMap& operator=(const NodeMap&) { return *this; }
+NodeMap& operator=(const NodeMap&) { return *this; }
-	// \todo fix this concept
+// \todo fix this concept
 };
 /// Read write map of the edges to type \c T.
 /// \ingroup concept
 template<class T>
 class EdgeMap : public ReadWriteMap<Edge,T>
 {
 public:
-	///\e
+///\e
-	EdgeMap(const StaticGraph&) { }
+EdgeMap(const StaticGraph&) { }
-	///\e
+///\e
-	EdgeMap(const StaticGraph&, T) { }
+EdgeMap(const StaticGraph&, T) { }
-	///Copy constructor
+///Copy constructor
-	EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
+EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
-	///Assignment operator
+///Assignment operator
-	EdgeMap& operator=(const EdgeMap&) { return *this; }
+EdgeMap& operator=(const EdgeMap&) { return *this; }
-	// \todo fix this concept
+// \todo fix this concept
 };
 template <typename _Graph>
 struct Constraints : public _StaticGraph::Constraints<_Graph> {};
 };
 /// An empty non-static graph class.
-/// This class provides everything that \ref StaticGraph
+/// This class provides everything that \ref StaticGraph does.
-/// with additional functionality which enables to build a
+/// Additionally it enables building graphs from scratch.
-/// graph from scratch.
 class ExtendableGraph : public StaticGraph
 {
 public:
 /// Defalult constructor.
 };
 /// An empty erasable graph class.
-/// This class is an extension of \ref ExtendableGraph. It also makes it
+/// This class is an extension of \ref ExtendableGraph. It makes it
 /// possible to erase edges or nodes.
 class ErasableGraph : public ExtendableGraph
 {
 public:
 /// Defalult constructor.

changeset 1434	d8475431bbbb
parent 1367	a490662291b9