Changeset 735:853fcddcf282 in lemon-1.2 for lemon/list_graph.h
- Timestamp:
- 08/23/09 11:09:22 (15 years ago)
- Branch:
- default
- Phase:
- public
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
lemon/list_graph.h
r617 r735 22 22 ///\ingroup graphs 23 23 ///\file 24 ///\brief ListDigraph ,ListGraph classes.24 ///\brief ListDigraph and ListGraph classes. 25 25 26 26 #include <lemon/core.h> … … 312 312 ///A general directed graph structure. 313 313 314 ///\ref ListDigraph is a simple and fast <em>directed graph</em>315 ///implementation based on staticlinked lists that are stored in314 ///\ref ListDigraph is a versatile and fast directed graph 315 ///implementation based on linked lists that are stored in 316 316 ///\c std::vector structures. 317 317 /// 318 /// It conforms to the \ref concepts::Digraph "Digraph concept" and it319 ///a lso provides several useful additional functionalities.320 ///Most of themember functions and nested classes are documented318 ///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 321 321 ///only in the concept class. 322 322 /// 323 323 ///\sa concepts::Digraph 324 324 ///\sa ListGraph 325 325 class ListDigraph : public ExtendedListDigraphBase { 326 326 typedef ExtendedListDigraphBase Parent; 327 327 328 328 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. 333 330 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. 339 333 void operator=(const ListDigraph &) {} 340 334 public: … … 348 342 ///Add a new node to the digraph. 349 343 350 /// Adda new node to the digraph.344 ///This function adds a new node to the digraph. 351 345 ///\return The new node. 352 346 Node addNode() { return Parent::addNode(); } … … 354 348 ///Add a new arc to the digraph. 355 349 356 /// Adda new arc to the digraph with source node \c s350 ///This function adds a new arc to the digraph with source node \c s 357 351 ///and target node \c t. 358 352 ///\return The new arc. 359 Arc addArc( const Node& s, const Node&t) {353 Arc addArc(Node s, Node t) { 360 354 return Parent::addArc(s, t); 361 355 } … … 363 357 ///\brief Erase a node from the digraph. 364 358 /// 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); } 368 361 369 362 ///\brief Erase an arc from the digraph. 370 363 /// 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); } 374 366 375 367 /// Node validity check 376 368 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. 383 374 bool valid(Node n) const { return Parent::valid(n); } 384 375 385 376 /// Arc validity check 386 377 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. 393 383 bool valid(Arc a) const { return Parent::valid(a); } 394 384 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. 402 391 /// 403 392 ///\warning This functionality cannot be used together with the Snapshot … … 406 395 Parent::changeTarget(a,n); 407 396 } 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. 415 403 /// 416 404 ///\warning This functionality cannot be used together with the Snapshot … … 420 408 } 421 409 422 /// Invertthe direction of an arc.423 424 /// \note The <tt>ArcIt</tt>s referencing the changed arc remain425 /// valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are426 /// 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. 427 415 /// 428 416 ///\warning This functionality cannot be used together with the Snapshot 429 417 ///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 } 455 423 456 424 ///Contract two nodes. 457 425 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. 467 438 /// 468 439 ///\warning This functionality cannot be used together with the Snapshot 469 440 ///feature. 470 void contract(Node a, Node b, bool r = true)441 void contract(Node u, Node v, bool r = true) 471 442 { 472 for(OutArcIt e(*this, b);e!=INVALID;) {443 for(OutArcIt e(*this,v);e!=INVALID;) { 473 444 OutArcIt f=e; 474 445 ++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); 477 448 e=f; 478 449 } 479 for(InArcIt e(*this, b);e!=INVALID;) {450 for(InArcIt e(*this,v);e!=INVALID;) { 480 451 InArcIt f=e; 481 452 ++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); 484 455 e=f; 485 456 } 486 erase( b);457 erase(v); 487 458 } 488 459 489 460 ///Split a node. 490 461 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. 495 468 ///\return The newly created node. 496 469 /// 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 502 474 ///Snapshot feature. 503 475 Node split(Node n, bool connect = true) { … … 515 487 ///Split an arc. 516 488 517 ///This function splits an arc. First a new node \c b is added to518 /// the digraph, then the original arc is re-targeted to \c519 /// 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. 521 493 ///\return The newly created node. 494 /// 495 ///\note \c InArcIt iterators referencing the original arc are 496 ///invalidated. Other iterators remain valid. 522 497 /// 523 498 ///\warning This functionality cannot be used together with the 524 499 ///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); }; 531 534 532 535 /// \brief Class to make a snapshot of the digraph and restore … … 538 541 /// restore() function. 539 542 /// 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 542 549 /// 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. 543 552 class Snapshot { 544 553 protected: … … 710 719 /// 711 720 /// Default constructor. 712 /// To actually make a snapshot you must call save().721 /// You have to call save() to actually make a snapshot. 713 722 Snapshot() 714 723 : digraph(0), node_observer_proxy(*this), … … 717 726 /// \brief Constructor that immediately makes a snapshot. 718 727 /// 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) 722 730 : node_observer_proxy(*this), 723 731 arc_observer_proxy(*this) { 724 attach( _digraph);732 attach(gr); 725 733 } 726 734 727 735 /// \brief Make a snapshot. 728 736 /// 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 732 739 /// 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) { 735 741 if (attached()) { 736 742 detach(); 737 743 clear(); 738 744 } 739 attach( _digraph);745 attach(gr); 740 746 } 741 747 742 748 /// \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&). 745 752 void restore() { 746 753 detach(); … … 756 763 } 757 764 758 /// \brief Gives back true whenthe snapshot is valid.765 /// \brief Returns \c true if the snapshot is valid. 759 766 /// 760 /// Gives back true whenthe snapshot is valid.767 /// This function returns \c true if the snapshot is valid. 761 768 bool valid() const { 762 769 return attached(); … … 795 802 796 803 typedef ListGraphBase Graph; 797 798 class Node;799 class Arc;800 class Edge;801 804 802 805 class Node { … … 848 851 bool operator<(const Arc& arc) const {return id < arc.id;} 849 852 }; 850 851 852 853 853 854 ListGraphBase() … … 1165 1166 ///A general undirected graph structure. 1166 1167 1167 ///\ref ListGraph is a simple and fast <em>undirected graph</em>1168 ///implementation based on staticlinked lists that are stored in1168 ///\ref ListGraph is a versatile and fast undirected graph 1169 ///implementation based on linked lists that are stored in 1169 1170 ///\c std::vector structures. 1170 1171 /// 1171 /// It conforms to the \ref concepts::Graph "Graph concept" and it1172 ///a lso provides several useful additional functionalities.1173 ///Most of themember functions and nested classes are documented1172 ///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 1174 1175 ///only in the concept class. 1175 1176 /// 1176 1177 ///\sa concepts::Graph 1177 1178 ///\sa ListDigraph 1178 1179 class ListGraph : public ExtendedListGraphBase { 1179 1180 typedef ExtendedListGraphBase Parent; 1180 1181 1181 1182 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. 1186 1184 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. 1192 1187 void operator=(const ListGraph &) {} 1193 1188 public: … … 1202 1197 /// \brief Add a new node to the graph. 1203 1198 /// 1204 /// Adda new node to the graph.1199 /// This function adds a new node to the graph. 1205 1200 /// \return The new node. 1206 1201 Node addNode() { return Parent::addNode(); } … … 1208 1203 /// \brief Add a new edge to the graph. 1209 1204 /// 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. 1212 1208 /// \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); } 1228 1222 /// Node validity check 1229 1223 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 1235 1228 /// added to the graph. 1236 1229 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); } 1237 1238 /// Arc validity check 1238 1239 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 1244 1244 /// added to the graph. 1245 1245 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. 1263 1254 /// 1264 1255 ///\warning This functionality cannot be used together with the … … 1267 1258 Parent::changeU(e,n); 1268 1259 } 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. 1276 1268 /// 1277 1269 ///\warning This functionality cannot be used together with the … … 1280 1272 Parent::changeV(e,n); 1281 1273 } 1274 1282 1275 /// \brief Contract two nodes. 1283 1276 /// 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. 1292 1288 /// 1293 1289 ///\warning This functionality cannot be used together with the … … 1308 1304 } 1309 1305 1306 ///Clear the graph. 1307 1308 ///This function erases all nodes and arcs from the graph. 1309 /// 1310 void clear() { 1311 Parent::clear(); 1312 } 1310 1313 1311 1314 /// \brief Class to make a snapshot of the graph and restore … … 1317 1320 /// using the restore() function. 1318 1321 /// 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. 1322 1331 class Snapshot { 1323 1332 protected: … … 1489 1498 /// 1490 1499 /// Default constructor. 1491 /// To actually make a snapshot you must call save().1500 /// You have to call save() to actually make a snapshot. 1492 1501 Snapshot() 1493 1502 : graph(0), node_observer_proxy(*this), … … 1496 1505 /// \brief Constructor that immediately makes a snapshot. 1497 1506 /// 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) 1501 1509 : node_observer_proxy(*this), 1502 1510 edge_observer_proxy(*this) { 1503 attach( _graph);1511 attach(gr); 1504 1512 } 1505 1513 1506 1514 /// \brief Make a snapshot. 1507 1515 /// 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 1511 1518 /// 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) { 1514 1520 if (attached()) { 1515 1521 detach(); 1516 1522 clear(); 1517 1523 } 1518 attach( _graph);1524 attach(gr); 1519 1525 } 1520 1526 1521 1527 /// \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&). 1524 1531 void restore() { 1525 1532 detach(); … … 1535 1542 } 1536 1543 1537 /// \brief Gives back true whenthe snapshot is valid.1544 /// \brief Returns \c true if the snapshot is valid. 1538 1545 /// 1539 /// Gives back true whenthe snapshot is valid.1546 /// This function returns \c true if the snapshot is valid. 1540 1547 bool valid() const { 1541 1548 return attached();
Note: See TracChangeset
for help on using the changeset viewer.