RhodeCode

    typedef EdgeNotifier ArcNotifier;

    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }

    /// \brief Concept class for \c Node, \c Arc and \c Edge types.

    /// This class describes the concept of \c Node, \c Arc and \c Edge

    /// subtypes of digraph and graph types.

    /// create graph skeleton classes. The reason for this is that \c Node

    /// and \c Arc (or \c Edge) types should \e not derive from the same 

    /// base class. For \c Node you should instantiate it with character

    /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.

      /// Default constructor.

      GraphItem(const GraphItem &) {}

      /// \brief Constructor for conversion from \c INVALID.

      /// Constructor for conversion from \c INVALID.

      /// It initializes the item to be invalid.

      /// \brief Assignment operator.

      /// Assignment operator for the item.

      GraphItem& operator=(const GraphItem&) { return *this; }

      /// Equality operator.

      bool operator==(const GraphItem&) const { return false; }

      /// Inequality operator.

      bool operator!=(const GraphItem&) const { return false; }

      /// \brief Ordering operator.

      /// This operator defines an ordering of the items.

      /// It makes possible to use graph item types as key types in 

      /// associative containers (e.g. \c std::map).

      bool operator<(const GraphItem&) const { return false; }

    /// \brief Base skeleton class for directed graphs.

    /// This class describes the base interface of directed graph types.

    /// All digraph %concepts have to conform to this class.

    /// It just provides types for nodes and arcs and functions 

    /// to get the source and the target nodes of arcs.

      /// This class represents the nodes of the digraph.

      /// This class represents the arcs of the digraph.

      typedef GraphItem<'a'> Arc;

      /// \brief Return the source node of an arc.

      /// This function returns the source node of an arc.

      Node source(const Arc&) const { return INVALID; }

      /// \brief Return the target node of an arc.

      /// This function returns the target node of an arc.

      Node target(const Arc&) const { return INVALID; }

      /// \brief Return the opposite node on the given arc.

      /// This function returns the opposite node on the given arc.

    /// \brief Base skeleton class for undirected graphs.

    /// This class describes the base interface of undirected graph types.

    /// All graph %concepts have to conform to this class.

    /// It extends the interface of \ref BaseDigraphComponent with an

    /// \c Edge type and functions to get the end nodes of edges,

    /// to convert from arcs to edges and to get both direction of edges.

      /// \brief Undirected edge class of the graph.

      /// This class represents the undirected edges of the graph.

      /// Undirected graphs can be used as directed graphs, each edge is

      /// represented by two opposite directed arcs.

      class Edge : public GraphItem<'e'> {

        typedef GraphItem<'e'> Parent;

        /// Default constructor.

        Edge(const Edge &) : Parent() {}

        /// \brief Constructor for conversion from \c INVALID.

        /// Constructor for conversion from \c INVALID.

        /// It initializes the item to be invalid.

        /// \brief Constructor for conversion from an arc.

        /// Constructor for conversion from an arc.

        /// \brief Assign an arc to an edge.

        /// This function assigns an arc to an edge.

      /// \brief Return one end node of an edge.

      ///

      /// This function returns one end node of an edge.

      Node u(const Edge&) const { return INVALID; }

      /// \brief Return the other end node of an edge.

      ///

      /// This function returns the other end node of an edge.

      Node v(const Edge&) const { return INVALID; }

      /// \brief Return a directed arc related to an edge.

      ///

      /// This function returns a directed arc from its direction and the

      /// represented edge.

      Arc direct(const Edge&, bool) const { return INVALID; }

      /// \brief Return a directed arc related to an edge.

      ///

      /// This function returns a directed arc from its source node and the

      /// represented edge.

      Arc direct(const Edge&, const Node&) const { return INVALID; }

      /// \brief Return the direction of the arc.

      /// \brief Return the opposite arc.

      /// This function returns the opposite arc, i.e. the arc representing

      /// the same edge and has opposite direction.

      Arc oppositeArc(const Arc&) const { return INVALID; }

          checkConcept<GraphItem<'e'>, Edge>();

            e = graph.direct(ue, false);

    /// \brief Skeleton class for \e idable directed graphs.

    /// This class describes the interface of \e idable directed graphs.

    /// It extends \ref BaseDigraphComponent with the core ID functions.

    /// The ids of the items must be unique and immutable.

    /// This concept is part of the Digraph concept.

      /// \brief Return a unique integer id for the given node.

      /// This function returns a unique integer id for the given node.

      int id(const Node&) const { return -1; }

      /// \brief Return the node by its unique id.

      /// This function returns the node by its unique id.

      /// If the digraph does not contain a node with the given id,

      /// then the result of the function is undefined.

      Node nodeFromId(int) const { return INVALID; }

      /// \brief Return a unique integer id for the given arc.

      /// This function returns a unique integer id for the given arc.

      int id(const Arc&) const { return -1; }

      /// \brief Return the arc by its unique id.

      /// This function returns the arc by its unique id.

      /// If the digraph does not contain an arc with the given id,

      /// then the result of the function is undefined.

      Arc arcFromId(int) const { return INVALID; }

      /// \brief Return an integer greater or equal to the maximum

      /// node id.

      /// This function returns an integer greater or equal to the

      /// maximum node id.

      int maxNodeId() const { return -1; }

      /// \brief Return an integer greater or equal to the maximum

      /// arc id.

      /// This function returns an integer greater or equal to the

      /// maximum arc id.

      int maxArcId() const { return -1; }

    /// \brief Skeleton class for \e idable undirected graphs.

    /// This class describes the interface of \e idable undirected

    /// graphs. It extends \ref IDableDigraphComponent with the core ID

    /// functions of undirected graphs.

    /// The ids of the items must be unique and immutable.

    /// This concept is part of the Graph concept.

      /// \brief Return a unique integer id for the given edge.

      /// This function returns a unique integer id for the given edge.

      int id(const Edge&) const { return -1; }

      /// \brief Return the edge by its unique id.

      /// This function returns the edge by its unique id.

      /// If the graph does not contain an edge with the given id,

      /// then the result of the function is undefined.

      Edge edgeFromId(int) const { return INVALID; }

      /// \brief Return an integer greater or equal to the maximum

      /// edge id.

      /// This function returns an integer greater or equal to the

      /// maximum edge id.

      int maxEdgeId() const { return -1; }

    /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.

    /// This class describes the concept of \c NodeIt, \c ArcIt and 

    /// \c EdgeIt subtypes of digraph and graph types.

      /// Default constructor.

      /// \warning The default constructor is not required to set

      /// the iterator to some well-defined value. So you should consider it

      /// as uninitialized.

      GraphItemIt(const GraphItemIt& it) : Item(it) {}

      /// \brief Constructor that sets the iterator to the first item.

      /// Constructor that sets the iterator to the first item.

      explicit GraphItemIt(const GR&) {}

      /// \brief Constructor for conversion from \c INVALID.

      /// Constructor for conversion from \c INVALID.

      /// It initializes the iterator to be invalid.

      /// \brief Assignment operator.

      /// Assignment operator for the iterator.

      GraphItemIt& operator=(const GraphItemIt&) { return *this; }

      /// \brief Increment the iterator.

      /// This operator increments the iterator, i.e. assigns it to the

      /// next item.

      /// Equality operator.

      /// Inequality operator.

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

      /// same object or both are invalid.

          checkConcept<GraphItem<>, _GraphItemIt>();

          _GraphItemIt it3 = it1;

          _GraphItemIt it4 = INVALID;

        const GR& g;

    /// \brief Concept class for \c InArcIt, \c OutArcIt and 

    /// \c IncEdgeIt types.

    /// This class describes the concept of \c InArcIt, \c OutArcIt 

    /// and \c IncEdgeIt subtypes of digraph and graph types.

    ///

    /// \note Since these iterator classes do not inherit from the same

    /// base class, there is an additional template parameter (selector)

    /// \c sel. For \c InArcIt you should instantiate it with character 

    /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.

      /// Default constructor.

      /// \warning The default constructor is not required to set

      /// the iterator to some well-defined value. So you should consider it

      /// as uninitialized.

      GraphIncIt(const GraphIncIt& it) : Item(it) {}

      /// \brief Constructor that sets the iterator to the first 

      /// incoming or outgoing arc.

      /// Constructor that sets the iterator to the first arc 

      /// incoming to or outgoing from the given node.

      explicit GraphIncIt(const GR&, const Base&) {}

      /// \brief Constructor for conversion from \c INVALID.

      /// Constructor for conversion from \c INVALID.

      /// It initializes the iterator to be invalid.

      /// \brief Assignment operator.

      /// Assignment operator for the iterator.

      GraphIncIt& operator=(const GraphIncIt&) { return *this; }

      /// \brief Increment the iterator.

      /// This operator increments the iterator, i.e. assigns it to the

      /// next arc incoming to or outgoing from the given node.

      /// Equality operator.

      /// Inequality operator.

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

      /// same object or both are invalid.

          _GraphIncIt it3 = it1;

          _GraphIncIt it4 = INVALID;

        const Base& node;

        const GR& graph;

    /// \brief Skeleton class for iterable directed graphs.

    /// This class describes the interface of iterable directed

    /// graphs. It extends \ref BaseDigraphComponent with the core

    /// iterable interface.

      /// This interface provides functions for iteration on digraph items.

      /// \brief Return the first node.

      /// This function gives back the first node in the iteration order.

      /// \brief Return the next node.

      /// This function gives back the next node in the iteration order.

      /// \brief Return the first arc.

      /// This function gives back the first arc in the iteration order.

      /// \brief Return the next arc.

      /// This function gives back the next arc in the iteration order.

      /// \brief Return the first arc incomming to the given node.

      /// This function gives back the first arc incomming to the

      /// given node.

      /// \brief Return the next arc incomming to the given node.

      /// This function gives back the next arc incomming to the

      /// given node.

      /// \brief Return the first arc outgoing form the given node.

      ///

      /// This function gives back the first arc outgoing form the

      /// \brief Return the next arc outgoing form the given node.

      /// This function gives back the next arc outgoing form the

      /// given node.

      /// This interface provides iterator classes for digraph items.

      /// \brief This iterator goes through each arc.

      /// This iterator goes through each arc.

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

      /// This function gives back the base node of the iterator.

      /// It is always the target node of the pointed arc.

      /// This function gives back the running node of the iterator.

      /// It is always the source node of the pointed arc.

      /// This function gives back the base node of the iterator.

      /// It is always the source node of the pointed arc.

      /// This function gives back the running node of the iterator.

      /// It is always the target node of the pointed arc.

            const typename _Digraph::InArcIt iait(INVALID);

            const typename _Digraph::OutArcIt oait(INVALID);

            n = digraph.baseNode(iait);

            n = digraph.runningNode(iait);

            n = digraph.baseNode(oait);

            n = digraph.runningNode(oait);

    /// \brief Skeleton class for iterable undirected graphs.

    /// This class describes the interface of iterable undirected

    /// graphs. It extends \ref IterableDigraphComponent with the core

    /// iterable interface of undirected graphs.

      /// This interface provides functions for iteration on edges.

      ///

      /// \brief Return the first edge.

      /// This function gives back the first edge in the iteration order.

      /// \brief Return the next edge.

      /// This function gives back the next edge in the iteration order.

      /// \brief Return the first edge incident to the given node.

      ///

      /// This function gives back the first edge incident to the given 

      /// node. The bool parameter gives back the direction for which the

      /// source node of the directed arc representing the edge is the 

      /// This function gives back the next edge incident to the given 

      /// node. The bool parameter should be used as \c firstInc() use it.

      /// This interface provides iterator classes for edges.

      /// \brief This iterator goes through each edge.

      /// This iterator goes through each edge.

      /// \brief This iterator goes trough the incident edges of a

      /// This iterator goes trough the incident edges of a certain

      typedef GraphIncIt<Graph, Edge, Node, 'e'> IncEdgeIt;

      /// This function gives back the base node of the iterator.

      /// This function gives back the running node of the iterator.

              typename _Graph::Node, 'e'>, typename _Graph::IncEdgeIt>();

            const typename _Graph::IncEdgeIt ieit(INVALID);

            n = graph.baseNode(ieit);

            n = graph.runningNode(ieit);

    /// \brief Skeleton class for alterable directed graphs.

    /// This class describes the interface of alterable directed

    /// graphs. It extends \ref BaseDigraphComponent with the alteration

    /// notifier interface. It implements

    /// alteration occured in the digraph all the observers will be

      /// Node alteration notifier class.

      /// Arc alteration notifier class.

      /// \brief Return the node alteration notifier.

      /// This function gives back the node alteration notifier.

         return NodeNotifier();

      /// \brief Return the arc alteration notifier.

      /// This function gives back the arc alteration notifier.

    /// \brief Skeleton class for alterable undirected graphs.

    /// This class describes the interface of alterable undirected

    /// graphs. It extends \ref AlterableDigraphComponent with the alteration

    /// notifier interface of undirected graphs. It implements

    /// an observer-notifier pattern for the edges. More

    /// alteration occured in the graph all the observers will be

      /// Edge alteration notifier class.

      /// \brief Return the edge alteration notifier.

      /// This function gives back the edge alteration notifier.

          checkConcept<AlterableDigraphComponent<Base>, _Graph>();

    /// \brief Concept class for standard graph maps.

    /// This class describes the concept of standard graph maps, i.e.

    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 

    /// graph types, which can be used for associating data to graph items.

      /// Construct a new map for the graph and initalize the values.

      /// \brief Assignment operator.

      /// Assignment operator. It does not mofify the underlying graph,

          _Map m1(g);

          _Map m2(g,t);

          // Copy constructor

          // _Map m3(m);

          // Assignment operator

          // m3 = cmap;

          ignore_unused_variable_warning(m1);

          ignore_unused_variable_warning(m2);

          // ignore_unused_variable_warning(m3);

        const _Map &m;

    /// \brief Skeleton class for mappable directed graphs.

    /// This class describes the interface of mappable directed graphs.

    /// It extends \ref BaseDigraphComponent with the standard digraph 

    /// map classes, namely \c NodeMap and \c ArcMap.

      /// \brief Standard graph map for the nodes.

      /// Standard graph map for the nodes.