1.1 --- a/lemon/Makefile.am Thu Aug 11 13:07:54 2005 +0000
1.2 +++ b/lemon/Makefile.am Thu Aug 11 13:15:03 2005 +0000
1.3 @@ -74,7 +74,6 @@
1.4 concept/graph.h \
1.5 concept/graph_component.h \
1.6 concept/undir_graph.h \
1.7 - concept/sym_graph.h \
1.8 concept/maps.h \
1.9 concept/heap.h \
1.10 concept/path.h
2.1 --- a/lemon/concept/sym_graph.h Thu Aug 11 13:07:54 2005 +0000
2.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
2.3 @@ -1,653 +0,0 @@
2.4 -/* -*- C++ -*-
2.5 - * lemon/concept/graph.h - Part of LEMON, a generic C++ optimization library
2.6 - *
2.7 - * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
2.8 - * (Egervary Research Group on Combinatorial Optimization, EGRES).
2.9 - *
2.10 - * Permission to use, modify and distribute this software is granted
2.11 - * provided that this copyright notice appears in all copies. For
2.12 - * precise terms see the accompanying LICENSE file.
2.13 - *
2.14 - * This software is provided "AS IS" with no warranty of any kind,
2.15 - * express or implied, and with no claim as to its suitability for any
2.16 - * purpose.
2.17 - *
2.18 - */
2.19 -
2.20 -#ifndef LEMON_CONCEPT_SYM_GRAPH_H
2.21 -#define LEMON_CONCEPT_SYM_GRAPH_H
2.22 -
2.23 -///\ingroup concept
2.24 -///\file
2.25 -///\brief Declaration of SymGraph.
2.26 -
2.27 -#include <lemon/invalid.h>
2.28 -#include <lemon/concept/graph.h>
2.29 -#include <lemon/concept/maps.h>
2.30 -
2.31 -namespace lemon {
2.32 - namespace concept {
2.33 -
2.34 - /// \addtogroup concept
2.35 - /// @{
2.36 -
2.37 - /// An empty static graph class.
2.38 -
2.39 - /// This class provides all the common features of a symmetric
2.40 - /// graph structure, however completely without implementations and
2.41 - /// real data structures behind the interface.
2.42 - /// All graph algorithms should compile with this class, but they will not
2.43 - /// run properly, of course.
2.44 - ///
2.45 - /// It can be used for checking the interface compatibility,
2.46 - /// or it can serve as a skeleton of a new symmetric graph structure.
2.47 - ///
2.48 - /// Also, you will find here the full documentation of graph
2.49 - /// features, the documentation of a real symmetric graph imlementation
2.50 - /// like @ref SymListGraph or
2.51 - /// @ref lemon::SymSmartGraph will just refer to this structure.
2.52 - class StaticSymGraph
2.53 - {
2.54 - public:
2.55 - /// Defalult constructor.
2.56 -
2.57 - /// Default constructor.
2.58 - ///
2.59 - StaticSymGraph() { }
2.60 - // ///Copy consructor.
2.61 -
2.62 -// ///\todo It is not clear, what we expect from a copy constructor.
2.63 -// ///E.g. How to assign the nodes/edges to each other? What about maps?
2.64 -// StaticGraph(const StaticGraph& g) { }
2.65 -
2.66 - /// The base type of node iterators,
2.67 - /// or in other words, the trivial node iterator.
2.68 -
2.69 - /// This is the base type of each node iterator,
2.70 - /// thus each kind of node iterator converts to this.
2.71 - /// More precisely each kind of node iterator should be inherited
2.72 - /// from the trivial node iterator.
2.73 - class Node {
2.74 - public:
2.75 - /// Default constructor
2.76 -
2.77 - /// @warning The default constructor sets the iterator
2.78 - /// to an undefined value.
2.79 - Node() { }
2.80 - /// Copy constructor.
2.81 -
2.82 - /// Copy constructor.
2.83 - ///
2.84 - Node(const Node&) { }
2.85 -
2.86 - /// Invalid constructor \& conversion.
2.87 -
2.88 - /// This constructor initializes the iterator to be invalid.
2.89 - /// \sa Invalid for more details.
2.90 - Node(Invalid) { }
2.91 - /// Equality operator
2.92 -
2.93 - /// Two iterators are equal if and only if they point to the
2.94 - /// same object or both are invalid.
2.95 - bool operator==(Node) const { return true; }
2.96 -
2.97 - /// Inequality operator
2.98 -
2.99 - /// \sa operator==(Node)
2.100 - ///
2.101 - bool operator!=(Node) const { return true; }
2.102 -
2.103 - ///Comparison operator.
2.104 -
2.105 - ///This is a strict ordering between the nodes.
2.106 - ///
2.107 - ///This ordering can be different from the order in which NodeIt
2.108 - ///goes through the nodes.
2.109 - ///\todo Possibly we don't need it.
2.110 - bool operator<(Node) const { return true; }
2.111 - };
2.112 -
2.113 - /// This iterator goes through each node.
2.114 -
2.115 - /// This iterator goes through each node.
2.116 - /// Its usage is quite simple, for example you can count the number
2.117 - /// of nodes in graph \c g of type \c Graph like this:
2.118 - /// \code
2.119 - /// int count=0;
2.120 - /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
2.121 - /// \endcode
2.122 - class NodeIt : public Node {
2.123 - public:
2.124 - /// Default constructor
2.125 -
2.126 - /// @warning The default constructor sets the iterator
2.127 - /// to an undefined value.
2.128 - NodeIt() { }
2.129 - /// Copy constructor.
2.130 -
2.131 - /// Copy constructor.
2.132 - ///
2.133 - NodeIt(const NodeIt&) { }
2.134 - /// Invalid constructor \& conversion.
2.135 -
2.136 - /// Initialize the iterator to be invalid.
2.137 - /// \sa Invalid for more details.
2.138 - NodeIt(Invalid) { }
2.139 - /// Sets the iterator to the first node.
2.140 -
2.141 - /// Sets the iterator to the first node of \c g.
2.142 - ///
2.143 - NodeIt(const StaticSymGraph& g) { }
2.144 - /// Node -> NodeIt conversion.
2.145 -
2.146 - /// Sets the iterator to the node of \c g pointed by the trivial
2.147 - /// iterator \c n.
2.148 - /// This feature necessitates that each time we
2.149 - /// iterate the node-set, the iteration order is the same.
2.150 - NodeIt(const StaticSymGraph& g, const Node& n) { }
2.151 - /// Next node.
2.152 -
2.153 - /// Assign the iterator to the next node.
2.154 - ///
2.155 - NodeIt& operator++() { return *this; }
2.156 - };
2.157 -
2.158 -
2.159 - /// The base type of the symmetric edge iterators.
2.160 -
2.161 - /// The base type of the symmetric edge iterators.
2.162 - ///
2.163 - class SymEdge {
2.164 - public:
2.165 - /// Default constructor
2.166 -
2.167 - /// @warning The default constructor sets the iterator
2.168 - /// to an undefined value.
2.169 - SymEdge() { }
2.170 - /// Copy constructor.
2.171 -
2.172 - /// Copy constructor.
2.173 - ///
2.174 - SymEdge(const SymEdge&) { }
2.175 - /// Initialize the iterator to be invalid.
2.176 -
2.177 - /// Initialize the iterator to be invalid.
2.178 - ///
2.179 - SymEdge(Invalid) { }
2.180 - /// Equality operator
2.181 -
2.182 - /// Two iterators are equal if and only if they point to the
2.183 - /// same object or both are invalid.
2.184 - bool operator==(SymEdge) const { return true; }
2.185 - /// Inequality operator
2.186 -
2.187 - /// \sa operator==(Node n)
2.188 - ///
2.189 - bool operator!=(SymEdge) const { return true; }
2.190 - ///Comparison operator.
2.191 -
2.192 - ///This is a strict ordering between the nodes.
2.193 - ///
2.194 - ///This ordering can be different from the order in which NodeIt
2.195 - ///goes through the nodes.
2.196 - ///\todo Possibly we don't need it.
2.197 - bool operator<(SymEdge) const { return true; }
2.198 - };
2.199 -
2.200 -
2.201 - /// The base type of the edge iterators.
2.202 -
2.203 - /// The base type of the edge iterators.
2.204 - ///
2.205 - class Edge : public SymEdge {
2.206 - public:
2.207 - /// Default constructor
2.208 -
2.209 - /// @warning The default constructor sets the iterator
2.210 - /// to an undefined value.
2.211 - Edge() { }
2.212 - /// Copy constructor.
2.213 -
2.214 - /// Copy constructor.
2.215 - ///
2.216 - Edge(const Edge&) { }
2.217 - /// Initialize the iterator to be invalid.
2.218 -
2.219 - /// Initialize the iterator to be invalid.
2.220 - ///
2.221 - Edge(Invalid) { }
2.222 - /// Equality operator
2.223 -
2.224 - /// Two iterators are equal if and only if they point to the
2.225 - /// same object or both are invalid.
2.226 - bool operator==(Edge) const { return true; }
2.227 - /// Inequality operator
2.228 -
2.229 - /// \sa operator==(Node n)
2.230 - ///
2.231 - bool operator!=(Edge) const { return true; }
2.232 - ///Comparison operator.
2.233 -
2.234 - ///This is a strict ordering between the nodes.
2.235 - ///
2.236 - ///This ordering can be different from the order in which NodeIt
2.237 - ///goes through the nodes.
2.238 - ///\todo Possibly we don't need it.
2.239 - bool operator<(Edge) const { return true; }
2.240 - };
2.241 -
2.242 - /// This iterator goes trough the outgoing edges of a node.
2.243 -
2.244 - /// This iterator goes trough the \e outgoing edges of a certain node
2.245 - /// of a graph.
2.246 - /// Its usage is quite simple, for example you can count the number
2.247 - /// of outgoing edges of a node \c n
2.248 - /// in graph \c g of type \c Graph as follows.
2.249 - /// \code
2.250 - /// int count=0;
2.251 - /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
2.252 - /// \endcode
2.253 -
2.254 - class OutEdgeIt : public Edge {
2.255 - public:
2.256 - /// Default constructor
2.257 -
2.258 - /// @warning The default constructor sets the iterator
2.259 - /// to an undefined value.
2.260 - OutEdgeIt() { }
2.261 - /// Copy constructor.
2.262 -
2.263 - /// Copy constructor.
2.264 - ///
2.265 - OutEdgeIt(const OutEdgeIt&) { }
2.266 - /// Initialize the iterator to be invalid.
2.267 -
2.268 - /// Initialize the iterator to be invalid.
2.269 - ///
2.270 - OutEdgeIt(Invalid) { }
2.271 - /// This constructor sets the iterator to first outgoing edge.
2.272 -
2.273 - /// This constructor sets the iterator to the first outgoing edge of
2.274 - /// the node
2.275 - ///@param n the node
2.276 - ///@param g the graph
2.277 - OutEdgeIt(const StaticSymGraph& g, const Node& n) { }
2.278 - /// Edge -> OutEdgeIt conversion
2.279 -
2.280 - /// Sets the iterator to the value of the trivial iterator \c e.
2.281 - /// This feature necessitates that each time we
2.282 - /// iterate the edge-set, the iteration order is the same.
2.283 - OutEdgeIt(const StaticSymGraph& g, const Edge& e) { }
2.284 - ///Next outgoing edge
2.285 -
2.286 - /// Assign the iterator to the next
2.287 - /// outgoing edge of the corresponding node.
2.288 - OutEdgeIt& operator++() { return *this; }
2.289 - };
2.290 -
2.291 - /// This iterator goes trough the incoming edges of a node.
2.292 -
2.293 - /// This iterator goes trough the \e incoming edges of a certain node
2.294 - /// of a graph.
2.295 - /// Its usage is quite simple, for example you can count the number
2.296 - /// of outgoing edges of a node \c n
2.297 - /// in graph \c g of type \c Graph as follows.
2.298 - /// \code
2.299 - /// int count=0;
2.300 - /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
2.301 - /// \endcode
2.302 -
2.303 - class InEdgeIt : public Edge {
2.304 - public:
2.305 - /// Default constructor
2.306 -
2.307 - /// @warning The default constructor sets the iterator
2.308 - /// to an undefined value.
2.309 - InEdgeIt() { }
2.310 - /// Copy constructor.
2.311 -
2.312 - /// Copy constructor.
2.313 - ///
2.314 - InEdgeIt(const InEdgeIt&) { }
2.315 - /// Initialize the iterator to be invalid.
2.316 -
2.317 - /// Initialize the iterator to be invalid.
2.318 - ///
2.319 - InEdgeIt(Invalid) { }
2.320 - /// This constructor sets the iterator to first incoming edge.
2.321 -
2.322 - /// This constructor sets the iterator to the first incoming edge of
2.323 - /// the node
2.324 - ///@param n the node
2.325 - ///@param g the graph
2.326 - InEdgeIt(const StaticSymGraph& g, const Node& n) { }
2.327 - /// Edge -> InEdgeIt conversion
2.328 -
2.329 - /// Sets the iterator to the value of the trivial iterator \c e.
2.330 - /// This feature necessitates that each time we
2.331 - /// iterate the edge-set, the iteration order is the same.
2.332 - InEdgeIt(const StaticSymGraph& g, const Edge& n) { }
2.333 - /// Next incoming edge
2.334 -
2.335 - /// Assign the iterator to the next inedge of the corresponding node.
2.336 - ///
2.337 - InEdgeIt& operator++() { return *this; }
2.338 - };
2.339 - /// This iterator goes through each symmetric edge.
2.340 -
2.341 - /// This iterator goes through each symmetric edge of a graph.
2.342 - /// Its usage is quite simple, for example you can count the number
2.343 - /// of symmetric edges in a graph \c g of type \c Graph as follows:
2.344 - /// \code
2.345 - /// int count=0;
2.346 - /// for(Graph::SymEdgeIt e(g); e!=INVALID; ++e) ++count;
2.347 - /// \endcode
2.348 - class SymEdgeIt : public SymEdge {
2.349 - public:
2.350 - /// Default constructor
2.351 -
2.352 - /// @warning The default constructor sets the iterator
2.353 - /// to an undefined value.
2.354 - SymEdgeIt() { }
2.355 - /// Copy constructor.
2.356 -
2.357 - /// Copy constructor.
2.358 - ///
2.359 - SymEdgeIt(const SymEdgeIt&) { }
2.360 - /// Initialize the iterator to be invalid.
2.361 -
2.362 - /// Initialize the iterator to be invalid.
2.363 - ///
2.364 - SymEdgeIt(Invalid) { }
2.365 - /// This constructor sets the iterator to first edge.
2.366 -
2.367 - /// This constructor sets the iterator to the first edge of
2.368 - /// the graph
2.369 - ///@param g the graph
2.370 - SymEdgeIt(const StaticSymGraph& g) { }
2.371 - /// Edge -> EdgeIt conversion
2.372 -
2.373 - /// Sets the iterator to the value of the trivial iterator \c e.
2.374 - /// This feature necessitates that each time we
2.375 - /// iterate the edge-set, the iteration order is the same.
2.376 - SymEdgeIt(const StaticSymGraph&, const SymEdge&) { }
2.377 - ///Next edge
2.378 -
2.379 - /// Assign the iterator to the next
2.380 - /// edge of the corresponding node.
2.381 - SymEdgeIt& operator++() { return *this; }
2.382 - };
2.383 - /// This iterator goes through each edge.
2.384 -
2.385 - /// This iterator goes through each edge of a graph.
2.386 - /// Its usage is quite simple, for example you can count the number
2.387 - /// of edges in a graph \c g of type \c Graph as follows:
2.388 - /// \code
2.389 - /// int count=0;
2.390 - /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
2.391 - /// \endcode
2.392 - class EdgeIt : public Edge {
2.393 - public:
2.394 - /// Default constructor
2.395 -
2.396 - /// @warning The default constructor sets the iterator
2.397 - /// to an undefined value.
2.398 - EdgeIt() { }
2.399 - /// Copy constructor.
2.400 -
2.401 - /// Copy constructor.
2.402 - ///
2.403 - EdgeIt(const EdgeIt&) { }
2.404 - /// Initialize the iterator to be invalid.
2.405 -
2.406 - /// Initialize the iterator to be invalid.
2.407 - ///
2.408 - EdgeIt(Invalid) { }
2.409 - /// This constructor sets the iterator to first edge.
2.410 -
2.411 - /// This constructor sets the iterator to the first edge of
2.412 - /// the graph
2.413 - ///@param g the graph
2.414 - EdgeIt(const StaticSymGraph& g) { }
2.415 - /// Edge -> EdgeIt conversion
2.416 -
2.417 - /// Sets the iterator to the value of the trivial iterator \c e.
2.418 - /// This feature necessitates that each time we
2.419 - /// iterate the edge-set, the iteration order is the same.
2.420 - EdgeIt(const StaticSymGraph&, const Edge&) { }
2.421 - ///Next edge
2.422 -
2.423 - /// Assign the iterator to the next
2.424 - /// edge of the corresponding node.
2.425 - EdgeIt& operator++() { return *this; }
2.426 - };
2.427 -
2.428 - /// First node of the graph.
2.429 -
2.430 - /// \retval i the first node.
2.431 - /// \return the first node.
2.432 - ///
2.433 - NodeIt& first(NodeIt& i) const { return i; }
2.434 -
2.435 - /// The first incoming edge.
2.436 -
2.437 - /// The first incoming edge.
2.438 - ///
2.439 - InEdgeIt& first(InEdgeIt &i, Node) const { return i; }
2.440 - /// The first outgoing edge.
2.441 -
2.442 - /// The first outgoing edge.
2.443 - ///
2.444 - OutEdgeIt& first(OutEdgeIt& i, Node) const { return i; }
2.445 - /// The first edge of the Graph.
2.446 -
2.447 - /// The first edge of the Graph.
2.448 - ///
2.449 - EdgeIt& first(EdgeIt& i) const { return i; }
2.450 - /// The first symmetric edge of the Graph.
2.451 -
2.452 - /// The first symmetric edge of the Graph.
2.453 - ///
2.454 - SymEdgeIt& first(SymEdgeIt& i) const { return i; }
2.455 -
2.456 - ///Gives back the target node of an edge.
2.457 -
2.458 - ///Gives back the target node of an edge.
2.459 - ///
2.460 - Node target(Edge) const { return INVALID; }
2.461 - ///Gives back the source node of an edge.
2.462 -
2.463 - ///Gives back the source node of an edge.
2.464 - ///
2.465 - Node source(Edge) const { return INVALID; }
2.466 -
2.467 - ///Gives back the first node of an symmetric edge.
2.468 -
2.469 - ///Gives back the first node of an symmetric edge.
2.470 - ///
2.471 - Node target(SymEdge) const { return INVALID; }
2.472 - ///Gives back the second node of an symmetric edge.
2.473 -
2.474 - ///Gives back the second node of an symmetric edge.
2.475 - ///
2.476 - Node source(SymEdge) const { return INVALID; }
2.477 - ///Gives back the \e id of a node.
2.478 -
2.479 - ///\warning Not all graph structures provide this feature.
2.480 - ///
2.481 - ///\todo Should each graph provide \c id?
2.482 - int id(const Node&) const { return 0; }
2.483 - ///Gives back the \e id of an edge.
2.484 -
2.485 - ///\warning Not all graph structures provide this feature.
2.486 - ///
2.487 - ///\todo Should each graph provide \c id?
2.488 - int id(const Edge&) const { return 0; }
2.489 -
2.490 - ///\warning Not all graph structures provide this feature.
2.491 - ///
2.492 - ///\todo Should each graph provide \c id?
2.493 - int id(const SymEdge&) const { return 0; }
2.494 -
2.495 - ///\e
2.496 -
2.497 - ///\todo Should it be in the concept?
2.498 - ///
2.499 - int nodeNum() const { return 0; }
2.500 - ///\e
2.501 -
2.502 - ///\todo Should it be in the concept?
2.503 - ///
2.504 - int edgeNum() const { return 0; }
2.505 -
2.506 - ///\todo Should it be in the concept?
2.507 - ///
2.508 - int symEdgeNum() const { return 0; }
2.509 -
2.510 -
2.511 - /// Gives back the forward directed edge of the symmetric edge.
2.512 - Edge forward(SymEdge) const {return INVALID;}
2.513 -
2.514 - /// Gives back the backward directed edge of the symmetric edge.
2.515 - Edge backward(SymEdge) const {return INVALID;};
2.516 -
2.517 - /// Gives back the opposite of the edge.
2.518 - Edge opposite(Edge) const {return INVALID;}
2.519 -
2.520 - ///Reference map of the nodes to type \c T.
2.521 - /// \ingroup concept
2.522 - ///Reference map of the nodes to type \c T.
2.523 - /// \sa Reference
2.524 - /// \warning Making maps that can handle bool type (NodeMap<bool>)
2.525 - /// needs some extra attention!
2.526 - template<class T> class NodeMap : public ReferenceMap< Node, T >
2.527 - {
2.528 - public:
2.529 -
2.530 - ///\e
2.531 - NodeMap(const StaticSymGraph&) { }
2.532 - ///\e
2.533 - NodeMap(const StaticSymGraph&, T) { }
2.534 -
2.535 - ///Copy constructor
2.536 - template<typename TT> NodeMap(const NodeMap<TT>&) { }
2.537 - ///Assignment operator
2.538 - template<typename TT> NodeMap& operator=(const NodeMap<TT>&)
2.539 - { return *this; }
2.540 - };
2.541 -
2.542 - ///Reference map of the edges to type \c T.
2.543 -
2.544 - /// \ingroup concept
2.545 - ///Reference map of the edges to type \c T.
2.546 - /// \sa Reference
2.547 - /// \warning Making maps that can handle bool type (EdgeMap<bool>)
2.548 - /// needs some extra attention!
2.549 - template<class T> class EdgeMap
2.550 - : public ReferenceMap<Edge,T>
2.551 - {
2.552 - public:
2.553 -
2.554 - ///\e
2.555 - EdgeMap(const StaticSymGraph&) { }
2.556 - ///\e
2.557 - EdgeMap(const StaticSymGraph&, T) { }
2.558 -
2.559 - ///Copy constructor
2.560 - template<typename TT> EdgeMap(const EdgeMap<TT>&) { }
2.561 - ///Assignment operator
2.562 - template<typename TT> EdgeMap &operator=(const EdgeMap<TT>&)
2.563 - { return *this; }
2.564 - };
2.565 -
2.566 - ///Reference map of the edges to type \c T.
2.567 -
2.568 - /// \ingroup concept
2.569 - ///Reference map of the symmetric edges to type \c T.
2.570 - /// \sa Reference
2.571 - /// \warning Making maps that can handle bool type (EdgeMap<bool>)
2.572 - /// needs some extra attention!
2.573 - template<class T> class SymEdgeMap
2.574 - : public ReferenceMap<SymEdge,T>
2.575 - {
2.576 - public:
2.577 -
2.578 - ///\e
2.579 - SymEdgeMap(const StaticSymGraph&) { }
2.580 - ///\e
2.581 - SymEdgeMap(const StaticSymGraph&, T) { }
2.582 -
2.583 - ///Copy constructor
2.584 - template<typename TT> SymEdgeMap(const SymEdgeMap<TT>&) { }
2.585 - ///Assignment operator
2.586 - template<typename TT> SymEdgeMap &operator=(const SymEdgeMap<TT>&)
2.587 - { return *this; }
2.588 - };
2.589 - };
2.590 -
2.591 -
2.592 -
2.593 - /// An empty non-static graph class.
2.594 -
2.595 - /// This class is an extension of \ref StaticGraph
2.596 - /// with additional functionality that enables one to build a
2.597 - /// graph from scratch.
2.598 - class ExtendableSymGraph : public StaticSymGraph
2.599 - {
2.600 - public:
2.601 - /// Default constructor.
2.602 -
2.603 - /// Default constructor.
2.604 - ///
2.605 - ExtendableSymGraph() { }
2.606 - ///Add a new node to the graph.
2.607 -
2.608 - /// \return the new node.
2.609 - ///
2.610 - Node addNode() { return INVALID; }
2.611 - ///Add a new edge to the graph.
2.612 -
2.613 - ///Add a new symmetric edge to the graph with source node \c t
2.614 - ///and target node \c h.
2.615 - ///\return the new edge.
2.616 - SymEdge addEdge(Node h, Node t) { return INVALID; }
2.617 -
2.618 - /// Resets the graph.
2.619 -
2.620 - /// This function deletes all edges and nodes of the graph.
2.621 - /// It also frees the memory allocated to store them.
2.622 - /// \todo It might belong to \ref ErasableGraph.
2.623 - void clear() { }
2.624 - };
2.625 -
2.626 - /// An empty erasable graph class.
2.627 -
2.628 - /// This class is an extension of \ref ExtendableGraph. It is also
2.629 - /// possible to erase edges or nodes in this graph.
2.630 - class ErasableSymGraph : public ExtendableSymGraph
2.631 - {
2.632 - public:
2.633 - /// Default constructor.
2.634 -
2.635 - /// Default constructor.
2.636 - ///
2.637 - ErasableSymGraph() { }
2.638 - /// Deletes a node.
2.639 -
2.640 - /// Deletes node \c n node.
2.641 - ///
2.642 - void erase(Node n) { }
2.643 - /// Deletes an edge.
2.644 -
2.645 - /// Deletes edge \c e edge.
2.646 - ///
2.647 - void erase(SymEdge e) { }
2.648 - };
2.649 -
2.650 - // @}
2.651 - } //namespace concept
2.652 -} //namespace lemon
2.653 -
2.654 -
2.655 -
2.656 -#endif // LEMON_CONCEPT_GRAPH_H