lemon-main: comparison lemon/concepts/digraph.h

equal deleted inserted replaced

-:4ba0ee04fedb
+:14a5089e7225
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 ///
 /// \sa concept
 class Digraph {
 private:
 ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 ///
 Digraph(const Digraph &) {};
 ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
 ///\e not allowed. Use DigraphCopy() instead.
 ///Assignment of \ref Digraph "Digraph"s to another ones are
 ///\e not allowed.  Use DigraphCopy() instead.
 void operator=(const Digraph &) {}
 public:
 /// Two iterators are equal if and only if they point to the
 /// same object or both are invalid.
 bool operator==(Node) const { return true; }
 /// Inequality operator
 /// \sa operator==(Node n)
 ///
 bool operator!=(Node) const { return true; }
-	/// Artificial ordering operator.
+/// Artificial ordering operator.
-	/// To allow the use of digraph descriptors as key type in std::map or
+/// To allow the use of digraph descriptors as key type in std::map or
-	/// similar associative container we require this.
+/// similar associative container we require this.
-	///
+///
-	/// \note This operator only have to define some strict ordering of
+/// \note This operator only have to define some strict ordering of
-	/// the items; this order has nothing to do with the iteration
+/// the items; this order has nothing to do with the iteration
-	/// ordering of the items.
+/// ordering of the items.
-	bool operator<(Node) const { return false; }
+bool operator<(Node) 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 digraph \c g of type \c Digraph like this:
 /// @warning The default constructor sets the iterator
 /// to an undefined value.
 NodeIt() { }
 /// Copy constructor.
 /// Copy constructor.
 ///
 NodeIt(const NodeIt& n) : Node(n) { }
 /// Invalid constructor \& conversion.
 /// Sets the iterator to the first node of \c g.
 ///
 NodeIt(const Digraph&) { }
 /// Node -> NodeIt conversion.
 /// Sets the iterator to the node of \c the digraph pointed by
-	/// the trivial iterator.
+/// the trivial iterator.
 /// This feature necessitates that each time we
 /// iterate the arc-set, the iteration order is the same.
 NodeIt(const Digraph&, const Node&) { }
 /// Next node.
 /// Assign the iterator to the next node.
 ///
 NodeIt& operator++() { return *this; }
 };
 /// Class for identifying an arc of the digraph
 /// This class identifies an arc of the digraph. It also serves
 /// as a base class of the arc iterators,
 /// thus they will convert to this type.
 /// \sa operator==(Arc n)
 ///
 bool operator!=(Arc) const { return true; }
-	/// Artificial ordering operator.
+/// Artificial ordering operator.
-	/// To allow the use of digraph descriptors as key type in std::map or
+/// To allow the use of digraph descriptors as key type in std::map or
-	/// similar associative container we require this.
+/// similar associative container we require this.
-	///
+///
-	/// \note This operator only have to define some strict ordering of
+/// \note This operator only have to define some strict ordering of
-	/// the items; this order has nothing to do with the iteration
+/// the items; this order has nothing to do with the iteration
-	/// ordering of the items.
+/// ordering of the items.
-	bool operator<(Arc) const { return false; }
+bool operator<(Arc) const { return false; }
 };
 /// This iterator goes trough the outgoing arcs of a node.
 /// This iterator goes trough the \e outgoing arcs of a certain node
 /// of a digraph.
 /// Its usage is quite simple, for example you can count the number
 /// in digraph \c g of type \c Digraph as follows.
 ///\code
 /// int count=0;
 /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
 ///\endcode
 class OutArcIt : public Arc {
 public:
 /// Default constructor
 /// @warning The default constructor sets the iterator
 /// Initialize the iterator to be invalid.
 ///
 OutArcIt(Invalid) { }
 /// This constructor sets the iterator to the first outgoing arc.
 /// This constructor sets the iterator to the first outgoing arc of
 /// the node.
 OutArcIt(const Digraph&, const Node&) { }
 /// Arc -> OutArcIt conversion
 /// Sets the iterator to the value of the trivial iterator.
-	/// This feature necessitates that each time we
+/// This feature necessitates that each time we
 /// iterate the arc-set, the iteration order is the same.
 OutArcIt(const Digraph&, const Arc&) { }
 ///Next outgoing arc
 /// Assign the iterator to the next
 /// outgoing arc of the corresponding node.
 OutArcIt& operator++() { return *this; }
 };
 /// This iterator goes trough the incoming arcs of a node.
 /// Initialize the iterator to be invalid.
 ///
 InArcIt(Invalid) { }
 /// This constructor sets the iterator to first incoming arc.
 /// This constructor set the iterator to the first incoming arc of
 /// the node.
 InArcIt(const Digraph&, const Node&) { }
 /// Arc -> InArcIt conversion
 /// Sets the iterator to the value of the trivial iterator \c e.
 /// This feature necessitates that each time we
 /// iterate the arc-set, the iteration order is the same.
 InArcIt(const Digraph&, const Arc&) { }
 /// Next incoming arc
 /// Assign the iterator to the next inarc of the corresponding node.
 /// Initialize the iterator to be invalid.
 ///
 ArcIt(Invalid) { }
 /// This constructor sets the iterator to the first arc.
 /// This constructor sets the iterator to the first arc of \c g.
 ///@param g the digraph
 ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
 /// Arc -> ArcIt conversion
 /// Sets the iterator to the value of the trivial iterator \c e.
 /// This feature necessitates that each time we
 /// iterate the arc-set, the iteration order is the same.
 ArcIt(const Digraph&, const Arc&) { }
 ///Next arc
 /// Assign the iterator to the next arc.
 ArcIt& operator++() { return *this; }
 };
 ///Gives back the target node of an arc.
 ///Gives back the source node of an arc.
 ///
 Node source(Arc) const { return INVALID; }
 /// \brief Returns the ID of the node.
 int id(Node) const { return -1; }
 /// \brief Returns the ID of the arc.
 int id(Arc) const { return -1; }
 /// \brief Returns the node with the given ID.
 ///
 /// \pre The argument should be a valid node ID in the graph.
 Node nodeFromId(int) const { return INVALID; }
 /// \brief Returns the arc with the given ID.
 ///
 /// \pre The argument should be a valid arc ID in the graph.
 Arc arcFromId(int) const { return INVALID; }
 /// \brief Returns an upper bound on the node IDs.
 int maxNodeId() const { return -1; }
 /// \brief Returns an upper bound on the arc IDs.
 int maxArcId() const { return -1; }
 void first(Node&) const {}
 void next(Node&) const {}
 void first(Arc&) const {}
 Node fromId(int, Node) const { return INVALID; }
 // The second parameter is dummy.
 Arc fromId(int, Arc) const { return INVALID; }
 // Dummy parameter.
 int maxId(Node) const { return -1; }
 // Dummy parameter.
 int maxId(Arc) const { return -1; }
 /// \brief The base node of the iterator.
 ///
 /// Gives back the base node of the iterator.
 /// It is always the target of the pointed arc.
 ///
 /// Gives back the opposite node on the given arc.
 Node oppositeNode(const Node&, const Arc&) const { return INVALID; }
 /// \brief Read write map of the nodes to type \c T.
 ///
 /// ReadWrite map of the nodes to type \c T.
 /// \sa Reference
 template<class T>
 class NodeMap : public ReadWriteMap< Node, T > {
 public:
 ///\e
 NodeMap(const Digraph&) { }
 ///Copy constructor
 NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
 ///Assignment operator
 template <typename CMap>
 NodeMap& operator=(const CMap&) {
 checkConcept<ReadMap<Node, T>, CMap>();
 return *this;
 }
 };
 /// \brief Read write map of the arcs to type \c T.
 ///
 /// Reference map of the arcs to type \c T.
 /// \sa Reference
 template<class T>
 class ArcMap : public ReadWriteMap<Arc,T> {
 public:
 ///\e
 ArcMap(const Digraph&) { }
 ArcMap(const Digraph&, T) { }
 ///Copy constructor
 ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
 ///Assignment operator
 template <typename CMap>
 ArcMap& operator=(const CMap&) {
 checkConcept<ReadMap<Arc, T>, CMap>();
 return *this;
 }
 };
 template <typename _Digraph>
 struct Constraints {
 void constraints() {
 checkConcept<IterableDigraphComponent<>, _Digraph>();
-	  checkConcept<IDableDigraphComponent<>, _Digraph>();
+checkConcept<IDableDigraphComponent<>, _Digraph>();
 checkConcept<MappableDigraphComponent<>, _Digraph>();
 }
 };
 };
 } //namespace concepts
 } //namespace lemon
 #endif // LEMON_CONCEPT_DIGRAPH_H

changeset 217	b67149f0e675
parent 125	19e82bda606a
child 220	a5d8c039f218