Various improvements and fixes (mainly in the doc) (#190)
authorPeter Kovacs <kpeter@inf.elte.hu>
Tue, 14 Apr 2009 10:33:17 +0200
changeset 571d11bf7998905
parent 565 37216ca5b9c6
child 572 2313edd0db0b
Various improvements and fixes (mainly in the doc) (#190)
lemon/adaptors.h
lemon/concepts/graph_components.h
     1.1 --- a/lemon/adaptors.h	Tue Apr 07 14:50:20 2009 +0100
     1.2 +++ b/lemon/adaptors.h	Tue Apr 14 10:33:17 2009 +0200
     1.3 @@ -2192,6 +2192,9 @@
     1.4  
     1.5      typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
     1.6      EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
     1.7 +    
     1.8 +    typedef EdgeNotifier ArcNotifier;
     1.9 +    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
    1.10  
    1.11    protected:
    1.12  
     2.1 --- a/lemon/concepts/graph_components.h	Tue Apr 07 14:50:20 2009 +0100
     2.2 +++ b/lemon/concepts/graph_components.h	Tue Apr 14 10:33:17 2009 +0200
     2.3 @@ -31,17 +31,16 @@
     2.4  namespace lemon {
     2.5    namespace concepts {
     2.6  
     2.7 -    /// \brief Skeleton class for graph Node and Arc types
     2.8 +    /// \brief Concept class for \c Node, \c Arc and \c Edge types.
     2.9      ///
    2.10 -    /// This class describes the interface of Node and Arc (and Edge
    2.11 -    /// in undirected graphs) subtypes of graph types.
    2.12 +    /// This class describes the concept of \c Node, \c Arc and \c Edge
    2.13 +    /// subtypes of digraph and graph types.
    2.14      ///
    2.15      /// \note This class is a template class so that we can use it to
    2.16 -    /// create graph skeleton classes. The reason for this is than Node
    2.17 -    /// and Arc types should \em not derive from the same base class.
    2.18 -    /// For Node you should instantiate it with character 'n' and for Arc
    2.19 -    /// with 'a'.
    2.20 -
    2.21 +    /// create graph skeleton classes. The reason for this is that \c Node
    2.22 +    /// and \c Arc (or \c Edge) types should \e not derive from the same 
    2.23 +    /// base class. For \c Node you should instantiate it with character
    2.24 +    /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
    2.25  #ifndef DOXYGEN
    2.26      template <char sel = '0'>
    2.27  #endif
    2.28 @@ -49,45 +48,49 @@
    2.29      public:
    2.30        /// \brief Default constructor.
    2.31        ///
    2.32 +      /// Default constructor.
    2.33        /// \warning The default constructor is not required to set
    2.34        /// the item to some well-defined value. So you should consider it
    2.35        /// as uninitialized.
    2.36        GraphItem() {}
    2.37 +
    2.38        /// \brief Copy constructor.
    2.39        ///
    2.40        /// Copy constructor.
    2.41 +      GraphItem(const GraphItem &) {}
    2.42 +
    2.43 +      /// \brief Constructor for conversion from \c INVALID.
    2.44        ///
    2.45 -      GraphItem(const GraphItem &) {}
    2.46 -      /// \brief Invalid constructor \& conversion.
    2.47 -      ///
    2.48 -      /// This constructor initializes the item to be invalid.
    2.49 +      /// Constructor for conversion from \c INVALID.
    2.50 +      /// It initializes the item to be invalid.
    2.51        /// \sa Invalid for more details.
    2.52        GraphItem(Invalid) {}
    2.53 -      /// \brief Assign operator for nodes.
    2.54 +
    2.55 +      /// \brief Assignment operator.
    2.56        ///
    2.57 -      /// The nodes are assignable.
    2.58 -      ///
    2.59 -      GraphItem& operator=(GraphItem const&) { return *this; }
    2.60 +      /// Assignment operator for the item.
    2.61 +      GraphItem& operator=(const GraphItem&) { return *this; }
    2.62 +
    2.63        /// \brief Equality operator.
    2.64        ///
    2.65 -      /// Two iterators are equal if and only if they represents the
    2.66 -      /// same node in the graph or both are invalid.
    2.67 -      bool operator==(GraphItem) const { return false; }
    2.68 +      /// Equality operator.
    2.69 +      bool operator==(const GraphItem&) const { return false; }
    2.70 +
    2.71        /// \brief Inequality operator.
    2.72        ///
    2.73 -      /// \sa operator==(const Node& n)
    2.74 +      /// Inequality operator.
    2.75 +      bool operator!=(const GraphItem&) const { return false; }
    2.76 +
    2.77 +      /// \brief Ordering operator.
    2.78        ///
    2.79 -      bool operator!=(GraphItem) const { return false; }
    2.80 -
    2.81 -      /// \brief Artificial ordering operator.
    2.82 -      ///
    2.83 -      /// To allow the use of graph descriptors as key type in std::map or
    2.84 -      /// similar associative container we require this.
    2.85 +      /// This operator defines an ordering of the items.
    2.86 +      /// It makes possible to use graph item types as key types in 
    2.87 +      /// associative containers (e.g. \c std::map).
    2.88        ///
    2.89        /// \note This operator only have to define some strict ordering of
    2.90        /// the items; this order has nothing to do with the iteration
    2.91        /// ordering of the items.
    2.92 -      bool operator<(GraphItem) const { return false; }
    2.93 +      bool operator<(const GraphItem&) const { return false; }
    2.94  
    2.95        template<typename _GraphItem>
    2.96        struct Constraints {
    2.97 @@ -99,7 +102,6 @@
    2.98            i1 = i2 = i3;
    2.99  
   2.100            bool b;
   2.101 -          //          b = (ia == ib) && (ia != ib) && (ia < ib);
   2.102            b = (ia == ib) && (ia != ib);
   2.103            b = (ia == INVALID) && (ib != INVALID);
   2.104            b = (ia < ib);
   2.105 @@ -110,13 +112,12 @@
   2.106        };
   2.107      };
   2.108  
   2.109 -    /// \brief An empty base directed graph class.
   2.110 +    /// \brief Base skeleton class for directed graphs.
   2.111      ///
   2.112 -    /// This class provides the minimal set of features needed for a
   2.113 -    /// directed graph structure. All digraph concepts have to
   2.114 -    /// conform to this base directed graph. It just provides types
   2.115 -    /// for nodes and arcs and functions to get the source and the
   2.116 -    /// target of the arcs.
   2.117 +    /// This class describes the base interface of directed graph types.
   2.118 +    /// All digraph %concepts have to conform to this class.
   2.119 +    /// It just provides types for nodes and arcs and functions 
   2.120 +    /// to get the source and the target nodes of arcs.
   2.121      class BaseDigraphComponent {
   2.122      public:
   2.123  
   2.124 @@ -124,31 +125,27 @@
   2.125  
   2.126        /// \brief Node class of the digraph.
   2.127        ///
   2.128 -      /// This class represents the Nodes of the digraph.
   2.129 -      ///
   2.130 +      /// This class represents the nodes of the digraph.
   2.131        typedef GraphItem<'n'> Node;
   2.132  
   2.133        /// \brief Arc class of the digraph.
   2.134        ///
   2.135 -      /// This class represents the Arcs of the digraph.
   2.136 +      /// This class represents the arcs of the digraph.
   2.137 +      typedef GraphItem<'a'> Arc;
   2.138 +
   2.139 +      /// \brief Return the source node of an arc.
   2.140        ///
   2.141 -      typedef GraphItem<'e'> Arc;
   2.142 +      /// This function returns the source node of an arc.
   2.143 +      Node source(const Arc&) const { return INVALID; }
   2.144  
   2.145 -      /// \brief Gives back the target node of an arc.
   2.146 +      /// \brief Return the target node of an arc.
   2.147        ///
   2.148 -      /// Gives back the target node of an arc.
   2.149 +      /// This function returns the target node of an arc.
   2.150 +      Node target(const Arc&) const { return INVALID; }
   2.151 +
   2.152 +      /// \brief Return the opposite node on the given arc.
   2.153        ///
   2.154 -      Node target(const Arc&) const { return INVALID;}
   2.155 -
   2.156 -      /// \brief Gives back the source node of an arc.
   2.157 -      ///
   2.158 -      /// Gives back the source node of an arc.
   2.159 -      ///
   2.160 -      Node source(const Arc&) const { return INVALID;}
   2.161 -
   2.162 -      /// \brief Gives back the opposite node on the given arc.
   2.163 -      ///
   2.164 -      /// Gives back the opposite node on the given arc.
   2.165 +      /// This function returns the opposite node on the given arc.
   2.166        Node oppositeNode(const Node&, const Arc&) const {
   2.167          return INVALID;
   2.168        }
   2.169 @@ -174,91 +171,96 @@
   2.170        };
   2.171      };
   2.172  
   2.173 -    /// \brief An empty base undirected graph class.
   2.174 +    /// \brief Base skeleton class for undirected graphs.
   2.175      ///
   2.176 -    /// This class provides the minimal set of features needed for an
   2.177 -    /// undirected graph structure. All undirected graph concepts have
   2.178 -    /// to conform to this base graph. It just provides types for
   2.179 -    /// nodes, arcs and edges and functions to get the
   2.180 -    /// source and the target of the arcs and edges,
   2.181 -    /// conversion from arcs to edges and function to get
   2.182 -    /// both direction of the edges.
   2.183 +    /// This class describes the base interface of undirected graph types.
   2.184 +    /// All graph %concepts have to conform to this class.
   2.185 +    /// It extends the interface of \ref BaseDigraphComponent with an
   2.186 +    /// \c Edge type and functions to get the end nodes of edges,
   2.187 +    /// to convert from arcs to edges and to get both direction of edges.
   2.188      class BaseGraphComponent : public BaseDigraphComponent {
   2.189      public:
   2.190        typedef BaseDigraphComponent::Node Node;
   2.191        typedef BaseDigraphComponent::Arc Arc;
   2.192 -      /// \brief Undirected arc class of the graph.
   2.193 +
   2.194 +      /// \brief Undirected edge class of the graph.
   2.195        ///
   2.196 -      /// This class represents the edges of the graph.
   2.197 -      /// The undirected graphs can be used as a directed graph which
   2.198 -      /// for each arc contains the opposite arc too so the graph is
   2.199 -      /// bidirected. The edge represents two opposite
   2.200 -      /// directed arcs.
   2.201 -      class Edge : public GraphItem<'u'> {
   2.202 +      /// This class represents the undirected edges of the graph.
   2.203 +      /// Undirected graphs can be used as directed graphs, each edge is
   2.204 +      /// represented by two opposite directed arcs.
   2.205 +      class Edge : public GraphItem<'e'> {
   2.206        public:
   2.207 -        typedef GraphItem<'u'> Parent;
   2.208 +        typedef GraphItem<'e'> Parent;
   2.209 +
   2.210          /// \brief Default constructor.
   2.211          ///
   2.212 +        /// Default constructor.
   2.213          /// \warning The default constructor is not required to set
   2.214          /// the item to some well-defined value. So you should consider it
   2.215          /// as uninitialized.
   2.216          Edge() {}
   2.217 +
   2.218          /// \brief Copy constructor.
   2.219          ///
   2.220          /// Copy constructor.
   2.221 +        Edge(const Edge &) : Parent() {}
   2.222 +
   2.223 +        /// \brief Constructor for conversion from \c INVALID.
   2.224          ///
   2.225 -        Edge(const Edge &) : Parent() {}
   2.226 -        /// \brief Invalid constructor \& conversion.
   2.227 -        ///
   2.228 -        /// This constructor initializes the item to be invalid.
   2.229 +        /// Constructor for conversion from \c INVALID.
   2.230 +        /// It initializes the item to be invalid.
   2.231          /// \sa Invalid for more details.
   2.232          Edge(Invalid) {}
   2.233 -        /// \brief Converter from arc to edge.
   2.234 +
   2.235 +        /// \brief Constructor for conversion from an arc.
   2.236          ///
   2.237 +        /// Constructor for conversion from an arc.
   2.238          /// Besides the core graph item functionality each arc should
   2.239          /// be convertible to the represented edge.
   2.240          Edge(const Arc&) {}
   2.241 -        /// \brief Assign arc to edge.
   2.242 +
   2.243 +        /// \brief Assign an arc to an edge.
   2.244          ///
   2.245 +        /// This function assigns an arc to an edge.
   2.246          /// Besides the core graph item functionality each arc should
   2.247          /// be convertible to the represented edge.
   2.248          Edge& operator=(const Arc&) { return *this; }
   2.249        };
   2.250  
   2.251 -      /// \brief Returns the direction of the arc.
   2.252 +      /// \brief Return one end node of an edge.
   2.253 +      ///
   2.254 +      /// This function returns one end node of an edge.
   2.255 +      Node u(const Edge&) const { return INVALID; }
   2.256 +
   2.257 +      /// \brief Return the other end node of an edge.
   2.258 +      ///
   2.259 +      /// This function returns the other end node of an edge.
   2.260 +      Node v(const Edge&) const { return INVALID; }
   2.261 +
   2.262 +      /// \brief Return a directed arc related to an edge.
   2.263 +      ///
   2.264 +      /// This function returns a directed arc from its direction and the
   2.265 +      /// represented edge.
   2.266 +      Arc direct(const Edge&, bool) const { return INVALID; }
   2.267 +
   2.268 +      /// \brief Return a directed arc related to an edge.
   2.269 +      ///
   2.270 +      /// This function returns a directed arc from its source node and the
   2.271 +      /// represented edge.
   2.272 +      Arc direct(const Edge&, const Node&) const { return INVALID; }
   2.273 +
   2.274 +      /// \brief Return the direction of the arc.
   2.275        ///
   2.276        /// Returns the direction of the arc. Each arc represents an
   2.277        /// edge with a direction. It gives back the
   2.278        /// direction.
   2.279        bool direction(const Arc&) const { return true; }
   2.280  
   2.281 -      /// \brief Returns the directed arc.
   2.282 +      /// \brief Return the opposite arc.
   2.283        ///
   2.284 -      /// Returns the directed arc from its direction and the
   2.285 -      /// represented edge.
   2.286 -      Arc direct(const Edge&, bool) const { return INVALID;}
   2.287 -
   2.288 -      /// \brief Returns the directed arc.
   2.289 -      ///
   2.290 -      /// Returns the directed arc from its source and the
   2.291 -      /// represented edge.
   2.292 -      Arc direct(const Edge&, const Node&) const { return INVALID;}
   2.293 -
   2.294 -      /// \brief Returns the opposite arc.
   2.295 -      ///
   2.296 -      /// Returns the opposite arc. It is the arc representing the
   2.297 -      /// same edge and has opposite direction.
   2.298 -      Arc oppositeArc(const Arc&) const { return INVALID;}
   2.299 -
   2.300 -      /// \brief Gives back one ending of an edge.
   2.301 -      ///
   2.302 -      /// Gives back one ending of an edge.
   2.303 -      Node u(const Edge&) const { return INVALID;}
   2.304 -
   2.305 -      /// \brief Gives back the other ending of an edge.
   2.306 -      ///
   2.307 -      /// Gives back the other ending of an edge.
   2.308 -      Node v(const Edge&) const { return INVALID;}
   2.309 +      /// This function returns the opposite arc, i.e. the arc representing
   2.310 +      /// the same edge and has opposite direction.
   2.311 +      Arc oppositeArc(const Arc&) const { return INVALID; }
   2.312  
   2.313        template <typename _Graph>
   2.314        struct Constraints {
   2.315 @@ -268,7 +270,7 @@
   2.316  
   2.317          void constraints() {
   2.318            checkConcept<BaseDigraphComponent, _Graph>();
   2.319 -          checkConcept<GraphItem<'u'>, Edge>();
   2.320 +          checkConcept<GraphItem<'e'>, Edge>();
   2.321            {
   2.322              Node n;
   2.323              Edge ue(INVALID);
   2.324 @@ -276,6 +278,7 @@
   2.325              n = graph.u(ue);
   2.326              n = graph.v(ue);
   2.327              e = graph.direct(ue, true);
   2.328 +            e = graph.direct(ue, false);
   2.329              e = graph.direct(ue, n);
   2.330              e = graph.oppositeArc(e);
   2.331              ue = e;
   2.332 @@ -289,12 +292,12 @@
   2.333  
   2.334      };
   2.335  
   2.336 -    /// \brief An empty idable base digraph class.
   2.337 +    /// \brief Skeleton class for \e idable directed graphs.
   2.338      ///
   2.339 -    /// This class provides beside the core digraph features
   2.340 -    /// core id functions for the digraph structure.
   2.341 -    /// The most of the base digraphs should conform to this concept.
   2.342 -    /// The id's are unique and immutable.
   2.343 +    /// This class describes the interface of \e idable directed graphs.
   2.344 +    /// It extends \ref BaseDigraphComponent with the core ID functions.
   2.345 +    /// The ids of the items must be unique and immutable.
   2.346 +    /// This concept is part of the Digraph concept.
   2.347      template <typename BAS = BaseDigraphComponent>
   2.348      class IDableDigraphComponent : public BAS {
   2.349      public:
   2.350 @@ -303,45 +306,43 @@
   2.351        typedef typename Base::Node Node;
   2.352        typedef typename Base::Arc Arc;
   2.353  
   2.354 -      /// \brief Gives back an unique integer id for the Node.
   2.355 +      /// \brief Return a unique integer id for the given node.
   2.356        ///
   2.357 -      /// Gives back an unique integer id for the Node.
   2.358 +      /// This function returns a unique integer id for the given node.
   2.359 +      int id(const Node&) const { return -1; }
   2.360 +
   2.361 +      /// \brief Return the node by its unique id.
   2.362        ///
   2.363 -      int id(const Node&) const { return -1;}
   2.364 +      /// This function returns the node by its unique id.
   2.365 +      /// If the digraph does not contain a node with the given id,
   2.366 +      /// then the result of the function is undefined.
   2.367 +      Node nodeFromId(int) const { return INVALID; }
   2.368  
   2.369 -      /// \brief Gives back the node by the unique id.
   2.370 +      /// \brief Return a unique integer id for the given arc.
   2.371        ///
   2.372 -      /// Gives back the node by the unique id.
   2.373 -      /// If the digraph does not contain node with the given id
   2.374 -      /// then the result of the function is undetermined.
   2.375 -      Node nodeFromId(int) const { return INVALID;}
   2.376 +      /// This function returns a unique integer id for the given arc.
   2.377 +      int id(const Arc&) const { return -1; }
   2.378  
   2.379 -      /// \brief Gives back an unique integer id for the Arc.
   2.380 +      /// \brief Return the arc by its unique id.
   2.381        ///
   2.382 -      /// Gives back an unique integer id for the Arc.
   2.383 +      /// This function returns the arc by its unique id.
   2.384 +      /// If the digraph does not contain an arc with the given id,
   2.385 +      /// then the result of the function is undefined.
   2.386 +      Arc arcFromId(int) const { return INVALID; }
   2.387 +
   2.388 +      /// \brief Return an integer greater or equal to the maximum
   2.389 +      /// node id.
   2.390        ///
   2.391 -      int id(const Arc&) const { return -1;}
   2.392 +      /// This function returns an integer greater or equal to the
   2.393 +      /// maximum node id.
   2.394 +      int maxNodeId() const { return -1; }
   2.395  
   2.396 -      /// \brief Gives back the arc by the unique id.
   2.397 +      /// \brief Return an integer greater or equal to the maximum
   2.398 +      /// arc id.
   2.399        ///
   2.400 -      /// Gives back the arc by the unique id.
   2.401 -      /// If the digraph does not contain arc with the given id
   2.402 -      /// then the result of the function is undetermined.
   2.403 -      Arc arcFromId(int) const { return INVALID;}
   2.404 -
   2.405 -      /// \brief Gives back an integer greater or equal to the maximum
   2.406 -      /// Node id.
   2.407 -      ///
   2.408 -      /// Gives back an integer greater or equal to the maximum Node
   2.409 -      /// id.
   2.410 -      int maxNodeId() const { return -1;}
   2.411 -
   2.412 -      /// \brief Gives back an integer greater or equal to the maximum
   2.413 -      /// Arc id.
   2.414 -      ///
   2.415 -      /// Gives back an integer greater or equal to the maximum Arc
   2.416 -      /// id.
   2.417 -      int maxArcId() const { return -1;}
   2.418 +      /// This function returns an integer greater or equal to the
   2.419 +      /// maximum arc id.
   2.420 +      int maxArcId() const { return -1; }
   2.421  
   2.422        template <typename _Digraph>
   2.423        struct Constraints {
   2.424 @@ -367,12 +368,13 @@
   2.425        };
   2.426      };
   2.427  
   2.428 -    /// \brief An empty idable base undirected graph class.
   2.429 +    /// \brief Skeleton class for \e idable undirected graphs.
   2.430      ///
   2.431 -    /// This class provides beside the core undirected graph features
   2.432 -    /// core id functions for the undirected graph structure.  The
   2.433 -    /// most of the base undirected graphs should conform to this
   2.434 -    /// concept.  The id's are unique and immutable.
   2.435 +    /// This class describes the interface of \e idable undirected
   2.436 +    /// graphs. It extends \ref IDableDigraphComponent with the core ID
   2.437 +    /// functions of undirected graphs.
   2.438 +    /// The ids of the items must be unique and immutable.
   2.439 +    /// This concept is part of the Graph concept.
   2.440      template <typename BAS = BaseGraphComponent>
   2.441      class IDableGraphComponent : public IDableDigraphComponent<BAS> {
   2.442      public:
   2.443 @@ -382,31 +384,29 @@
   2.444  
   2.445        using IDableDigraphComponent<Base>::id;
   2.446  
   2.447 -      /// \brief Gives back an unique integer id for the Edge.
   2.448 +      /// \brief Return a unique integer id for the given edge.
   2.449        ///
   2.450 -      /// Gives back an unique integer id for the Edge.
   2.451 +      /// This function returns a unique integer id for the given edge.
   2.452 +      int id(const Edge&) const { return -1; }
   2.453 +
   2.454 +      /// \brief Return the edge by its unique id.
   2.455        ///
   2.456 -      int id(const Edge&) const { return -1;}
   2.457 +      /// This function returns the edge by its unique id.
   2.458 +      /// If the graph does not contain an edge with the given id,
   2.459 +      /// then the result of the function is undefined.
   2.460 +      Edge edgeFromId(int) const { return INVALID; }
   2.461  
   2.462 -      /// \brief Gives back the edge by the unique id.
   2.463 +      /// \brief Return an integer greater or equal to the maximum
   2.464 +      /// edge id.
   2.465        ///
   2.466 -      /// Gives back the edge by the unique id.  If the
   2.467 -      /// graph does not contain arc with the given id then the
   2.468 -      /// result of the function is undetermined.
   2.469 -      Edge edgeFromId(int) const { return INVALID;}
   2.470 -
   2.471 -      /// \brief Gives back an integer greater or equal to the maximum
   2.472 -      /// Edge id.
   2.473 -      ///
   2.474 -      /// Gives back an integer greater or equal to the maximum Edge
   2.475 -      /// id.
   2.476 -      int maxEdgeId() const { return -1;}
   2.477 +      /// This function returns an integer greater or equal to the
   2.478 +      /// maximum edge id.
   2.479 +      int maxEdgeId() const { return -1; }
   2.480  
   2.481        template <typename _Graph>
   2.482        struct Constraints {
   2.483  
   2.484          void constraints() {
   2.485 -          checkConcept<Base, _Graph >();
   2.486            checkConcept<IDableDigraphComponent<Base>, _Graph >();
   2.487            typename _Graph::Edge edge;
   2.488            int ueid = graph.id(edge);
   2.489 @@ -420,59 +420,71 @@
   2.490        };
   2.491      };
   2.492  
   2.493 -    /// \brief Skeleton class for graph NodeIt and ArcIt
   2.494 +    /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
   2.495      ///
   2.496 -    /// Skeleton class for graph NodeIt and ArcIt.
   2.497 -    ///
   2.498 +    /// This class describes the concept of \c NodeIt, \c ArcIt and 
   2.499 +    /// \c EdgeIt subtypes of digraph and graph types.
   2.500      template <typename GR, typename Item>
   2.501      class GraphItemIt : public Item {
   2.502      public:
   2.503        /// \brief Default constructor.
   2.504        ///
   2.505 -      /// @warning The default constructor sets the iterator
   2.506 -      /// to an undefined value.
   2.507 +      /// Default constructor.
   2.508 +      /// \warning The default constructor is not required to set
   2.509 +      /// the iterator to some well-defined value. So you should consider it
   2.510 +      /// as uninitialized.
   2.511        GraphItemIt() {}
   2.512 +
   2.513        /// \brief Copy constructor.
   2.514        ///
   2.515        /// Copy constructor.
   2.516 +      GraphItemIt(const GraphItemIt& it) : Item(it) {}
   2.517 +
   2.518 +      /// \brief Constructor that sets the iterator to the first item.
   2.519        ///
   2.520 -      GraphItemIt(const GraphItemIt& ) {}
   2.521 -      /// \brief Sets the iterator to the first item.
   2.522 +      /// Constructor that sets the iterator to the first item.
   2.523 +      explicit GraphItemIt(const GR&) {}
   2.524 +
   2.525 +      /// \brief Constructor for conversion from \c INVALID.
   2.526        ///
   2.527 -      /// Sets the iterator to the first item of \c the graph.
   2.528 -      ///
   2.529 -      explicit GraphItemIt(const GR&) {}
   2.530 -      /// \brief Invalid constructor \& conversion.
   2.531 -      ///
   2.532 -      /// This constructor initializes the item to be invalid.
   2.533 +      /// Constructor for conversion from \c INVALID.
   2.534 +      /// It initializes the iterator to be invalid.
   2.535        /// \sa Invalid for more details.
   2.536        GraphItemIt(Invalid) {}
   2.537 -      /// \brief Assign operator for items.
   2.538 +
   2.539 +      /// \brief Assignment operator.
   2.540        ///
   2.541 -      /// The items are assignable.
   2.542 +      /// Assignment operator for the iterator.
   2.543 +      GraphItemIt& operator=(const GraphItemIt&) { return *this; }
   2.544 +
   2.545 +      /// \brief Increment the iterator.
   2.546        ///
   2.547 -      GraphItemIt& operator=(const GraphItemIt&) { return *this; }
   2.548 -      /// \brief Next item.
   2.549 -      ///
   2.550 -      /// Assign the iterator to the next item.
   2.551 -      ///
   2.552 +      /// This operator increments the iterator, i.e. assigns it to the
   2.553 +      /// next item.
   2.554        GraphItemIt& operator++() { return *this; }
   2.555 + 
   2.556        /// \brief Equality operator
   2.557        ///
   2.558 +      /// Equality operator.
   2.559        /// Two iterators are equal if and only if they point to the
   2.560        /// same object or both are invalid.
   2.561        bool operator==(const GraphItemIt&) const { return true;}
   2.562 +
   2.563        /// \brief Inequality operator
   2.564        ///
   2.565 -      /// \sa operator==(Node n)
   2.566 -      ///
   2.567 +      /// Inequality operator.
   2.568 +      /// Two iterators are equal if and only if they point to the
   2.569 +      /// same object or both are invalid.
   2.570        bool operator!=(const GraphItemIt&) const { return true;}
   2.571  
   2.572        template<typename _GraphItemIt>
   2.573        struct Constraints {
   2.574          void constraints() {
   2.575 +          checkConcept<GraphItem<>, _GraphItemIt>();
   2.576            _GraphItemIt it1(g);
   2.577            _GraphItemIt it2;
   2.578 +          _GraphItemIt it3 = it1;
   2.579 +          _GraphItemIt it4 = INVALID;
   2.580  
   2.581            it2 = ++it1;
   2.582            ++it2 = it1;
   2.583 @@ -481,16 +493,20 @@
   2.584            Item bi = it1;
   2.585            bi = it2;
   2.586          }
   2.587 -        GR& g;
   2.588 +        const GR& g;
   2.589        };
   2.590      };
   2.591  
   2.592 -    /// \brief Skeleton class for graph InArcIt and OutArcIt
   2.593 +    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
   2.594 +    /// \c IncEdgeIt types.
   2.595      ///
   2.596 -    /// \note Because InArcIt and OutArcIt may not inherit from the same
   2.597 -    /// base class, the \c sel is a additional template parameter (selector).
   2.598 -    /// For InArcIt you should instantiate it with character 'i' and for
   2.599 -    /// OutArcIt with 'o'.
   2.600 +    /// This class describes the concept of \c InArcIt, \c OutArcIt 
   2.601 +    /// and \c IncEdgeIt subtypes of digraph and graph types.
   2.602 +    ///
   2.603 +    /// \note Since these iterator classes do not inherit from the same
   2.604 +    /// base class, there is an additional template parameter (selector)
   2.605 +    /// \c sel. For \c InArcIt you should instantiate it with character 
   2.606 +    /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
   2.607      template <typename GR,
   2.608                typename Item = typename GR::Arc,
   2.609                typename Base = typename GR::Node,
   2.610 @@ -499,47 +515,54 @@
   2.611      public:
   2.612        /// \brief Default constructor.
   2.613        ///
   2.614 -      /// @warning The default constructor sets the iterator
   2.615 -      /// to an undefined value.
   2.616 +      /// Default constructor.
   2.617 +      /// \warning The default constructor is not required to set
   2.618 +      /// the iterator to some well-defined value. So you should consider it
   2.619 +      /// as uninitialized.
   2.620        GraphIncIt() {}
   2.621 +
   2.622        /// \brief Copy constructor.
   2.623        ///
   2.624        /// Copy constructor.
   2.625 +      GraphIncIt(const GraphIncIt& it) : Item(it) {}
   2.626 +
   2.627 +      /// \brief Constructor that sets the iterator to the first 
   2.628 +      /// incoming or outgoing arc.
   2.629        ///
   2.630 -      GraphIncIt(GraphIncIt const& gi) : Item(gi) {}
   2.631 -      /// \brief Sets the iterator to the first arc incoming into or outgoing
   2.632 -      /// from the node.
   2.633 +      /// Constructor that sets the iterator to the first arc 
   2.634 +      /// incoming to or outgoing from the given node.
   2.635 +      explicit GraphIncIt(const GR&, const Base&) {}
   2.636 +
   2.637 +      /// \brief Constructor for conversion from \c INVALID.
   2.638        ///
   2.639 -      /// Sets the iterator to the first arc incoming into or outgoing
   2.640 -      /// from the node.
   2.641 -      ///
   2.642 -      explicit GraphIncIt(const GR&, const Base&) {}
   2.643 -      /// \brief Invalid constructor \& conversion.
   2.644 -      ///
   2.645 -      /// This constructor initializes the item to be invalid.
   2.646 +      /// Constructor for conversion from \c INVALID.
   2.647 +      /// It initializes the iterator to be invalid.
   2.648        /// \sa Invalid for more details.
   2.649        GraphIncIt(Invalid) {}
   2.650 -      /// \brief Assign operator for iterators.
   2.651 +
   2.652 +      /// \brief Assignment operator.
   2.653        ///
   2.654 -      /// The iterators are assignable.
   2.655 +      /// Assignment operator for the iterator.
   2.656 +      GraphIncIt& operator=(const GraphIncIt&) { return *this; }
   2.657 +
   2.658 +      /// \brief Increment the iterator.
   2.659        ///
   2.660 -      GraphIncIt& operator=(GraphIncIt const&) { return *this; }
   2.661 -      /// \brief Next item.
   2.662 -      ///
   2.663 -      /// Assign the iterator to the next item.
   2.664 -      ///
   2.665 +      /// This operator increments the iterator, i.e. assigns it to the
   2.666 +      /// next arc incoming to or outgoing from the given node.
   2.667        GraphIncIt& operator++() { return *this; }
   2.668  
   2.669        /// \brief Equality operator
   2.670        ///
   2.671 +      /// Equality operator.
   2.672        /// Two iterators are equal if and only if they point to the
   2.673        /// same object or both are invalid.
   2.674        bool operator==(const GraphIncIt&) const { return true;}
   2.675  
   2.676        /// \brief Inequality operator
   2.677        ///
   2.678 -      /// \sa operator==(Node n)
   2.679 -      ///
   2.680 +      /// Inequality operator.
   2.681 +      /// Two iterators are equal if and only if they point to the
   2.682 +      /// same object or both are invalid.
   2.683        bool operator!=(const GraphIncIt&) const { return true;}
   2.684  
   2.685        template <typename _GraphIncIt>
   2.686 @@ -548,27 +571,25 @@
   2.687            checkConcept<GraphItem<sel>, _GraphIncIt>();
   2.688            _GraphIncIt it1(graph, node);
   2.689            _GraphIncIt it2;
   2.690 +          _GraphIncIt it3 = it1;
   2.691 +          _GraphIncIt it4 = INVALID;
   2.692  
   2.693            it2 = ++it1;
   2.694            ++it2 = it1;
   2.695            ++(++it1);
   2.696            Item e = it1;
   2.697            e = it2;
   2.698 -
   2.699          }
   2.700 -
   2.701 -        Item arc;
   2.702 -        Base node;
   2.703 -        GR graph;
   2.704 -        _GraphIncIt it;
   2.705 +        const Base& node;
   2.706 +        const GR& graph;
   2.707        };
   2.708      };
   2.709  
   2.710 -
   2.711 -    /// \brief An empty iterable digraph class.
   2.712 +    /// \brief Skeleton class for iterable directed graphs.
   2.713      ///
   2.714 -    /// This class provides beside the core digraph features
   2.715 -    /// iterator based iterable interface for the digraph structure.
   2.716 +    /// This class describes the interface of iterable directed
   2.717 +    /// graphs. It extends \ref BaseDigraphComponent with the core
   2.718 +    /// iterable interface.
   2.719      /// This concept is part of the Digraph concept.
   2.720      template <typename BAS = BaseDigraphComponent>
   2.721      class IterableDigraphComponent : public BAS {
   2.722 @@ -583,68 +604,59 @@
   2.723  
   2.724        /// \name Base iteration
   2.725        ///
   2.726 -      /// This interface provides functions for iteration on digraph items
   2.727 +      /// This interface provides functions for iteration on digraph items.
   2.728        ///
   2.729        /// @{
   2.730  
   2.731 -      /// \brief Gives back the first node in the iterating order.
   2.732 +      /// \brief Return the first node.
   2.733        ///
   2.734 -      /// Gives back the first node in the iterating order.
   2.735 -      ///
   2.736 +      /// This function gives back the first node in the iteration order.
   2.737        void first(Node&) const {}
   2.738  
   2.739 -      /// \brief Gives back the next node in the iterating order.
   2.740 +      /// \brief Return the next node.
   2.741        ///
   2.742 -      /// Gives back the next node in the iterating order.
   2.743 -      ///
   2.744 +      /// This function gives back the next node in the iteration order.
   2.745        void next(Node&) const {}
   2.746  
   2.747 -      /// \brief Gives back the first arc in the iterating order.
   2.748 +      /// \brief Return the first arc.
   2.749        ///
   2.750 -      /// Gives back the first arc in the iterating order.
   2.751 -      ///
   2.752 +      /// This function gives back the first arc in the iteration order.
   2.753        void first(Arc&) const {}
   2.754  
   2.755 -      /// \brief Gives back the next arc in the iterating order.
   2.756 +      /// \brief Return the next arc.
   2.757        ///
   2.758 -      /// Gives back the next arc in the iterating order.
   2.759 -      ///
   2.760 +      /// This function gives back the next arc in the iteration order.
   2.761        void next(Arc&) const {}
   2.762  
   2.763 -
   2.764 -      /// \brief Gives back the first of the arcs point to the given
   2.765 -      /// node.
   2.766 +      /// \brief Return the first arc incomming to the given node.
   2.767        ///
   2.768 -      /// Gives back the first of the arcs point to the given node.
   2.769 -      ///
   2.770 +      /// This function gives back the first arc incomming to the
   2.771 +      /// given node.
   2.772        void firstIn(Arc&, const Node&) const {}
   2.773  
   2.774 -      /// \brief Gives back the next of the arcs points to the given
   2.775 -      /// node.
   2.776 +      /// \brief Return the next arc incomming to the given node.
   2.777        ///
   2.778 -      /// Gives back the next of the arcs points to the given node.
   2.779 -      ///
   2.780 +      /// This function gives back the next arc incomming to the
   2.781 +      /// given node.
   2.782        void nextIn(Arc&) const {}
   2.783  
   2.784 -      /// \brief Gives back the first of the arcs start from the
   2.785 +      /// \brief Return the first arc outgoing form the given node.
   2.786 +      ///
   2.787 +      /// This function gives back the first arc outgoing form the
   2.788        /// given node.
   2.789 -      ///
   2.790 -      /// Gives back the first of the arcs start from the given node.
   2.791 -      ///
   2.792        void firstOut(Arc&, const Node&) const {}
   2.793  
   2.794 -      /// \brief Gives back the next of the arcs start from the given
   2.795 -      /// node.
   2.796 +      /// \brief Return the next arc outgoing form the given node.
   2.797        ///
   2.798 -      /// Gives back the next of the arcs start from the given node.
   2.799 -      ///
   2.800 +      /// This function gives back the next arc outgoing form the
   2.801 +      /// given node.
   2.802        void nextOut(Arc&) const {}
   2.803  
   2.804        /// @}
   2.805  
   2.806        /// \name Class based iteration
   2.807        ///
   2.808 -      /// This interface provides functions for iteration on digraph items
   2.809 +      /// This interface provides iterator classes for digraph items.
   2.810        ///
   2.811        /// @{
   2.812  
   2.813 @@ -654,15 +666,15 @@
   2.814        ///
   2.815        typedef GraphItemIt<Digraph, Node> NodeIt;
   2.816  
   2.817 -      /// \brief This iterator goes through each node.
   2.818 +      /// \brief This iterator goes through each arc.
   2.819        ///
   2.820 -      /// This iterator goes through each node.
   2.821 +      /// This iterator goes through each arc.
   2.822        ///
   2.823        typedef GraphItemIt<Digraph, Arc> ArcIt;
   2.824  
   2.825        /// \brief This iterator goes trough the incoming arcs of a node.
   2.826        ///
   2.827 -      /// This iterator goes trough the \e inccoming arcs of a certain node
   2.828 +      /// This iterator goes trough the \e incoming arcs of a certain node
   2.829        /// of a digraph.
   2.830        typedef GraphIncIt<Digraph, Arc, Node, 'i'> InArcIt;
   2.831  
   2.832 @@ -674,26 +686,26 @@
   2.833  
   2.834        /// \brief The base node of the iterator.
   2.835        ///
   2.836 -      /// Gives back the base node of the iterator.
   2.837 -      /// It is always the target of the pointed arc.
   2.838 +      /// This function gives back the base node of the iterator.
   2.839 +      /// It is always the target node of the pointed arc.
   2.840        Node baseNode(const InArcIt&) const { return INVALID; }
   2.841  
   2.842        /// \brief The running node of the iterator.
   2.843        ///
   2.844 -      /// Gives back the running node of the iterator.
   2.845 -      /// It is always the source of the pointed arc.
   2.846 +      /// This function gives back the running node of the iterator.
   2.847 +      /// It is always the source node of the pointed arc.
   2.848        Node runningNode(const InArcIt&) const { return INVALID; }
   2.849  
   2.850        /// \brief The base node of the iterator.
   2.851        ///
   2.852 -      /// Gives back the base node of the iterator.
   2.853 -      /// It is always the source of the pointed arc.
   2.854 +      /// This function gives back the base node of the iterator.
   2.855 +      /// It is always the source node of the pointed arc.
   2.856        Node baseNode(const OutArcIt&) const { return INVALID; }
   2.857  
   2.858        /// \brief The running node of the iterator.
   2.859        ///
   2.860 -      /// Gives back the running node of the iterator.
   2.861 -      /// It is always the target of the pointed arc.
   2.862 +      /// This function gives back the running node of the iterator.
   2.863 +      /// It is always the target node of the pointed arc.
   2.864        Node runningNode(const OutArcIt&) const { return INVALID; }
   2.865  
   2.866        /// @}
   2.867 @@ -735,25 +747,25 @@
   2.868                typename _Digraph::Node, 'o'>, typename _Digraph::OutArcIt>();
   2.869  
   2.870              typename _Digraph::Node n;
   2.871 -            typename _Digraph::InArcIt ieit(INVALID);
   2.872 -            typename _Digraph::OutArcIt oeit(INVALID);
   2.873 -            n = digraph.baseNode(ieit);
   2.874 -            n = digraph.runningNode(ieit);
   2.875 -            n = digraph.baseNode(oeit);
   2.876 -            n = digraph.runningNode(oeit);
   2.877 +            const typename _Digraph::InArcIt iait(INVALID);
   2.878 +            const typename _Digraph::OutArcIt oait(INVALID);
   2.879 +            n = digraph.baseNode(iait);
   2.880 +            n = digraph.runningNode(iait);
   2.881 +            n = digraph.baseNode(oait);
   2.882 +            n = digraph.runningNode(oait);
   2.883              ignore_unused_variable_warning(n);
   2.884            }
   2.885          }
   2.886  
   2.887          const _Digraph& digraph;
   2.888 -
   2.889        };
   2.890      };
   2.891  
   2.892 -    /// \brief An empty iterable undirected graph class.
   2.893 +    /// \brief Skeleton class for iterable undirected graphs.
   2.894      ///
   2.895 -    /// This class provides beside the core graph features iterator
   2.896 -    /// based iterable interface for the undirected graph structure.
   2.897 +    /// This class describes the interface of iterable undirected
   2.898 +    /// graphs. It extends \ref IterableDigraphComponent with the core
   2.899 +    /// iterable interface of undirected graphs.
   2.900      /// This concept is part of the Graph concept.
   2.901      template <typename BAS = BaseGraphComponent>
   2.902      class IterableGraphComponent : public IterableDigraphComponent<BAS> {
   2.903 @@ -769,42 +781,36 @@
   2.904  
   2.905        /// \name Base iteration
   2.906        ///
   2.907 -      /// This interface provides functions for iteration on graph items
   2.908 +      /// This interface provides functions for iteration on edges.
   2.909 +      ///
   2.910        /// @{
   2.911  
   2.912        using IterableDigraphComponent<Base>::first;
   2.913        using IterableDigraphComponent<Base>::next;
   2.914  
   2.915 -      /// \brief Gives back the first edge in the iterating
   2.916 -      /// order.
   2.917 +      /// \brief Return the first edge.
   2.918        ///
   2.919 -      /// Gives back the first edge in the iterating order.
   2.920 -      ///
   2.921 +      /// This function gives back the first edge in the iteration order.
   2.922        void first(Edge&) const {}
   2.923  
   2.924 -      /// \brief Gives back the next edge in the iterating
   2.925 -      /// order.
   2.926 +      /// \brief Return the next edge.
   2.927        ///
   2.928 -      /// Gives back the next edge in the iterating order.
   2.929 -      ///
   2.930 +      /// This function gives back the next edge in the iteration order.
   2.931        void next(Edge&) const {}
   2.932  
   2.933 -
   2.934 -      /// \brief Gives back the first of the edges from the
   2.935 +      /// \brief Return the first edge incident to the given node.
   2.936 +      ///
   2.937 +      /// This function gives back the first edge incident to the given 
   2.938 +      /// node. The bool parameter gives back the direction for which the
   2.939 +      /// source node of the directed arc representing the edge is the 
   2.940        /// given node.
   2.941 -      ///
   2.942 -      /// Gives back the first of the edges from the given
   2.943 -      /// node. The bool parameter gives back that direction which
   2.944 -      /// gives a good direction of the edge so the source of the
   2.945 -      /// directed arc is the given node.
   2.946        void firstInc(Edge&, bool&, const Node&) const {}
   2.947  
   2.948        /// \brief Gives back the next of the edges from the
   2.949        /// given node.
   2.950        ///
   2.951 -      /// Gives back the next of the edges from the given
   2.952 -      /// node. The bool parameter should be used as the \c firstInc()
   2.953 -      /// use it.
   2.954 +      /// This function gives back the next edge incident to the given 
   2.955 +      /// node. The bool parameter should be used as \c firstInc() use it.
   2.956        void nextInc(Edge&, bool&) const {}
   2.957  
   2.958        using IterableDigraphComponent<Base>::baseNode;
   2.959 @@ -814,28 +820,30 @@
   2.960  
   2.961        /// \name Class based iteration
   2.962        ///
   2.963 -      /// This interface provides functions for iteration on graph items
   2.964 +      /// This interface provides iterator classes for edges.
   2.965        ///
   2.966        /// @{
   2.967  
   2.968 -      /// \brief This iterator goes through each node.
   2.969 +      /// \brief This iterator goes through each edge.
   2.970        ///
   2.971 -      /// This iterator goes through each node.
   2.972 +      /// This iterator goes through each edge.
   2.973        typedef GraphItemIt<Graph, Edge> EdgeIt;
   2.974 -      /// \brief This iterator goes trough the incident arcs of a
   2.975 +
   2.976 +      /// \brief This iterator goes trough the incident edges of a
   2.977        /// node.
   2.978        ///
   2.979 -      /// This iterator goes trough the incident arcs of a certain
   2.980 +      /// This iterator goes trough the incident edges of a certain
   2.981        /// node of a graph.
   2.982 -      typedef GraphIncIt<Graph, Edge, Node, 'u'> IncEdgeIt;
   2.983 +      typedef GraphIncIt<Graph, Edge, Node, 'e'> IncEdgeIt;
   2.984 +
   2.985        /// \brief The base node of the iterator.
   2.986        ///
   2.987 -      /// Gives back the base node of the iterator.
   2.988 +      /// This function gives back the base node of the iterator.
   2.989        Node baseNode(const IncEdgeIt&) const { return INVALID; }
   2.990  
   2.991        /// \brief The running node of the iterator.
   2.992        ///
   2.993 -      /// Gives back the running node of the iterator.
   2.994 +      /// This function gives back the running node of the iterator.
   2.995        Node runningNode(const IncEdgeIt&) const { return INVALID; }
   2.996  
   2.997        /// @}
   2.998 @@ -864,12 +872,12 @@
   2.999              checkConcept<GraphItemIt<_Graph, typename _Graph::Edge>,
  2.1000                typename _Graph::EdgeIt >();
  2.1001              checkConcept<GraphIncIt<_Graph, typename _Graph::Edge,
  2.1002 -              typename _Graph::Node, 'u'>, typename _Graph::IncEdgeIt>();
  2.1003 +              typename _Graph::Node, 'e'>, typename _Graph::IncEdgeIt>();
  2.1004  
  2.1005              typename _Graph::Node n;
  2.1006 -            typename _Graph::IncEdgeIt ueit(INVALID);
  2.1007 -            n = graph.baseNode(ueit);
  2.1008 -            n = graph.runningNode(ueit);
  2.1009 +            const typename _Graph::IncEdgeIt ieit(INVALID);
  2.1010 +            n = graph.baseNode(ieit);
  2.1011 +            n = graph.runningNode(ieit);
  2.1012            }
  2.1013          }
  2.1014  
  2.1015 @@ -877,13 +885,14 @@
  2.1016        };
  2.1017      };
  2.1018  
  2.1019 -    /// \brief An empty alteration notifier digraph class.
  2.1020 +    /// \brief Skeleton class for alterable directed graphs.
  2.1021      ///
  2.1022 -    /// This class provides beside the core digraph features alteration
  2.1023 -    /// notifier interface for the digraph structure.  This implements
  2.1024 +    /// This class describes the interface of alterable directed
  2.1025 +    /// graphs. It extends \ref BaseDigraphComponent with the alteration
  2.1026 +    /// notifier interface. It implements
  2.1027      /// an observer-notifier pattern for each digraph item. More
  2.1028      /// obsevers can be registered into the notifier and whenever an
  2.1029 -    /// alteration occured in the digraph all the observers will
  2.1030 +    /// alteration occured in the digraph all the observers will be
  2.1031      /// notified about it.
  2.1032      template <typename BAS = BaseDigraphComponent>
  2.1033      class AlterableDigraphComponent : public BAS {
  2.1034 @@ -894,23 +903,23 @@
  2.1035        typedef typename Base::Arc Arc;
  2.1036  
  2.1037  
  2.1038 -      /// The node observer registry.
  2.1039 +      /// Node alteration notifier class.
  2.1040        typedef AlterationNotifier<AlterableDigraphComponent, Node>
  2.1041        NodeNotifier;
  2.1042 -      /// The arc observer registry.
  2.1043 +      /// Arc alteration notifier class.
  2.1044        typedef AlterationNotifier<AlterableDigraphComponent, Arc>
  2.1045        ArcNotifier;
  2.1046  
  2.1047 -      /// \brief Gives back the node alteration notifier.
  2.1048 +      /// \brief Return the node alteration notifier.
  2.1049        ///
  2.1050 -      /// Gives back the node alteration notifier.
  2.1051 +      /// This function gives back the node alteration notifier.
  2.1052        NodeNotifier& notifier(Node) const {
  2.1053 -        return NodeNotifier();
  2.1054 +         return NodeNotifier();
  2.1055        }
  2.1056  
  2.1057 -      /// \brief Gives back the arc alteration notifier.
  2.1058 +      /// \brief Return the arc alteration notifier.
  2.1059        ///
  2.1060 -      /// Gives back the arc alteration notifier.
  2.1061 +      /// This function gives back the arc alteration notifier.
  2.1062        ArcNotifier& notifier(Arc) const {
  2.1063          return ArcNotifier();
  2.1064        }
  2.1065 @@ -930,18 +939,17 @@
  2.1066          }
  2.1067  
  2.1068          const _Digraph& digraph;
  2.1069 -
  2.1070        };
  2.1071 -
  2.1072      };
  2.1073  
  2.1074 -    /// \brief An empty alteration notifier undirected graph class.
  2.1075 +    /// \brief Skeleton class for alterable undirected graphs.
  2.1076      ///
  2.1077 -    /// This class provides beside the core graph features alteration
  2.1078 -    /// notifier interface for the graph structure.  This implements
  2.1079 -    /// an observer-notifier pattern for each graph item. More
  2.1080 +    /// This class describes the interface of alterable undirected
  2.1081 +    /// graphs. It extends \ref AlterableDigraphComponent with the alteration
  2.1082 +    /// notifier interface of undirected graphs. It implements
  2.1083 +    /// an observer-notifier pattern for the edges. More
  2.1084      /// obsevers can be registered into the notifier and whenever an
  2.1085 -    /// alteration occured in the graph all the observers will
  2.1086 +    /// alteration occured in the graph all the observers will be
  2.1087      /// notified about it.
  2.1088      template <typename BAS = BaseGraphComponent>
  2.1089      class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
  2.1090 @@ -951,13 +959,13 @@
  2.1091        typedef typename Base::Edge Edge;
  2.1092  
  2.1093  
  2.1094 -      /// The arc observer registry.
  2.1095 +      /// Edge alteration notifier class.
  2.1096        typedef AlterationNotifier<AlterableGraphComponent, Edge>
  2.1097        EdgeNotifier;
  2.1098  
  2.1099 -      /// \brief Gives back the arc alteration notifier.
  2.1100 +      /// \brief Return the edge alteration notifier.
  2.1101        ///
  2.1102 -      /// Gives back the arc alteration notifier.
  2.1103 +      /// This function gives back the edge alteration notifier.
  2.1104        EdgeNotifier& notifier(Edge) const {
  2.1105          return EdgeNotifier();
  2.1106        }
  2.1107 @@ -965,7 +973,7 @@
  2.1108        template <typename _Graph>
  2.1109        struct Constraints {
  2.1110          void constraints() {
  2.1111 -          checkConcept<AlterableGraphComponent<Base>, _Graph>();
  2.1112 +          checkConcept<AlterableDigraphComponent<Base>, _Graph>();
  2.1113            typename _Graph::EdgeNotifier& uen
  2.1114              = graph.notifier(typename _Graph::Edge());
  2.1115            ignore_unused_variable_warning(uen);
  2.1116 @@ -975,11 +983,11 @@
  2.1117        };
  2.1118      };
  2.1119  
  2.1120 -    /// \brief Class describing the concept of graph maps
  2.1121 +    /// \brief Concept class for standard graph maps.
  2.1122      ///
  2.1123 -    /// This class describes the common interface of the graph maps
  2.1124 -    /// (NodeMap, ArcMap), that is maps that can be used to
  2.1125 -    /// associate data to graph descriptors (nodes or arcs).
  2.1126 +    /// This class describes the concept of standard graph maps, i.e.
  2.1127 +    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
  2.1128 +    /// graph types, which can be used for associating data to graph items.
  2.1129      template <typename GR, typename K, typename V>
  2.1130      class GraphMap : public ReadWriteMap<K, V> {
  2.1131      public:
  2.1132 @@ -999,7 +1007,7 @@
  2.1133        explicit GraphMap(const Graph&) {}
  2.1134        /// \brief Construct a new map with default value.
  2.1135        ///
  2.1136 -      /// Construct a new map for the graph and initalise the values.
  2.1137 +      /// Construct a new map for the graph and initalize the values.
  2.1138        GraphMap(const Graph&, const Value&) {}
  2.1139  
  2.1140      private:
  2.1141 @@ -1008,9 +1016,9 @@
  2.1142        /// Copy Constructor.
  2.1143        GraphMap(const GraphMap&) : Parent() {}
  2.1144  
  2.1145 -      /// \brief Assign operator.
  2.1146 +      /// \brief Assignment operator.
  2.1147        ///
  2.1148 -      /// Assign operator. It does not mofify the underlying graph,
  2.1149 +      /// Assignment operator. It does not mofify the underlying graph,
  2.1150        /// it just iterates on the current item set and set the  map
  2.1151        /// with the value returned by the assigned map.
  2.1152        template <typename CMap>
  2.1153 @@ -1024,32 +1032,33 @@
  2.1154        struct Constraints {
  2.1155          void constraints() {
  2.1156            checkConcept<ReadWriteMap<Key, Value>, _Map >();
  2.1157 -          // Construction with a graph parameter
  2.1158 -          _Map a(g);
  2.1159 -          // Constructor with a graph and a default value parameter
  2.1160 -          _Map a2(g,t);
  2.1161 -          // Copy constructor.
  2.1162 -          // _Map b(c);
  2.1163 +          _Map m1(g);
  2.1164 +          _Map m2(g,t);
  2.1165 +          
  2.1166 +          // Copy constructor
  2.1167 +          // _Map m3(m);
  2.1168  
  2.1169 +          // Assignment operator
  2.1170            // ReadMap<Key, Value> cmap;
  2.1171 -          // b = cmap;
  2.1172 +          // m3 = cmap;
  2.1173  
  2.1174 -          ignore_unused_variable_warning(a);
  2.1175 -          ignore_unused_variable_warning(a2);
  2.1176 -          // ignore_unused_variable_warning(b);
  2.1177 +          ignore_unused_variable_warning(m1);
  2.1178 +          ignore_unused_variable_warning(m2);
  2.1179 +          // ignore_unused_variable_warning(m3);
  2.1180          }
  2.1181  
  2.1182 -        const _Map &c;
  2.1183 +        const _Map &m;
  2.1184          const Graph &g;
  2.1185          const typename GraphMap::Value &t;
  2.1186        };
  2.1187  
  2.1188      };
  2.1189  
  2.1190 -    /// \brief An empty mappable digraph class.
  2.1191 +    /// \brief Skeleton class for mappable directed graphs.
  2.1192      ///
  2.1193 -    /// This class provides beside the core digraph features
  2.1194 -    /// map interface for the digraph structure.
  2.1195 +    /// This class describes the interface of mappable directed graphs.
  2.1196 +    /// It extends \ref BaseDigraphComponent with the standard digraph 
  2.1197 +    /// map classes, namely \c NodeMap and \c ArcMap.
  2.1198      /// This concept is part of the Digraph concept.
  2.1199      template <typename BAS = BaseDigraphComponent>
  2.1200      class MappableDigraphComponent : public BAS  {
  2.1201 @@ -1061,12 +1070,11 @@
  2.1202  
  2.1203        typedef MappableDigraphComponent Digraph;
  2.1204  
  2.1205 -      /// \brief ReadWrite map of the nodes.
  2.1206 +      /// \brief Standard graph map for the nodes.
  2.1207        ///
  2.1208 -      /// ReadWrite map of the nodes.
  2.1209 -      ///
  2.1210 +      /// Standard graph map for the nodes.
  2.1211        template <typename V>
  2.1212 -      class NodeMap : public GraphMap<Digraph, Node, V> {
  2.1213 +      class NodeMap : public GraphMap<MappableDigraphComponent, Node, V> {
  2.1214        public:
  2.1215          typedef GraphMap<MappableDigraphComponent, Node, V> Parent;
  2.1216  
  2.1217 @@ -1078,7 +1086,7 @@
  2.1218  
  2.1219          /// \brief Construct a new map with default value.
  2.1220          ///
  2.1221 -        /// Construct a new map for the digraph and initalise the values.
  2.1222 +        /// Construct a new map for the digraph and initalize the values.
  2.1223          NodeMap(const MappableDigraphComponent& digraph, const V& value)
  2.1224            : Parent(digraph, value) {}
  2.1225  
  2.1226 @@ -1088,9 +1096,9 @@
  2.1227          /// Copy Constructor.
  2.1228          NodeMap(const NodeMap& nm) : Parent(nm) {}
  2.1229  
  2.1230 -        /// \brief Assign operator.
  2.1231 +        /// \brief Assignment operator.
  2.1232          ///
  2.1233 -        /// Assign operator.
  2.1234 +        /// Assignment operator.
  2.1235          template <typename CMap>
  2.1236          NodeMap& operator=(const CMap&) {
  2.1237            checkConcept<ReadMap<Node, V>, CMap>();
  2.1238 @@ -1099,12 +1107,11 @@
  2.1239  
  2.1240        };
  2.1241  
  2.1242 -      /// \brief ReadWrite map of the arcs.
  2.1243 +      /// \brief Standard graph map for the arcs.
  2.1244        ///
  2.1245 -      /// ReadWrite map of the arcs.
  2.1246 -      ///
  2.1247 +      /// Standard graph map for the arcs.
  2.1248        template <typename V>
  2.1249 -      class ArcMap : public GraphMap<Digraph, Arc, V> {
  2.1250 +      class ArcMap : public GraphMap<MappableDigraphComponent, Arc, V> {
  2.1251        public:
  2.1252          typedef GraphMap<MappableDigraphComponent, Arc, V> Parent;
  2.1253  
  2.1254 @@ -1116,7 +1123,7 @@
  2.1255  
  2.1256          /// \brief Construct a new map with default value.
  2.1257          ///
  2.1258 -        /// Construct a new map for the digraph and initalise the values.
  2.1259 +        /// Construct a new map for the digraph and initalize the values.
  2.1260          ArcMap(const MappableDigraphComponent& digraph, const V& value)
  2.1261            : Parent(digraph, value) {}
  2.1262  
  2.1263 @@ -1126,9 +1133,9 @@
  2.1264          /// Copy Constructor.
  2.1265          ArcMap(const ArcMap& nm) : Parent(nm) {}
  2.1266  
  2.1267 -        /// \brief Assign operator.
  2.1268 +        /// \brief Assignment operator.
  2.1269          ///
  2.1270 -        /// Assign operator.
  2.1271 +        /// Assignment operator.
  2.1272          template <typename CMap>
  2.1273          ArcMap& operator=(const CMap&) {
  2.1274            checkConcept<ReadMap<Arc, V>, CMap>();
  2.1275 @@ -1178,14 +1185,15 @@
  2.1276            }
  2.1277          }
  2.1278  
  2.1279 -        _Digraph& digraph;
  2.1280 +        const _Digraph& digraph;
  2.1281        };
  2.1282      };
  2.1283  
  2.1284 -    /// \brief An empty mappable base bipartite graph class.
  2.1285 +    /// \brief Skeleton class for mappable undirected graphs.
  2.1286      ///
  2.1287 -    /// This class provides beside the core graph features
  2.1288 -    /// map interface for the graph structure.
  2.1289 +    /// This class describes the interface of mappable undirected graphs.
  2.1290 +    /// It extends \ref MappableDigraphComponent with the standard graph 
  2.1291 +    /// map class for edges (\c EdgeMap).
  2.1292      /// This concept is part of the Graph concept.
  2.1293      template <typename BAS = BaseGraphComponent>
  2.1294      class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
  2.1295 @@ -1196,12 +1204,11 @@
  2.1296  
  2.1297        typedef MappableGraphComponent Graph;
  2.1298  
  2.1299 -      /// \brief ReadWrite map of the edges.
  2.1300 +      /// \brief Standard graph map for the edges.
  2.1301        ///
  2.1302 -      /// ReadWrite map of the edges.
  2.1303 -      ///
  2.1304 +      /// Standard graph map for the edges.
  2.1305        template <typename V>
  2.1306 -      class EdgeMap : public GraphMap<Graph, Edge, V> {
  2.1307 +      class EdgeMap : public GraphMap<MappableGraphComponent, Edge, V> {
  2.1308        public:
  2.1309          typedef GraphMap<MappableGraphComponent, Edge, V> Parent;
  2.1310  
  2.1311 @@ -1213,7 +1220,7 @@
  2.1312  
  2.1313          /// \brief Construct a new map with default value.
  2.1314          ///
  2.1315 -        /// Construct a new map for the graph and initalise the values.
  2.1316 +        /// Construct a new map for the graph and initalize the values.
  2.1317          EdgeMap(const MappableGraphComponent& graph, const V& value)
  2.1318            : Parent(graph, value) {}
  2.1319  
  2.1320 @@ -1223,9 +1230,9 @@
  2.1321          /// Copy Constructor.
  2.1322          EdgeMap(const EdgeMap& nm) : Parent(nm) {}
  2.1323  
  2.1324 -        /// \brief Assign operator.
  2.1325 +        /// \brief Assignment operator.
  2.1326          ///
  2.1327 -        /// Assign operator.
  2.1328 +        /// Assignment operator.
  2.1329          template <typename CMap>
  2.1330          EdgeMap& operator=(const CMap&) {
  2.1331            checkConcept<ReadMap<Edge, V>, CMap>();
  2.1332 @@ -1245,7 +1252,7 @@
  2.1333          };
  2.1334  
  2.1335          void constraints() {
  2.1336 -          checkConcept<MappableGraphComponent<Base>, _Graph>();
  2.1337 +          checkConcept<MappableDigraphComponent<Base>, _Graph>();
  2.1338  
  2.1339            { // int map test
  2.1340              typedef typename _Graph::template EdgeMap<int> IntEdgeMap;
  2.1341 @@ -1262,16 +1269,16 @@
  2.1342            }
  2.1343          }
  2.1344  
  2.1345 -        _Graph& graph;
  2.1346 +        const _Graph& graph;
  2.1347        };
  2.1348      };
  2.1349  
  2.1350 -    /// \brief An empty extendable digraph class.
  2.1351 +    /// \brief Skeleton class for extendable directed graphs.
  2.1352      ///
  2.1353 -    /// This class provides beside the core digraph features digraph
  2.1354 -    /// extendable interface for the digraph structure.  The main
  2.1355 -    /// difference between the base and this interface is that the
  2.1356 -    /// digraph alterations should handled already on this level.
  2.1357 +    /// This class describes the interface of extendable directed graphs.
  2.1358 +    /// It extends \ref BaseDigraphComponent with functions for adding 
  2.1359 +    /// nodes and arcs to the digraph.
  2.1360 +    /// This concept requires \ref AlterableDigraphComponent.
  2.1361      template <typename BAS = BaseDigraphComponent>
  2.1362      class ExtendableDigraphComponent : public BAS {
  2.1363      public:
  2.1364 @@ -1280,17 +1287,17 @@
  2.1365        typedef typename Base::Node Node;
  2.1366        typedef typename Base::Arc Arc;
  2.1367  
  2.1368 -      /// \brief Adds a new node to the digraph.
  2.1369 +      /// \brief Add a new node to the digraph.
  2.1370        ///
  2.1371 -      /// Adds a new node to the digraph.
  2.1372 -      ///
  2.1373 +      /// This function adds a new node to the digraph.
  2.1374        Node addNode() {
  2.1375          return INVALID;
  2.1376        }
  2.1377  
  2.1378 -      /// \brief Adds a new arc connects the given two nodes.
  2.1379 +      /// \brief Add a new arc connecting the given two nodes.
  2.1380        ///
  2.1381 -      /// Adds a new arc connects the the given two nodes.
  2.1382 +      /// This function adds a new arc connecting the given two nodes
  2.1383 +      /// of the digraph.
  2.1384        Arc addArc(const Node&, const Node&) {
  2.1385          return INVALID;
  2.1386        }
  2.1387 @@ -1310,13 +1317,12 @@
  2.1388        };
  2.1389      };
  2.1390  
  2.1391 -    /// \brief An empty extendable base undirected graph class.
  2.1392 +    /// \brief Skeleton class for extendable undirected graphs.
  2.1393      ///
  2.1394 -    /// This class provides beside the core undirected graph features
  2.1395 -    /// core undircted graph extend interface for the graph structure.
  2.1396 -    /// The main difference between the base and this interface is
  2.1397 -    /// that the graph alterations should handled already on this
  2.1398 -    /// level.
  2.1399 +    /// This class describes the interface of extendable undirected graphs.
  2.1400 +    /// It extends \ref BaseGraphComponent with functions for adding 
  2.1401 +    /// nodes and edges to the graph.
  2.1402 +    /// This concept requires \ref AlterableGraphComponent.
  2.1403      template <typename BAS = BaseGraphComponent>
  2.1404      class ExtendableGraphComponent : public BAS {
  2.1405      public:
  2.1406 @@ -1325,18 +1331,18 @@
  2.1407        typedef typename Base::Node Node;
  2.1408        typedef typename Base::Edge Edge;
  2.1409  
  2.1410 -      /// \brief Adds a new node to the graph.
  2.1411 +      /// \brief Add a new node to the digraph.
  2.1412        ///
  2.1413 -      /// Adds a new node to the graph.
  2.1414 -      ///
  2.1415 +      /// This function adds a new node to the digraph.
  2.1416        Node addNode() {
  2.1417          return INVALID;
  2.1418        }
  2.1419  
  2.1420 -      /// \brief Adds a new arc connects the given two nodes.
  2.1421 +      /// \brief Add a new edge connecting the given two nodes.
  2.1422        ///
  2.1423 -      /// Adds a new arc connects the the given two nodes.
  2.1424 -      Edge addArc(const Node&, const Node&) {
  2.1425 +      /// This function adds a new edge connecting the given two nodes
  2.1426 +      /// of the graph.
  2.1427 +      Edge addEdge(const Node&, const Node&) {
  2.1428          return INVALID;
  2.1429        }
  2.1430  
  2.1431 @@ -1355,12 +1361,12 @@
  2.1432        };
  2.1433      };
  2.1434  
  2.1435 -    /// \brief An empty erasable digraph class.
  2.1436 +    /// \brief Skeleton class for erasable directed graphs.
  2.1437      ///
  2.1438 -    /// This class provides beside the core digraph features core erase
  2.1439 -    /// functions for the digraph structure. The main difference between
  2.1440 -    /// the base and this interface is that the digraph alterations
  2.1441 -    /// should handled already on this level.
  2.1442 +    /// This class describes the interface of erasable directed graphs.
  2.1443 +    /// It extends \ref BaseDigraphComponent with functions for removing 
  2.1444 +    /// nodes and arcs from the digraph.
  2.1445 +    /// This concept requires \ref AlterableDigraphComponent.
  2.1446      template <typename BAS = BaseDigraphComponent>
  2.1447      class ErasableDigraphComponent : public BAS {
  2.1448      public:
  2.1449 @@ -1371,23 +1377,22 @@
  2.1450  
  2.1451        /// \brief Erase a node from the digraph.
  2.1452        ///
  2.1453 -      /// Erase a node from the digraph. This function should
  2.1454 -      /// erase all arcs connecting to the node.
  2.1455 +      /// This function erases the given node from the digraph and all arcs 
  2.1456 +      /// connected to the node.
  2.1457        void erase(const Node&) {}
  2.1458  
  2.1459        /// \brief Erase an arc from the digraph.
  2.1460        ///
  2.1461 -      /// Erase an arc from the digraph.
  2.1462 -      ///
  2.1463 +      /// This function erases the given arc from the digraph.
  2.1464        void erase(const Arc&) {}
  2.1465  
  2.1466        template <typename _Digraph>
  2.1467        struct Constraints {
  2.1468          void constraints() {
  2.1469            checkConcept<Base, _Digraph>();
  2.1470 -          typename _Digraph::Node node;
  2.1471 +          const typename _Digraph::Node node(INVALID);
  2.1472            digraph.erase(node);
  2.1473 -          typename _Digraph::Arc arc;
  2.1474 +          const typename _Digraph::Arc arc(INVALID);
  2.1475            digraph.erase(arc);
  2.1476          }
  2.1477  
  2.1478 @@ -1395,12 +1400,12 @@
  2.1479        };
  2.1480      };
  2.1481  
  2.1482 -    /// \brief An empty erasable base undirected graph class.
  2.1483 +    /// \brief Skeleton class for erasable undirected graphs.
  2.1484      ///
  2.1485 -    /// This class provides beside the core undirected graph features
  2.1486 -    /// core erase functions for the undirceted graph structure. The
  2.1487 -    /// main difference between the base and this interface is that
  2.1488 -    /// the graph alterations should handled already on this level.
  2.1489 +    /// This class describes the interface of erasable undirected graphs.
  2.1490 +    /// It extends \ref BaseGraphComponent with functions for removing 
  2.1491 +    /// nodes and edges from the graph.
  2.1492 +    /// This concept requires \ref AlterableGraphComponent.
  2.1493      template <typename BAS = BaseGraphComponent>
  2.1494      class ErasableGraphComponent : public BAS {
  2.1495      public:
  2.1496 @@ -1411,23 +1416,22 @@
  2.1497  
  2.1498        /// \brief Erase a node from the graph.
  2.1499        ///
  2.1500 -      /// Erase a node from the graph. This function should erase
  2.1501 -      /// arcs connecting to the node.
  2.1502 +      /// This function erases the given node from the graph and all edges
  2.1503 +      /// connected to the node.
  2.1504        void erase(const Node&) {}
  2.1505  
  2.1506 -      /// \brief Erase an arc from the graph.
  2.1507 +      /// \brief Erase an edge from the digraph.
  2.1508        ///
  2.1509 -      /// Erase an arc from the graph.
  2.1510 -      ///
  2.1511 +      /// This function erases the given edge from the digraph.
  2.1512        void erase(const Edge&) {}
  2.1513  
  2.1514        template <typename _Graph>
  2.1515        struct Constraints {
  2.1516          void constraints() {
  2.1517            checkConcept<Base, _Graph>();
  2.1518 -          typename _Graph::Node node;
  2.1519 +          const typename _Graph::Node node(INVALID);
  2.1520            graph.erase(node);
  2.1521 -          typename _Graph::Edge edge;
  2.1522 +          const typename _Graph::Edge edge(INVALID);
  2.1523            graph.erase(edge);
  2.1524          }
  2.1525  
  2.1526 @@ -1435,12 +1439,12 @@
  2.1527        };
  2.1528      };
  2.1529  
  2.1530 -    /// \brief An empty clearable base digraph class.
  2.1531 +    /// \brief Skeleton class for clearable directed graphs.
  2.1532      ///
  2.1533 -    /// This class provides beside the core digraph features core clear
  2.1534 -    /// functions for the digraph structure. The main difference between
  2.1535 -    /// the base and this interface is that the digraph alterations
  2.1536 -    /// should handled already on this level.
  2.1537 +    /// This class describes the interface of clearable directed graphs.
  2.1538 +    /// It extends \ref BaseDigraphComponent with a function for clearing
  2.1539 +    /// the digraph.
  2.1540 +    /// This concept requires \ref AlterableDigraphComponent.
  2.1541      template <typename BAS = BaseDigraphComponent>
  2.1542      class ClearableDigraphComponent : public BAS {
  2.1543      public:
  2.1544 @@ -1449,8 +1453,7 @@
  2.1545  
  2.1546        /// \brief Erase all nodes and arcs from the digraph.
  2.1547        ///
  2.1548 -      /// Erase all nodes and arcs from the digraph.
  2.1549 -      ///
  2.1550 +      /// This function erases all nodes and arcs from the digraph.
  2.1551        void clear() {}
  2.1552  
  2.1553        template <typename _Digraph>
  2.1554 @@ -1460,29 +1463,35 @@
  2.1555            digraph.clear();
  2.1556          }
  2.1557  
  2.1558 -        _Digraph digraph;
  2.1559 +        _Digraph& digraph;
  2.1560        };
  2.1561      };
  2.1562  
  2.1563 -    /// \brief An empty clearable base undirected graph class.
  2.1564 +    /// \brief Skeleton class for clearable undirected graphs.
  2.1565      ///
  2.1566 -    /// This class provides beside the core undirected graph features
  2.1567 -    /// core clear functions for the undirected graph structure. The
  2.1568 -    /// main difference between the base and this interface is that
  2.1569 -    /// the graph alterations should handled already on this level.
  2.1570 +    /// This class describes the interface of clearable undirected graphs.
  2.1571 +    /// It extends \ref BaseGraphComponent with a function for clearing
  2.1572 +    /// the graph.
  2.1573 +    /// This concept requires \ref AlterableGraphComponent.
  2.1574      template <typename BAS = BaseGraphComponent>
  2.1575      class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
  2.1576      public:
  2.1577  
  2.1578        typedef BAS Base;
  2.1579  
  2.1580 +      /// \brief Erase all nodes and edges from the graph.
  2.1581 +      ///
  2.1582 +      /// This function erases all nodes and edges from the graph.
  2.1583 +      void clear() {}
  2.1584 +
  2.1585        template <typename _Graph>
  2.1586        struct Constraints {
  2.1587          void constraints() {
  2.1588 -          checkConcept<ClearableGraphComponent<Base>, _Graph>();
  2.1589 +          checkConcept<Base, _Graph>();
  2.1590 +          graph.clear();
  2.1591          }
  2.1592  
  2.1593 -        _Graph graph;
  2.1594 +        _Graph& graph;
  2.1595        };
  2.1596      };
  2.1597