COIN-OR::LEMON - Graph Library

Changeset 782:853fcddcf282 in lemon for lemon/list_graph.h


Ignore:
Timestamp:
08/23/09 11:09:22 (11 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Doc improvements, fixes and unifications for graphs (#311)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/list_graph.h

    r664 r782  
    2222///\ingroup graphs
    2323///\file
    24 ///\brief ListDigraph, ListGraph classes.
     24///\brief ListDigraph and ListGraph classes.
    2525
    2626#include <lemon/core.h>
     
    312312  ///A general directed graph structure.
    313313
    314   ///\ref ListDigraph is a simple and fast <em>directed graph</em>
    315   ///implementation based on static linked lists that are stored in
     314  ///\ref ListDigraph is a versatile and fast directed graph
     315  ///implementation based on linked lists that are stored in
    316316  ///\c std::vector structures.
    317317  ///
    318   ///It conforms to the \ref concepts::Digraph "Digraph concept" and it
    319   ///also provides several useful additional functionalities.
    320   ///Most of the member functions and nested classes are documented
     318  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
     319  ///and it also provides several useful additional functionalities.
     320  ///Most of its member functions and nested classes are documented
    321321  ///only in the concept class.
    322322  ///
    323323  ///\sa concepts::Digraph
    324 
     324  ///\sa ListGraph
    325325  class ListDigraph : public ExtendedListDigraphBase {
    326326    typedef ExtendedListDigraphBase Parent;
    327327
    328328  private:
    329     ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
    330 
    331     ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
    332     ///
     329    /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
    333330    ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};
    334     ///\brief Assignment of ListDigraph to another one is \e not allowed.
    335     ///Use copyDigraph() instead.
    336 
    337     ///Assignment of ListDigraph to another one is \e not allowed.
    338     ///Use copyDigraph() instead.
     331    /// \brief Assignment of a digraph to another one is \e not allowed.
     332    /// Use DigraphCopy instead.
    339333    void operator=(const ListDigraph &) {}
    340334  public:
     
    348342    ///Add a new node to the digraph.
    349343
    350     ///Add a new node to the digraph.
     344    ///This function adds a new node to the digraph.
    351345    ///\return The new node.
    352346    Node addNode() { return Parent::addNode(); }
     
    354348    ///Add a new arc to the digraph.
    355349
    356     ///Add a new arc to the digraph with source node \c s
     350    ///This function adds a new arc to the digraph with source node \c s
    357351    ///and target node \c t.
    358352    ///\return The new arc.
    359     Arc addArc(const Node& s, const Node& t) {
     353    Arc addArc(Node s, Node t) {
    360354      return Parent::addArc(s, t);
    361355    }
     
    363357    ///\brief Erase a node from the digraph.
    364358    ///
    365     ///Erase a node from the digraph.
    366     ///
    367     void erase(const Node& n) { Parent::erase(n); }
     359    ///This function erases the given node from the digraph.
     360    void erase(Node n) { Parent::erase(n); }
    368361
    369362    ///\brief Erase an arc from the digraph.
    370363    ///
    371     ///Erase an arc from the digraph.
    372     ///
    373     void erase(const Arc& a) { Parent::erase(a); }
     364    ///This function erases the given arc from the digraph.
     365    void erase(Arc a) { Parent::erase(a); }
    374366
    375367    /// Node validity check
    376368
    377     /// This function gives back true if the given node is valid,
    378     /// ie. it is a real node of the graph.
    379     ///
    380     /// \warning A Node pointing to a removed item
    381     /// could become valid again later if new nodes are
    382     /// added to the graph.
     369    /// This function gives back \c true if the given node is valid,
     370    /// i.e. it is a real node of the digraph.
     371    ///
     372    /// \warning A removed node could become valid again if new nodes are
     373    /// added to the digraph.
    383374    bool valid(Node n) const { return Parent::valid(n); }
    384375
    385376    /// Arc validity check
    386377
    387     /// This function gives back true if the given arc is valid,
    388     /// ie. it is a real arc of the graph.
    389     ///
    390     /// \warning An Arc pointing to a removed item
    391     /// could become valid again later if new nodes are
    392     /// added to the graph.
     378    /// This function gives back \c true if the given arc is valid,
     379    /// i.e. it is a real arc of the digraph.
     380    ///
     381    /// \warning A removed arc could become valid again if new arcs are
     382    /// added to the digraph.
    393383    bool valid(Arc a) const { return Parent::valid(a); }
    394384
    395     /// Change the target of \c a to \c n
    396 
    397     /// Change the target of \c a to \c n
    398     ///
    399     ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
    400     ///the changed arc remain valid. However <tt>InArcIt</tt>s are
    401     ///invalidated.
     385    /// Change the target node of an arc
     386
     387    /// This function changes the target node of the given arc \c a to \c n.
     388    ///
     389    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
     390    ///arc remain valid, however \c InArcIt iterators are invalidated.
    402391    ///
    403392    ///\warning This functionality cannot be used together with the Snapshot
     
    406395      Parent::changeTarget(a,n);
    407396    }
    408     /// Change the source of \c a to \c n
    409 
    410     /// Change the source of \c a to \c n
    411     ///
    412     ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
    413     ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
    414     ///invalidated.
     397    /// Change the source node of an arc
     398
     399    /// This function changes the source node of the given arc \c a to \c n.
     400    ///
     401    ///\note \c InArcIt iterators referencing the changed arc remain
     402    ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
    415403    ///
    416404    ///\warning This functionality cannot be used together with the Snapshot
     
    420408    }
    421409
    422     /// Invert the direction of an arc.
    423 
    424     ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
    425     ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
    426     ///invalidated.
     410    /// Reverse the direction of an arc.
     411
     412    /// This function reverses the direction of the given arc.
     413    ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing
     414    ///the changed arc are invalidated.
    427415    ///
    428416    ///\warning This functionality cannot be used together with the Snapshot
    429417    ///feature.
    430     void reverseArc(Arc e) {
    431       Node t=target(e);
    432       changeTarget(e,source(e));
    433       changeSource(e,t);
    434     }
    435 
    436     /// Reserve memory for nodes.
    437 
    438     /// Using this function it is possible to avoid the superfluous memory
    439     /// allocation: if you know that the digraph you want to build will
    440     /// be very large (e.g. it will contain millions of nodes and/or arcs)
    441     /// then it is worth reserving space for this amount before starting
    442     /// to build the digraph.
    443     /// \sa reserveArc
    444     void reserveNode(int n) { nodes.reserve(n); };
    445 
    446     /// Reserve memory for arcs.
    447 
    448     /// Using this function it is possible to avoid the superfluous memory
    449     /// allocation: if you know that the digraph you want to build will
    450     /// be very large (e.g. it will contain millions of nodes and/or arcs)
    451     /// then it is worth reserving space for this amount before starting
    452     /// to build the digraph.
    453     /// \sa reserveNode
    454     void reserveArc(int m) { arcs.reserve(m); };
     418    void reverseArc(Arc a) {
     419      Node t=target(a);
     420      changeTarget(a,source(a));
     421      changeSource(a,t);
     422    }
    455423
    456424    ///Contract two nodes.
    457425
    458     ///This function contracts two nodes.
    459     ///Node \p b will be removed but instead of deleting
    460     ///incident arcs, they will be joined to \p a.
    461     ///The last parameter \p r controls whether to remove loops. \c true
    462     ///means that loops will be removed.
    463     ///
    464     ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
    465     ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s
    466     ///may be invalidated.
     426    ///This function contracts the given two nodes.
     427    ///Node \c v is removed, but instead of deleting its
     428    ///incident arcs, they are joined to node \c u.
     429    ///If the last parameter \c r is \c true (this is the default value),
     430    ///then the newly created loops are removed.
     431    ///
     432    ///\note The moved arcs are joined to node \c u using changeSource()
     433    ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
     434    ///invalidated for the outgoing arcs of node \c v and \c InArcIt
     435    ///iterators are invalidated for the incomming arcs of \c v.
     436    ///Moreover all iterators referencing node \c v or the removed
     437    ///loops are also invalidated. Other iterators remain valid.
    467438    ///
    468439    ///\warning This functionality cannot be used together with the Snapshot
    469440    ///feature.
    470     void contract(Node a, Node b, bool r = true)
     441    void contract(Node u, Node v, bool r = true)
    471442    {
    472       for(OutArcIt e(*this,b);e!=INVALID;) {
     443      for(OutArcIt e(*this,v);e!=INVALID;) {
    473444        OutArcIt f=e;
    474445        ++f;
    475         if(r && target(e)==a) erase(e);
    476         else changeSource(e,a);
     446        if(r && target(e)==u) erase(e);
     447        else changeSource(e,u);
    477448        e=f;
    478449      }
    479       for(InArcIt e(*this,b);e!=INVALID;) {
     450      for(InArcIt e(*this,v);e!=INVALID;) {
    480451        InArcIt f=e;
    481452        ++f;
    482         if(r && source(e)==a) erase(e);
    483         else changeTarget(e,a);
     453        if(r && source(e)==u) erase(e);
     454        else changeTarget(e,u);
    484455        e=f;
    485456      }
    486       erase(b);
     457      erase(v);
    487458    }
    488459
    489460    ///Split a node.
    490461
    491     ///This function splits a node. First a new node is added to the digraph,
    492     ///then the source of each outgoing arc of \c n is moved to this new node.
    493     ///If \c connect is \c true (this is the default value), then a new arc
    494     ///from \c n to the newly created node is also added.
     462    ///This function splits the given node. First, a new node is added
     463    ///to the digraph, then the source of each outgoing arc of node \c n
     464    ///is moved to this new node.
     465    ///If the second parameter \c connect is \c true (this is the default
     466    ///value), then a new arc from node \c n to the newly created node
     467    ///is also added.
    495468    ///\return The newly created node.
    496469    ///
    497     ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
    498     ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may
    499     ///be invalidated.
    500     ///
    501     ///\warning This functionality cannot be used in conjunction with the
     470    ///\note \c ArcIt and \c OutArcIt iterators referencing the outgoing
     471    ///arcs of node \c n are invalidated. Other iterators remain valid.
     472    ///
     473    ///\warning This functionality cannot be used together with the
    502474    ///Snapshot feature.
    503475    Node split(Node n, bool connect = true) {
     
    515487    ///Split an arc.
    516488
    517     ///This function splits an arc. First a new node \c b is added to
    518     ///the digraph, then the original arc is re-targeted to \c
    519     ///b. Finally an arc from \c b to the original target is added.
    520     ///
     489    ///This function splits the given arc. First, a new node \c v is
     490    ///added to the digraph, then the target node of the original arc
     491    ///is set to \c v. Finally, an arc from \c v to the original target
     492    ///is added.
    521493    ///\return The newly created node.
     494    ///
     495    ///\note \c InArcIt iterators referencing the original arc are
     496    ///invalidated. Other iterators remain valid.
    522497    ///
    523498    ///\warning This functionality cannot be used together with the
    524499    ///Snapshot feature.
    525     Node split(Arc e) {
    526       Node b = addNode();
    527       addArc(b,target(e));
    528       changeTarget(e,b);
    529       return b;
    530     }
     500    Node split(Arc a) {
     501      Node v = addNode();
     502      addArc(v,target(a));
     503      changeTarget(a,v);
     504      return v;
     505    }
     506
     507    ///Clear the digraph.
     508
     509    ///This function erases all nodes and arcs from the digraph.
     510    ///
     511    void clear() {
     512      Parent::clear();
     513    }
     514
     515    /// Reserve memory for nodes.
     516
     517    /// Using this function, it is possible to avoid superfluous memory
     518    /// allocation: if you know that the digraph you want to build will
     519    /// be large (e.g. it will contain millions of nodes and/or arcs),
     520    /// then it is worth reserving space for this amount before starting
     521    /// to build the digraph.
     522    /// \sa reserveArc()
     523    void reserveNode(int n) { nodes.reserve(n); };
     524
     525    /// Reserve memory for arcs.
     526
     527    /// Using this function, it is possible to avoid superfluous memory
     528    /// allocation: if you know that the digraph you want to build will
     529    /// be large (e.g. it will contain millions of nodes and/or arcs),
     530    /// then it is worth reserving space for this amount before starting
     531    /// to build the digraph.
     532    /// \sa reserveNode()
     533    void reserveArc(int m) { arcs.reserve(m); };
    531534
    532535    /// \brief Class to make a snapshot of the digraph and restore
     
    538541    /// restore() function.
    539542    ///
    540     /// \warning Arc and node deletions and other modifications (e.g.
    541     /// contracting, splitting, reversing arcs or nodes) cannot be
     543    /// \note After a state is restored, you cannot restore a later state,
     544    /// i.e. you cannot add the removed nodes and arcs again using
     545    /// another Snapshot instance.
     546    ///
     547    /// \warning Node and arc deletions and other modifications (e.g.
     548    /// reversing, contracting, splitting arcs or nodes) cannot be
    542549    /// restored. These events invalidate the snapshot.
     550    /// However the arcs and nodes that were added to the digraph after
     551    /// making the current snapshot can be removed without invalidating it.
    543552    class Snapshot {
    544553    protected:
     
    710719      ///
    711720      /// Default constructor.
    712       /// To actually make a snapshot you must call save().
     721      /// You have to call save() to actually make a snapshot.
    713722      Snapshot()
    714723        : digraph(0), node_observer_proxy(*this),
     
    717726      /// \brief Constructor that immediately makes a snapshot.
    718727      ///
    719       /// This constructor immediately makes a snapshot of the digraph.
    720       /// \param _digraph The digraph we make a snapshot of.
    721       Snapshot(ListDigraph &_digraph)
     728      /// This constructor immediately makes a snapshot of the given digraph.
     729      Snapshot(ListDigraph &gr)
    722730        : node_observer_proxy(*this),
    723731          arc_observer_proxy(*this) {
    724         attach(_digraph);
     732        attach(gr);
    725733      }
    726734
    727735      /// \brief Make a snapshot.
    728736      ///
    729       /// Make a snapshot of the digraph.
    730       ///
    731       /// This function can be called more than once. In case of a repeated
     737      /// This function makes a snapshot of the given digraph.
     738      /// It can be called more than once. In case of a repeated
    732739      /// call, the previous snapshot gets lost.
    733       /// \param _digraph The digraph we make the snapshot of.
    734       void save(ListDigraph &_digraph) {
     740      void save(ListDigraph &gr) {
    735741        if (attached()) {
    736742          detach();
    737743          clear();
    738744        }
    739         attach(_digraph);
     745        attach(gr);
    740746      }
    741747
    742748      /// \brief Undo the changes until the last snapshot.
    743       //
    744       /// Undo the changes until the last snapshot created by save().
     749      ///
     750      /// This function undos the changes until the last snapshot
     751      /// created by save() or Snapshot(ListDigraph&).
    745752      void restore() {
    746753        detach();
     
    756763      }
    757764
    758       /// \brief Gives back true when the snapshot is valid.
     765      /// \brief Returns \c true if the snapshot is valid.
    759766      ///
    760       /// Gives back true when the snapshot is valid.
     767      /// This function returns \c true if the snapshot is valid.
    761768      bool valid() const {
    762769        return attached();
     
    795802
    796803    typedef ListGraphBase Graph;
    797 
    798     class Node;
    799     class Arc;
    800     class Edge;
    801804
    802805    class Node {
     
    848851      bool operator<(const Arc& arc) const {return id < arc.id;}
    849852    };
    850 
    851 
    852853
    853854    ListGraphBase()
     
    11651166  ///A general undirected graph structure.
    11661167
    1167   ///\ref ListGraph is a simple and fast <em>undirected graph</em>
    1168   ///implementation based on static linked lists that are stored in
     1168  ///\ref ListGraph is a versatile and fast undirected graph
     1169  ///implementation based on linked lists that are stored in
    11691170  ///\c std::vector structures.
    11701171  ///
    1171   ///It conforms to the \ref concepts::Graph "Graph concept" and it
    1172   ///also provides several useful additional functionalities.
    1173   ///Most of the member functions and nested classes are documented
     1172  ///This type fully conforms to the \ref concepts::Graph "Graph concept"
     1173  ///and it also provides several useful additional functionalities.
     1174  ///Most of its member functions and nested classes are documented
    11741175  ///only in the concept class.
    11751176  ///
    11761177  ///\sa concepts::Graph
    1177 
     1178  ///\sa ListDigraph
    11781179  class ListGraph : public ExtendedListGraphBase {
    11791180    typedef ExtendedListGraphBase Parent;
    11801181
    11811182  private:
    1182     ///ListGraph is \e not copy constructible. Use copyGraph() instead.
    1183 
    1184     ///ListGraph is \e not copy constructible. Use copyGraph() instead.
    1185     ///
     1183    /// Graphs are \e not copy constructible. Use GraphCopy instead.
    11861184    ListGraph(const ListGraph &) :ExtendedListGraphBase()  {};
    1187     ///\brief Assignment of ListGraph to another one is \e not allowed.
    1188     ///Use copyGraph() instead.
    1189 
    1190     ///Assignment of ListGraph to another one is \e not allowed.
    1191     ///Use copyGraph() instead.
     1185    /// \brief Assignment of a graph to another one is \e not allowed.
     1186    /// Use GraphCopy instead.
    11921187    void operator=(const ListGraph &) {}
    11931188  public:
     
    12021197    /// \brief Add a new node to the graph.
    12031198    ///
    1204     /// Add a new node to the graph.
     1199    /// This function adds a new node to the graph.
    12051200    /// \return The new node.
    12061201    Node addNode() { return Parent::addNode(); }
     
    12081203    /// \brief Add a new edge to the graph.
    12091204    ///
    1210     /// Add a new edge to the graph with source node \c s
    1211     /// and target node \c t.
     1205    /// This function adds a new edge to the graph between nodes
     1206    /// \c u and \c v with inherent orientation from node \c u to
     1207    /// node \c v.
    12121208    /// \return The new edge.
    1213     Edge addEdge(const Node& s, const Node& t) {
    1214       return Parent::addEdge(s, t);
    1215     }
    1216 
    1217     /// \brief Erase a node from the graph.
    1218     ///
    1219     /// Erase a node from the graph.
    1220     ///
    1221     void erase(const Node& n) { Parent::erase(n); }
    1222 
    1223     /// \brief Erase an edge from the graph.
    1224     ///
    1225     /// Erase an edge from the graph.
    1226     ///
    1227     void erase(const Edge& e) { Parent::erase(e); }
     1209    Edge addEdge(Node u, Node v) {
     1210      return Parent::addEdge(u, v);
     1211    }
     1212
     1213    ///\brief Erase a node from the graph.
     1214    ///
     1215    /// This function erases the given node from the graph.
     1216    void erase(Node n) { Parent::erase(n); }
     1217
     1218    ///\brief Erase an edge from the graph.
     1219    ///
     1220    /// This function erases the given edge from the graph.
     1221    void erase(Edge e) { Parent::erase(e); }
    12281222    /// Node validity check
    12291223
    1230     /// This function gives back true if the given node is valid,
    1231     /// ie. it is a real node of the graph.
    1232     ///
    1233     /// \warning A Node pointing to a removed item
    1234     /// could become valid again later if new nodes are
     1224    /// This function gives back \c true if the given node is valid,
     1225    /// i.e. it is a real node of the graph.
     1226    ///
     1227    /// \warning A removed node could become valid again if new nodes are
    12351228    /// added to the graph.
    12361229    bool valid(Node n) const { return Parent::valid(n); }
     1230    /// Edge validity check
     1231
     1232    /// This function gives back \c true if the given edge is valid,
     1233    /// i.e. it is a real edge of the graph.
     1234    ///
     1235    /// \warning A removed edge could become valid again if new edges are
     1236    /// added to the graph.
     1237    bool valid(Edge e) const { return Parent::valid(e); }
    12371238    /// Arc validity check
    12381239
    1239     /// This function gives back true if the given arc is valid,
    1240     /// ie. it is a real arc of the graph.
    1241     ///
    1242     /// \warning An Arc pointing to a removed item
    1243     /// could become valid again later if new edges are
     1240    /// This function gives back \c true if the given arc is valid,
     1241    /// i.e. it is a real arc of the graph.
     1242    ///
     1243    /// \warning A removed arc could become valid again if new edges are
    12441244    /// added to the graph.
    12451245    bool valid(Arc a) const { return Parent::valid(a); }
    1246     /// Edge validity check
    1247 
    1248     /// This function gives back true if the given edge is valid,
    1249     /// ie. it is a real arc of the graph.
    1250     ///
    1251     /// \warning A Edge pointing to a removed item
    1252     /// could become valid again later if new edges are
    1253     /// added to the graph.
    1254     bool valid(Edge e) const { return Parent::valid(e); }
    1255     /// \brief Change the end \c u of \c e to \c n
    1256     ///
    1257     /// This function changes the end \c u of \c e to node \c n.
    1258     ///
    1259     ///\note The <tt>EdgeIt</tt>s and <tt>ArcIt</tt>s referencing the
    1260     ///changed edge are invalidated and if the changed node is the
    1261     ///base node of an iterator then this iterator is also
    1262     ///invalidated.
     1246
     1247    /// \brief Change the first node of an edge.
     1248    ///
     1249    /// This function changes the first node of the given edge \c e to \c n.
     1250    ///
     1251    ///\note \c EdgeIt and \c ArcIt iterators referencing the
     1252    ///changed edge are invalidated and all other iterators whose
     1253    ///base node is the changed node are also invalidated.
    12631254    ///
    12641255    ///\warning This functionality cannot be used together with the
     
    12671258      Parent::changeU(e,n);
    12681259    }
    1269     /// \brief Change the end \c v of \c e to \c n
    1270     ///
    1271     /// This function changes the end \c v of \c e to \c n.
    1272     ///
    1273     ///\note The <tt>EdgeIt</tt>s referencing the changed edge remain
    1274     ///valid, however <tt>ArcIt</tt>s and if the changed node is the
    1275     ///base node of an iterator then this iterator is invalidated.
     1260    /// \brief Change the second node of an edge.
     1261    ///
     1262    /// This function changes the second node of the given edge \c e to \c n.
     1263    ///
     1264    ///\note \c EdgeIt iterators referencing the changed edge remain
     1265    ///valid, however \c ArcIt iterators referencing the changed edge and
     1266    ///all other iterators whose base node is the changed node are also
     1267    ///invalidated.
    12761268    ///
    12771269    ///\warning This functionality cannot be used together with the
     
    12801272      Parent::changeV(e,n);
    12811273    }
     1274
    12821275    /// \brief Contract two nodes.
    12831276    ///
    1284     /// This function contracts two nodes.
    1285     /// Node \p b will be removed but instead of deleting
    1286     /// its neighboring arcs, they will be joined to \p a.
    1287     /// The last parameter \p r controls whether to remove loops. \c true
    1288     /// means that loops will be removed.
    1289     ///
    1290     /// \note The <tt>ArcIt</tt>s referencing a moved arc remain
    1291     /// valid.
     1277    /// This function contracts the given two nodes.
     1278    /// Node \c b is removed, but instead of deleting
     1279    /// its incident edges, they are joined to node \c a.
     1280    /// If the last parameter \c r is \c true (this is the default value),
     1281    /// then the newly created loops are removed.
     1282    ///
     1283    /// \note The moved edges are joined to node \c a using changeU()
     1284    /// or changeV(), thus all edge and arc iterators whose base node is
     1285    /// \c b are invalidated.
     1286    /// Moreover all iterators referencing node \c b or the removed
     1287    /// loops are also invalidated. Other iterators remain valid.
    12921288    ///
    12931289    ///\warning This functionality cannot be used together with the
     
    13081304    }
    13091305
     1306    ///Clear the graph.
     1307
     1308    ///This function erases all nodes and arcs from the graph.
     1309    ///
     1310    void clear() {
     1311      Parent::clear();
     1312    }
    13101313
    13111314    /// \brief Class to make a snapshot of the graph and restore
     
    13171320    /// using the restore() function.
    13181321    ///
    1319     /// \warning Edge and node deletions and other modifications
    1320     /// (e.g. changing nodes of edges, contracting nodes) cannot be
    1321     /// restored. These events invalidate the snapshot.
     1322    /// \note After a state is restored, you cannot restore a later state,
     1323    /// i.e. you cannot add the removed nodes and edges again using
     1324    /// another Snapshot instance.
     1325    ///
     1326    /// \warning Node and edge deletions and other modifications
     1327    /// (e.g. changing the end-nodes of edges or contracting nodes)
     1328    /// cannot be restored. These events invalidate the snapshot.
     1329    /// However the edges and nodes that were added to the graph after
     1330    /// making the current snapshot can be removed without invalidating it.
    13221331    class Snapshot {
    13231332    protected:
     
    14891498      ///
    14901499      /// Default constructor.
    1491       /// To actually make a snapshot you must call save().
     1500      /// You have to call save() to actually make a snapshot.
    14921501      Snapshot()
    14931502        : graph(0), node_observer_proxy(*this),
     
    14961505      /// \brief Constructor that immediately makes a snapshot.
    14971506      ///
    1498       /// This constructor immediately makes a snapshot of the graph.
    1499       /// \param _graph The graph we make a snapshot of.
    1500       Snapshot(ListGraph &_graph)
     1507      /// This constructor immediately makes a snapshot of the given graph.
     1508      Snapshot(ListGraph &gr)
    15011509        : node_observer_proxy(*this),
    15021510          edge_observer_proxy(*this) {
    1503         attach(_graph);
     1511        attach(gr);
    15041512      }
    15051513
    15061514      /// \brief Make a snapshot.
    15071515      ///
    1508       /// Make a snapshot of the graph.
    1509       ///
    1510       /// This function can be called more than once. In case of a repeated
     1516      /// This function makes a snapshot of the given graph.
     1517      /// It can be called more than once. In case of a repeated
    15111518      /// call, the previous snapshot gets lost.
    1512       /// \param _graph The graph we make the snapshot of.
    1513       void save(ListGraph &_graph) {
     1519      void save(ListGraph &gr) {
    15141520        if (attached()) {
    15151521          detach();
    15161522          clear();
    15171523        }
    1518         attach(_graph);
     1524        attach(gr);
    15191525      }
    15201526
    15211527      /// \brief Undo the changes until the last snapshot.
    1522       //
    1523       /// Undo the changes until the last snapshot created by save().
     1528      ///
     1529      /// This function undos the changes until the last snapshot
     1530      /// created by save() or Snapshot(ListGraph&).
    15241531      void restore() {
    15251532        detach();
     
    15351542      }
    15361543
    1537       /// \brief Gives back true when the snapshot is valid.
     1544      /// \brief Returns \c true if the snapshot is valid.
    15381545      ///
    1539       /// Gives back true when the snapshot is valid.
     1546      /// This function returns \c true if the snapshot is valid.
    15401547      bool valid() const {
    15411548        return attached();
Note: See TracChangeset for help on using the changeset viewer.