RhodeCode

        /// the items; this order has nothing to do with the iteration

        /// ordering of the items.

        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 graph \c g of type \c Graph like this:

      ///\code

      /// int count=0;

      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;

      ///\endcode

      class NodeIt : public Node {

      public:

        /// Default constructor

        /// @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.

        /// Initialize the iterator to be invalid.

        /// \sa Invalid for more details.

        NodeIt(Invalid) { }

        /// Sets the iterator to the first node.

        /// Sets the iterator to the first node of \c g.

        ///

        NodeIt(const Graph&) { }

        /// Node -> NodeIt conversion.

        /// Sets the iterator to the node of \c the graph pointed by

        /// the trivial iterator.

        /// This feature necessitates that each time we

        /// iterate the arc-set, the iteration order is the same.

        NodeIt(const Graph&, const Node&) { }

        /// Next node.

        /// Assign the iterator to the next node.

        ///

        NodeIt& operator++() { return *this; }

      };

      /// The base type of the edge iterators.

      /// The base type of the edge iterators.

      ///

      class Edge {

      public:

        /// Default constructor

        /// @warning The default constructor sets the iterator

        /// to an undefined value.

        Edge() { }

        /// Copy constructor.

        /// Copy constructor.

        ///

        Edge(const Edge&) { }

        /// Initialize the iterator to be invalid.

        /// Initialize the iterator to be invalid.

        ///

        Edge(Invalid) { }

        /// Equality operator

        /// Two iterators are equal if and only if they point to the

        /// same object or both are invalid.

        bool operator==(Edge) const { return true; }

        /// Inequality operator

        /// \sa operator==(Edge n)

        ///

        bool operator!=(Edge) 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<(Edge) const { return false; }

      };

      /// 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

      /// of edges in a graph \c g of type \c Graph as follows:

      ///\code

      /// int count=0;

      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;

      ///\endcode

      class EdgeIt : public Edge {

      public:

        /// Default constructor

        /// @warning The default constructor sets the iterator

        /// to an undefined value.

        EdgeIt() { }

        /// Copy constructor.

        /// Copy constructor.

        ///

        EdgeIt(const EdgeIt& e) : Edge(e) { }

        /// Initialize the iterator to be invalid.

        /// Initialize the iterator to be invalid.

        ///

        EdgeIt(Invalid) { }

        /// This constructor sets the iterator to the first edge.

        /// This constructor sets the iterator to the first edge.

        EdgeIt(const Graph&) { }

        /// Edge -> EdgeIt conversion

        /// Sets the iterator to the value of the trivial iterator.

        /// This feature necessitates that each time we

        /// iterate the edge-set, the iteration order is the

        /// same.

        EdgeIt(const Graph&, const Edge&) { }

        /// Next edge

        /// Assign the iterator to the next edge.

        EdgeIt& operator++() { return *this; }

      };

      /// \brief This iterator goes trough the incident undirected

      /// arcs of a node.

      ///

      /// This iterator goes trough the incident edges

      /// of a certain node of a graph. You should assume that the

      /// loop arcs will be iterated twice.

      ///

      /// Its usage is quite simple, for example you can compute the

      /// degree (i.e. count the number of incident arcs of a node \c n

      /// in graph \c g of type \c Graph as follows.

      ///

      ///\code

      /// int count=0;

      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;

      ///\endcode

      class IncEdgeIt : public Edge {

      public:

        /// Default constructor

        /// @warning The default constructor sets the iterator

        /// to an undefined value.

        IncEdgeIt() { }

        /// Copy constructor.

        /// Copy constructor.

        ///

        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }

        /// Initialize the iterator to be invalid.

        /// Initialize the iterator to be invalid.

        ///

        IncEdgeIt(Invalid) { }

        /// This constructor sets the iterator to first incident arc.

        /// This constructor set the iterator to the first incident arc of

        /// the node.

        IncEdgeIt(const Graph&, const Node&) { }

        /// Edge -> IncEdgeIt 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.

        IncEdgeIt(const Graph&, const Edge&) { }

        /// Next incident arc

        /// Assign the iterator to the next incident arc

        /// of the corresponding node.

        IncEdgeIt& operator++() { return *this; }

      };

      /// The directed arc type.

      /// The directed arc type. It can be converted to the

      /// edge or it should be inherited from the undirected

      public:

        /// Default constructor

        /// @warning The default constructor sets the iterator

        /// to an undefined value.

        Arc() { }

        /// Copy constructor.

        /// Copy constructor.

        ///

        /// Initialize the iterator to be invalid.

        /// Initialize the iterator to be invalid.

        ///

        Arc(Invalid) { }

        /// Equality operator

        /// Two iterators are equal if and only if they point to the

        /// same object or both are invalid.

        bool operator==(Arc) const { return true; }

        /// Inequality operator

        /// \sa operator==(Arc n)

        ///

        bool operator!=(Arc) 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<(Arc) const { return false; }

      };

      /// This iterator goes through each directed arc.

      /// This iterator goes through each arc of a graph.

      /// Its usage is quite simple, for example you can count the number

      /// of arcs in a graph \c g of type \c Graph as follows:

      ///\code

      /// int count=0;

      /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;

      ///\endcode

      class ArcIt : public Arc {

      public:

        /// Default constructor

        /// @warning The default constructor sets the iterator

        /// to an undefined value.

        ArcIt() { }

        /// Copy constructor.

        /// Copy constructor.

        ///

        ArcIt(const ArcIt& e) : Arc(e) { }

        /// Initialize the iterator to be invalid.

        /// 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 graph

        ArcIt(const Graph &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 Graph&, const Arc&) { }

        ///Next arc

        /// Assign the iterator to the next arc.

        ArcIt& operator++() { return *this; }

      };

      /// This iterator goes trough the outgoing directed arcs of a node.

      /// This iterator goes trough the \e outgoing arcs of a certain node

      /// of a graph.

      /// Its usage is quite simple, for example you can count the number

      /// of outgoing arcs of a node \c n

      /// in graph \c g of type \c Graph as follows.

      ///\code

      /// int count=0;

      /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;

      ///\endcode

      class OutArcIt : public Arc {

      public:

        /// Default constructor

        /// @warning The default constructor sets the iterator

        /// to an undefined value.

        OutArcIt() { }

        /// Copy constructor.

        /// Copy constructor.

        ///

        OutArcIt(const OutArcIt& e) : Arc(e) { }

        /// Initialize the iterator to be invalid.

        /// 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.

        ///@param n the node

        ///@param g the graph

        OutArcIt(const Graph& n, const Node& g) {

          ignore_unused_variable_warning(n);

          ignore_unused_variable_warning(g);

        }

        /// Arc -> OutArcIt conversion

        /// Sets the iterator to the value of the trivial iterator.

        /// This feature necessitates that each time we

        /// iterate the arc-set, the iteration order is the same.

        OutArcIt(const Graph&, 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 directed arcs of a node.

      /// This iterator goes trough the \e incoming arcs of a certain node

      /// of a graph.

      /// Its usage is quite simple, for example you can count the number

      /// of outgoing arcs of a node \c n

      /// in graph \c g of type \c Graph as follows.

      ///\code

      /// int count=0;

      /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;

      ///\endcode

      class InArcIt : public Arc {

      public:

        /// Default constructor

        /// @warning The default constructor sets the iterator

        /// to an undefined value.

        InArcIt() { }

        /// Copy constructor.

        /// Copy constructor.

        ///

        InArcIt(const InArcIt& e) : Arc(e) { }

        /// Initialize the iterator to be invalid.

        /// 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.

        ///@param n the node

        ///@param g the graph

        InArcIt(const Graph& g, const Node& n) {

          ignore_unused_variable_warning(n);

          ignore_unused_variable_warning(g);

        }

        /// 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 Graph&, const Arc&) { }

        /// Next incoming arc

        /// Assign the iterator to the next inarc of the corresponding node.

        ///

        InArcIt& operator++() { return *this; }

      };

      /// \brief Reference map of the nodes to type \c T.

      ///

      /// Reference map of the nodes to type \c T.

      template<class T>

      class NodeMap : public ReferenceMap<Node, T, T&, const T&>

      {

      public:

        ///\e

        NodeMap(const Graph&) { }

        ///\e

        NodeMap(const Graph&, T) { }

      private:

        ///Copy constructor

        NodeMap(const NodeMap& nm) :

          ReferenceMap<Node, T, T&, const T&>(nm) { }

        ///Assignment operator

        template <typename CMap>

        NodeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Node, T>, CMap>();

          return *this;

        }

      };

      /// \brief Reference map of the arcs to type \c T.

      ///

      /// Reference map of the arcs to type \c T.

      template<class T>

      class ArcMap : public ReferenceMap<Arc, T, T&, const T&>

      {

      public:

        ///\e

        ArcMap(const Graph&) { }

        ///\e

        ArcMap(const Graph&, T) { }

      private:

        ///Copy constructor

        ArcMap(const ArcMap& em) :

          ReferenceMap<Arc, T, T&, const T&>(em) { }

        ///Assignment operator

        template <typename CMap>

        ArcMap& operator=(const CMap&) {