RhodeCode

      ///

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