/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

///\ingroup graph_concepts

///\file

///\brief The concept of graph components.

#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H

#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H

#include <lemon/core.h>

#include <lemon/concepts/maps.h>

#include <lemon/bits/alteration_notifier.h>

namespace lemon {

  namespace concepts {

    /// \brief Skeleton class for graph Node and Arc types

    ///

    /// This class describes the interface of Node and Arc (and Edge

    /// in undirected graphs) subtypes of graph types.

    ///

    /// \note This class is a template class so that we can use it to

    /// create graph skeleton classes. The reason for this is than Node

    /// and Arc types should \em not derive from the same base class.

    /// For Node you should instantiate it with character 'n' and for Arc

    /// with 'a'.

#ifndef DOXYGEN

    template <char sel = '0'>

#endif

    class GraphItem {

    public:

      /// \brief Default constructor.

      ///

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

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

      /// as uninitialized.

      GraphItem() {}

      /// \brief Copy constructor.

      ///

      /// Copy constructor.

      ///

      GraphItem(const GraphItem &) {}

      /// \brief Invalid constructor \& conversion.

      ///

      /// This constructor initializes the item to be invalid.

      /// \sa Invalid for more details.

      GraphItem(Invalid) {}

      /// \brief Assign operator for nodes.

      ///

      /// The nodes are assignable.

      ///

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

      /// \brief Equality operator.

      ///

      /// Two iterators are equal if and only if they represents the

      /// same node in the graph or both are invalid.

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

      /// \brief Inequality operator.

      ///

      /// \sa operator==(const Node& n)

      ///

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

      /// \brief 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<(GraphItem) const { return false; }

      template<typename _GraphItem>

      struct Constraints {

        void constraints() {

          _GraphItem i1;

          _GraphItem i2 = i1;

          _GraphItem i3 = INVALID;

          i1 = i2 = i3;

          bool b;

          //          b = (ia == ib) && (ia != ib) && (ia < ib);

          b = (ia == ib) && (ia != ib);

          b = (ia == INVALID) && (ib != INVALID);

          b = (ia < ib);

        }

        const _GraphItem &ia;

        const _GraphItem &ib;

      };

    };

    /// \brief An empty base directed graph class.

    ///

    /// This class provides the minimal set of features needed for a

    /// directed graph structure. All digraph concepts have to

    /// conform to this base directed graph. It just provides types

    /// for nodes and arcs and functions to get the source and the

    /// target of the arcs.

    class BaseDigraphComponent {

    public:

      typedef BaseDigraphComponent Digraph;

      /// \brief Node class of the digraph.

      ///

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

      ///

      typedef GraphItem<'n'> Node;

      /// \brief Arc class of the digraph.

      ///

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

      ///

      typedef GraphItem<'e'> Arc;

      /// \brief Gives back the target node of an arc.

      ///

      /// Gives back the target node of an arc.

      ///

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

      /// \brief Gives back the source node of an arc.

      ///

      /// Gives back the source node of an arc.

      ///

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

      /// \brief Gives back the opposite node on the given arc.

      ///

      /// Gives back the opposite node on the given arc.

      Node oppositeNode(const Node&, const Arc&) const {

        return INVALID;

      }

      template <typename _Digraph>

      struct Constraints {

        typedef typename _Digraph::Node Node;

        typedef typename _Digraph::Arc Arc;

        void constraints() {

          checkConcept<GraphItem<'n'>, Node>();

          checkConcept<GraphItem<'a'>, Arc>();

          {

            Node n;

            Arc e(INVALID);

            n = digraph.source(e);

            n = digraph.target(e);

            n = digraph.oppositeNode(n, e);

          }

        }

        const _Digraph& digraph;

      };

    };

    /// \brief An empty base undirected graph class.

    ///

    /// This class provides the minimal set of features needed for an

    /// undirected graph structure. All undirected graph concepts have

    /// to conform to this base graph. It just provides types for

    /// nodes, arcs and edges and functions to get the

    /// source and the target of the arcs and edges,

    /// conversion from arcs to edges and function to get

    /// both direction of the edges.

    class BaseGraphComponent : public BaseDigraphComponent {

    public:

      typedef BaseDigraphComponent::Node Node;

      typedef BaseDigraphComponent::Arc Arc;

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

      ///

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

      /// The undirected graphs can be used as a directed graph which

      /// for each arc contains the opposite arc too so the graph is

      /// bidirected. The edge represents two opposite

      /// directed arcs.

      class Edge : public GraphItem<'u'> {

      public:

        typedef GraphItem<'u'> Parent;

        /// \brief Default constructor.

        ///

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

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

        /// as uninitialized.

        Edge() {}

        /// \brief Copy constructor.

        ///

        /// Copy constructor.

        ///

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

        /// \brief Invalid constructor \& conversion.

        ///

        /// This constructor initializes the item to be invalid.

        /// \sa Invalid for more details.

        Edge(Invalid) {}

        /// \brief Converter from arc to edge.

        ///

        /// Besides the core graph item functionality each arc should

        /// be convertible to the represented edge.

        Edge(const Arc&) {}

        /// \brief Assign arc to edge.

        ///

        /// Besides the core graph item functionality each arc should

        /// be convertible to the represented edge.

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

      };

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

      ///

      /// Returns the direction of the arc. Each arc represents an

      /// edge with a direction. It gives back the

      /// direction.

      bool direction(const Arc&) const { return true; }

      /// \brief Returns the directed arc.

      ///

      /// Returns the directed arc from its direction and the

      /// represented edge.

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

      /// \brief Returns the directed arc.

      ///

      /// Returns the directed arc from its source and the

      /// represented edge.

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

      /// \brief Returns the opposite arc.

      ///

      /// Returns the opposite arc. It is the arc representing the

      /// same edge and has opposite direction.

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

      /// \brief Gives back one ending of an edge.

      ///

      /// Gives back one ending of an edge.

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

      /// \brief Gives back the other ending of an edge.

      ///

      /// Gives back the other ending of an edge.

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

      template <typename _Graph>

      struct Constraints {

        typedef typename _Graph::Node Node;

        typedef typename _Graph::Arc Arc;

        typedef typename _Graph::Edge Edge;

        void constraints() {

          checkConcept<BaseDigraphComponent, _Graph>();

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

          {

            Node n;

            Edge ue(INVALID);

            Arc e;

            n = graph.u(ue);

            n = graph.v(ue);

            e = graph.direct(ue, true);

            e = graph.direct(ue, n);

            e = graph.oppositeArc(e);

            ue = e;

            bool d = graph.direction(e);

            ignore_unused_variable_warning(d);

          }

        }

        const _Graph& graph;

      };

    };

    /// \brief An empty idable base digraph class.

    ///

    /// This class provides beside the core digraph features

    /// core id functions for the digraph structure.

    /// The most of the base digraphs should conform to this concept.

    /// The id's are unique and immutable.

    template <typename BAS = BaseDigraphComponent>

    class IDableDigraphComponent : public BAS {

    public:

      typedef BAS Base;

      typedef typename Base::Node Node;

      typedef typename Base::Arc Arc;

      /// \brief Gives back an unique integer id for the Node.

      ///

      /// Gives back an unique integer id for the Node.

      ///

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

      /// \brief Gives back the node by the unique id.

      ///

      /// Gives back the node by the unique id.

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

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

      Node nodeFromId(int) const { return INVALID;}

      /// \brief Gives back an unique integer id for the Arc.

      ///

      /// Gives back an unique integer id for the Arc.

      ///

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

      /// \brief Gives back the arc by the unique id.

      ///

      /// Gives back the arc by the unique id.

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

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

      Arc arcFromId(int) const { return INVALID;}

      /// \brief Gives back an integer greater or equal to the maximum

      /// Node id.

      ///

      /// Gives back an integer greater or equal to the maximum Node

      /// id.

      int maxNodeId() const { return -1;}

      /// \brief Gives back an integer greater or equal to the maximum

      /// Arc id.

      ///

      /// Gives back an integer greater or equal to the maximum Arc

      /// id.

      int maxArcId() const { return -1;}

      template <typename _Digraph>

      struct Constraints {

        void constraints() {

          checkConcept<Base, _Digraph >();

          typename _Digraph::Node node;

          int nid = digraph.id(node);

          nid = digraph.id(node);

          node = digraph.nodeFromId(nid);

          typename _Digraph::Arc arc;

          int eid = digraph.id(arc);

          eid = digraph.id(arc);

          arc = digraph.arcFromId(eid);

          nid = digraph.maxNodeId();

          ignore_unused_variable_warning(nid);

          eid = digraph.maxArcId();

          ignore_unused_variable_warning(eid);

        }

        const _Digraph& digraph;

      };

    };

    /// \brief An empty idable base undirected graph class.

    ///

    /// This class provides beside the core undirected graph features

    /// core id functions for the undirected graph structure.  The

    /// most of the base undirected graphs should conform to this

    /// concept.  The id's are unique and immutable.

    template <typename BAS = BaseGraphComponent>

    class IDableGraphComponent : public IDableDigraphComponent<BAS> {

    public:

      typedef BAS Base;

      typedef typename Base::Edge Edge;

      using IDableDigraphComponent<Base>::id;

      /// \brief Gives back an unique integer id for the Edge.

      ///

      /// Gives back an unique integer id for the Edge.

      ///

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

      /// \brief Gives back the edge by the unique id.

      ///

      /// Gives back the edge by the unique id.  If the

      /// graph does not contain arc with the given id then the

      /// result of the function is undetermined.

      Edge edgeFromId(int) const { return INVALID;}

      /// \brief Gives back an integer greater or equal to the maximum

      /// Edge id.

      ///

      /// Gives back an integer greater or equal to the maximum Edge

      /// id.

      int maxEdgeId() const { return -1;}

      template <typename _Graph>

      struct Constraints {

        void constraints() {

          checkConcept<Base, _Graph >();

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

          typename _Graph::Edge edge;

          int ueid = graph.id(edge);

          ueid = graph.id(edge);

          edge = graph.edgeFromId(ueid);

          ueid = graph.maxEdgeId();

          ignore_unused_variable_warning(ueid);

        }

        const _Graph& graph;

      };

    };

    /// \brief Skeleton class for graph NodeIt and ArcIt

    ///

    /// Skeleton class for graph NodeIt and ArcIt.

    ///

    template <typename GR, typename Item>

    class GraphItemIt : public Item {

    public:

      /// \brief Default constructor.

      ///

      /// @warning The default constructor sets the iterator

      /// to an undefined value.

      GraphItemIt() {}

      /// \brief Copy constructor.

      ///

      /// Copy constructor.

      ///

      GraphItemIt(const GraphItemIt& ) {}

      /// \brief Sets the iterator to the first item.

      ///

      /// Sets the iterator to the first item of \c the graph.

      ///

      explicit GraphItemIt(const GR&) {}

      /// \brief Invalid constructor \& conversion.

      ///

      /// This constructor initializes the item to be invalid.

      /// \sa Invalid for more details.

      GraphItemIt(Invalid) {}

      /// \brief Assign operator for items.

      ///

      /// The items are assignable.

      ///

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

      /// \brief Next item.

      ///

      /// Assign the iterator to the next item.

      ///

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

      /// \brief Equality operator

      ///

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

      /// same object or both are invalid.

      bool operator==(const GraphItemIt&) const { return true;}

      /// \brief Inequality operator

      ///

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

      ///

      bool operator!=(const GraphItemIt&) const { return true;}

      template<typename _GraphItemIt>

      struct Constraints {

        void constraints() {

          _GraphItemIt it1(g);

          _GraphItemIt it2;

          it2 = ++it1;

          ++it2 = it1;

          ++(++it1);

          Item bi = it1;

          bi = it2;

        }

        GR& g;

      };

    };

    /// \brief Skeleton class for graph InArcIt and OutArcIt

    ///

    /// \note Because InArcIt and OutArcIt may not inherit from the same

    /// base class, the \c sel is a additional template parameter (selector).

    /// For InArcIt you should instantiate it with character 'i' and for

    /// OutArcIt with 'o'.

    template <typename GR,

              typename Item = typename GR::Arc,

              typename Base = typename GR::Node,

              char sel = '0'>

    class GraphIncIt : public Item {

    public:

      /// \brief Default constructor.

      ///

      /// @warning The default constructor sets the iterator

      /// to an undefined value.

      GraphIncIt() {}

      /// \brief Copy constructor.

      ///

      /// Copy constructor.

      ///

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

      /// \brief Sets the iterator to the first arc incoming into or outgoing

      /// from the node.

      ///

      /// Sets the iterator to the first arc incoming into or outgoing

      /// from the node.

      ///

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

      /// \brief Invalid constructor \& conversion.

      ///

      /// This constructor initializes the item to be invalid.

      /// \sa Invalid for more details.

      GraphIncIt(Invalid) {}

      /// \brief Assign operator for iterators.

      ///

      /// The iterators are assignable.

      ///

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

      /// \brief Next item.

      ///

      /// Assign the iterator to the next item.

      ///

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

      /// \brief Equality operator

      ///

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

      /// same object or both are invalid.

      bool operator==(const GraphIncIt&) const { return true;}

      /// \brief Inequality operator

      ///

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

      ///

      bool operator!=(const GraphIncIt&) const { return true;}

      template <typename _GraphIncIt>

      struct Constraints {

        void constraints() {

          checkConcept<GraphItem<sel>, _GraphIncIt>();

          _GraphIncIt it1(graph, node);

          _GraphIncIt it2;

          it2 = ++it1;

          ++it2 = it1;

          ++(++it1);

          Item e = it1;

          e = it2;

        }

        Item arc;

        Base node;

        GR graph;

        _GraphIncIt it;

      };

    };

    /// \brief An empty iterable digraph class.

    ///

    /// This class provides beside the core digraph features

    /// iterator based iterable interface for the digraph structure.

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

    template <typename BAS = BaseDigraphComponent>

    class IterableDigraphComponent : public BAS {

    public:

      typedef BAS Base;

      typedef typename Base::Node Node;

      typedef typename Base::Arc Arc;

      typedef IterableDigraphComponent Digraph;

      /// \name Base iteration

      ///

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

      ///

      /// @{

      /// \brief Gives back the first node in the iterating order.

      ///

      /// Gives back the first node in the iterating order.

      ///

      void first(Node&) const {}

      /// \brief Gives back the next node in the iterating order.

      ///

      /// Gives back the next node in the iterating order.

      ///

      void next(Node&) const {}

      /// \brief Gives back the first arc in the iterating order.

      ///

      /// Gives back the first arc in the iterating order.

      ///

      void first(Arc&) const {}

      /// \brief Gives back the next arc in the iterating order.

      ///

      /// Gives back the next arc in the iterating order.

      ///

      void next(Arc&) const {}

      /// \brief Gives back the first of the arcs point to the given

      /// node.

      ///

      /// Gives back the first of the arcs point to the given node.

      ///

      void firstIn(Arc&, const Node&) const {}

      /// \brief Gives back the next of the arcs points to the given

      /// node.

      ///

      /// Gives back the next of the arcs points to the given node.

      ///

      void nextIn(Arc&) const {}

      /// \brief Gives back the first of the arcs start from the

      /// given node.

      ///

      /// Gives back the first of the arcs start from the given node.

      ///

      void firstOut(Arc&, const Node&) const {}

      /// \brief Gives back the next of the arcs start from the given

      /// node.

      ///

      /// Gives back the next of the arcs start from the given node.

      ///

      void nextOut(Arc&) const {}

      /// @}

      /// \name Class based iteration

      ///

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

      ///

      /// @{

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

      ///

      /// This iterator goes through each node.

      ///

      typedef GraphItemIt<Digraph, Node> NodeIt;

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

      ///

      /// This iterator goes through each node.

      ///

      typedef GraphItemIt<Digraph, Arc> ArcIt;

      /// \brief This iterator goes trough the incoming arcs of a node.

      ///

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

      /// of a digraph.

      typedef GraphIncIt<Digraph, Arc, Node, 'i'> InArcIt;

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

      typedef GraphIncIt<Digraph, Arc, Node, 'o'> OutArcIt;

      /// \brief The base node of the iterator.

      ///

      /// Gives back the base node of the iterator.

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

      Node baseNode(const InArcIt&) const { return INVALID; }

      /// \brief The running node of the iterator.

      ///

      /// Gives back the running node of the iterator.

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

      Node runningNode(const InArcIt&) const { return INVALID; }

      /// \brief The base node of the iterator.

      ///

      /// Gives back the base node of the iterator.

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

      Node baseNode(const OutArcIt&) const { return INVALID; }

      /// \brief The running node of the iterator.

      ///

      /// Gives back the running node of the iterator.

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

      Node runningNode(const OutArcIt&) const { return INVALID; }

      /// @}

      template <typename _Digraph>

      struct Constraints {

        void constraints() {

          checkConcept<Base, _Digraph>();

          {

            typename _Digraph::Node node(INVALID);

            typename _Digraph::Arc arc(INVALID);

            {

              digraph.first(node);

              digraph.next(node);

            }

            {

              digraph.first(arc);

              digraph.next(arc);

            }

            {

              digraph.firstIn(arc, node);

              digraph.nextIn(arc);

            }

            {

              digraph.firstOut(arc, node);

              digraph.nextOut(arc);

            }

          }

          {

            checkConcept<GraphItemIt<_Digraph, typename _Digraph::Arc>,

              typename _Digraph::ArcIt >();

            checkConcept<GraphItemIt<_Digraph, typename _Digraph::Node>,

              typename _Digraph::NodeIt >();

            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,

              typename _Digraph::Node, 'i'>, typename _Digraph::InArcIt>();

            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,

              typename _Digraph::Node, 'o'>, typename _Digraph::OutArcIt>();

            typename _Digraph::Node n;

            typename _Digraph::InArcIt ieit(INVALID);

            typename _Digraph::OutArcIt oeit(INVALID);

            n = digraph.baseNode(ieit);

            n = digraph.runningNode(ieit);

            n = digraph.baseNode(oeit);

            n = digraph.runningNode(oeit);

            ignore_unused_variable_warning(n);

          }

        }

        const _Digraph& digraph;

      };

    };

    /// \brief An empty iterable undirected graph class.

    ///

    /// This class provides beside the core graph features iterator

    /// based iterable interface for the undirected graph structure.

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

    template <typename BAS = BaseGraphComponent>

    class IterableGraphComponent : public IterableDigraphComponent<BAS> {

    public:

      typedef BAS Base;

      typedef typename Base::Node Node;

      typedef typename Base::Arc Arc;

      typedef typename Base::Edge Edge;

      typedef IterableGraphComponent Graph;

      /// \name Base iteration

      ///

      /// This interface provides functions for iteration on graph items

      /// @{

      using IterableDigraphComponent<Base>::first;

      using IterableDigraphComponent<Base>::next;

      /// \brief Gives back the first edge in the iterating

      /// order.

      ///

      /// Gives back the first edge in the iterating order.

      ///

      void first(Edge&) const {}

      /// \brief Gives back the next edge in the iterating

      /// order.

      ///

      /// Gives back the next edge in the iterating order.

      ///

      void next(Edge&) const {}

      /// \brief Gives back the first of the edges from the

      /// given node.

      ///

      /// Gives back the first of the edges from the given

      /// node. The bool parameter gives back that direction which

      /// gives a good direction of the edge so the source of the

      /// directed arc is the given node.

      void firstInc(Edge&, bool&, const Node&) const {}

      /// \brief Gives back the next of the edges from the

      /// given node.

      ///

      /// Gives back the next of the edges from the given

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

      /// use it.

      void nextInc(Edge&, bool&) const {}

      using IterableDigraphComponent<Base>::baseNode;

      using IterableDigraphComponent<Base>::runningNode;

      /// @}

      /// \name Class based iteration

      ///

      /// This interface provides functions for iteration on graph items

      ///

      /// @{

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

      ///

      /// This iterator goes through each node.

      typedef GraphItemIt<Graph, Edge> EdgeIt;

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

      /// node.

      ///

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

      /// node of a graph.

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

      /// \brief The base node of the iterator.

      ///

      /// Gives back the base node of the iterator.

      Node baseNode(const IncEdgeIt&) const { return INVALID; }

      /// \brief The running node of the iterator.

      ///

      /// Gives back the running node of the iterator.

      Node runningNode(const IncEdgeIt&) const { return INVALID; }

      /// @}

      template <typename _Graph>

      struct Constraints {

        void constraints() {

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

          {

            typename _Graph::Node node(INVALID);

            typename _Graph::Edge edge(INVALID);

            bool dir;

            {

              graph.first(edge);

              graph.next(edge);

            }

            {

              graph.firstInc(edge, dir, node);

              graph.nextInc(edge, dir);

            }

          }

          {

            checkConcept<GraphItemIt<_Graph, typename _Graph::Edge>,

              typename _Graph::EdgeIt >();

            checkConcept<GraphIncIt<_Graph, typename _Graph::Edge,

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

            typename _Graph::Node n;

            typename _Graph::IncEdgeIt ueit(INVALID);

            n = graph.baseNode(ueit);

            n = graph.runningNode(ueit);

          }

        }

        const _Graph& graph;

      };

    };

    /// \brief An empty alteration notifier digraph class.

    ///

    /// This class provides beside the core digraph features alteration

    /// notifier interface for the digraph structure.  This implements

    /// an observer-notifier pattern for each digraph item. More

    /// obsevers can be registered into the notifier and whenever an

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

    /// notified about it.

    template <typename BAS = BaseDigraphComponent>

    class AlterableDigraphComponent : public BAS {

    public:

      typedef BAS Base;

      typedef typename Base::Node Node;

      typedef typename Base::Arc Arc;

      /// The node observer registry.

      typedef AlterationNotifier<AlterableDigraphComponent, Node>

      NodeNotifier;

      /// The arc observer registry.

      typedef AlterationNotifier<AlterableDigraphComponent, Arc>

      ArcNotifier;

      /// \brief Gives back the node alteration notifier.

      ///

      /// Gives back the node alteration notifier.

      NodeNotifier& notifier(Node) const {

        return NodeNotifier();

      }

      /// \brief Gives back the arc alteration notifier.

      ///

      /// Gives back the arc alteration notifier.

      ArcNotifier& notifier(Arc) const {

        return ArcNotifier();

      }

      template <typename _Digraph>

      struct Constraints {

        void constraints() {

          checkConcept<Base, _Digraph>();

          typename _Digraph::NodeNotifier& nn

            = digraph.notifier(typename _Digraph::Node());

          typename _Digraph::ArcNotifier& en

            = digraph.notifier(typename _Digraph::Arc());

          ignore_unused_variable_warning(nn);

          ignore_unused_variable_warning(en);

        }

        const _Digraph& digraph;

      };

    };

    /// \brief An empty alteration notifier undirected graph class.

    ///

    /// This class provides beside the core graph features alteration

    /// notifier interface for the graph structure.  This implements

    /// an observer-notifier pattern for each graph item. More

    /// obsevers can be registered into the notifier and whenever an

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

    /// notified about it.

    template <typename BAS = BaseGraphComponent>

    class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {

    public:

      typedef BAS Base;

      typedef typename Base::Edge Edge;

      /// The arc observer registry.

      typedef AlterationNotifier<AlterableGraphComponent, Edge>

      EdgeNotifier;

      /// \brief Gives back the arc alteration notifier.

      ///

      /// Gives back the arc alteration notifier.

      EdgeNotifier& notifier(Edge) const {

        return EdgeNotifier();

      }

      template <typename _Graph>

      struct Constraints {

        void constraints() {

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

          typename _Graph::EdgeNotifier& uen

            = graph.notifier(typename _Graph::Edge());

          ignore_unused_variable_warning(uen);

        }

        const _Graph& graph;

      };

    };

    /// \brief Class describing the concept of graph maps

    ///

    /// This class describes the common interface of the graph maps

    /// (NodeMap, ArcMap), that is maps that can be used to

    /// associate data to graph descriptors (nodes or arcs).

    template <typename GR, typename K, typename V>

    class GraphMap : public ReadWriteMap<K, V> {

    public:

      typedef ReadWriteMap<K, V> Parent;

      /// The graph type of the map.

      typedef GR Graph;

      /// The key type of the map.

      typedef K Key;