gravatar
kpeter (Peter Kovacs)
kpeter@inf.elte.hu
Doc reorganization + improvements - Reorganize several tools (move them to other modules). - Add new module for map concepts. - Remove the doc of all tools in lemon/bits. - Improvements in groups.dox. - Fix some doxygen warnings.
0 17 0
default
17 files changed with 527 insertions and 558 deletions:
↑ Collapse diff ↑
Ignore white space 6 line context
... ...
@@ -51,13 +51,15 @@
51 51
LEMON also provides a variety of graphs for these requirements called
52 52
\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only
53 53
in conjunction with other graph representations.
54 54

	
55 55
You are free to use the graph structure that fit your requirements
56 56
the best, most graph algorithms and auxiliary data structures can be used
57
with any graph structures.
57
with any graph structure.
58

	
59
<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
58 60
*/
59 61

	
60 62
/**
61 63
@defgroup semi_adaptors Semi-Adaptor Classes for Graphs
62 64
@ingroup graphs
63 65
\brief Graph types between real graphs and graph adaptors.
... ...
@@ -71,26 +73,27 @@
71 73
@defgroup maps Maps
72 74
@ingroup datas
73 75
\brief Map structures implemented in LEMON.
74 76

	
75 77
This group describes the map structures implemented in LEMON.
76 78

	
77
LEMON provides several special purpose maps that e.g. combine
79
LEMON provides several special purpose maps and map adaptors that e.g. combine
78 80
new maps from existing ones.
81

	
82
<b>See also:</b> \ref map_concepts "Map Concepts".
79 83
*/
80 84

	
81 85
/**
82 86
@defgroup graph_maps Graph Maps
83 87
@ingroup maps
84 88
\brief Special graph-related maps.
85 89

	
86 90
This group describes maps that are specifically designed to assign
87 91
values to the nodes and arcs of graphs.
88 92
*/
89 93

	
90

	
91 94
/**
92 95
\defgroup map_adaptors Map Adaptors
93 96
\ingroup maps
94 97
\brief Tools to create new maps from existing ones
95 98

	
96 99
This group describes map adaptors that are used to create "implicit"
... ...
@@ -101,13 +104,13 @@
101 104
(negation, shifting, addition, multiplication, logical 'and', 'or',
102 105
'not' etc.) or e.g. convert a map to another one of different Value type.
103 106

	
104 107
The typical usage of this classes is passing implicit maps to
105 108
algorithms.  If a function type algorithm is called then the function
106 109
type map adaptors can be used comfortable. For example let's see the
107
usage of map adaptors with the \c digraphToEps() function.
110
usage of map adaptors with the \c graphToEps() function.
108 111
\code
109 112
  Color nodeColor(int deg) {
110 113
    if (deg >= 2) {
111 114
      return Color(0.5, 0.0, 0.5);
112 115
    } else if (deg == 1) {
113 116
      return Color(1.0, 0.5, 1.0);
... ...
@@ -115,19 +118,19 @@
115 118
      return Color(0.0, 0.0, 0.0);
116 119
    }
117 120
  }
118 121

	
119 122
  Digraph::NodeMap<int> degree_map(graph);
120 123

	
121
  digraphToEps(graph, "graph.eps")
124
  graphToEps(graph, "graph.eps")
122 125
    .coords(coords).scaleToA4().undirected()
123 126
    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
124 127
    .run();
125 128
\endcode
126 129
The \c functorToMap() function makes an \c int to \c Color map from the
127
\e nodeColor() function. The \c composeMap() compose the \e degree_map
130
\c nodeColor() function. The \c composeMap() compose the \c degree_map
128 131
and the previously created map. The composed map is a proper function to
129 132
get the color of each node.
130 133

	
131 134
The usage with class type algorithms is little bit harder. In this
132 135
case the function type map adaptors can not be used, because the
133 136
function map adaptors give back temporary objects.
... ...
@@ -170,25 +173,23 @@
170 173
All of them have similar interfaces and they can be copied easily with
171 174
assignment operators and copy constructors. This makes it easy and
172 175
efficient to have e.g. the Dijkstra algorithm to store its result in
173 176
any kind of path structure.
174 177

	
175 178
\sa lemon::concepts::Path
176

	
177 179
*/
178 180

	
179 181
/**
180 182
@defgroup auxdat Auxiliary Data Structures
181 183
@ingroup datas
182 184
\brief Auxiliary data structures implemented in LEMON.
183 185

	
184 186
This group describes some data structures implemented in LEMON in
185 187
order to make it easier to implement combinatorial algorithms.
186 188
*/
187 189

	
188

	
189 190
/**
190 191
@defgroup algs Algorithms
191 192
\brief This group describes the several algorithms
192 193
implemented in LEMON.
193 194

	
194 195
This group describes the several algorithms
... ...
@@ -198,25 +199,25 @@
198 199
/**
199 200
@defgroup search Graph Search
200 201
@ingroup algs
201 202
\brief Common graph search algorithms.
202 203

	
203 204
This group describes the common graph search algorithms like
204
Breadth-first search (Bfs) and Depth-first search (Dfs).
205
Breadth-First Search (BFS) and Depth-First Search (DFS).
205 206
*/
206 207

	
207 208
/**
208
@defgroup shortest_path Shortest Path algorithms
209
@defgroup shortest_path Shortest Path Algorithms
209 210
@ingroup algs
210 211
\brief Algorithms for finding shortest paths.
211 212

	
212 213
This group describes the algorithms for finding shortest paths in graphs.
213 214
*/
214 215

	
215 216
/**
216
@defgroup max_flow Maximum Flow algorithms
217
@defgroup max_flow Maximum Flow Algorithms
217 218
@ingroup algs
218 219
\brief Algorithms for finding maximum flows.
219 220

	
220 221
This group describes the algorithms for finding maximum flows and
221 222
feasible circulations.
222 223

	
... ...
@@ -238,27 +239,26 @@
238 239
- \ref lemon::GoldbergTarjan "Preflow algorithm with dynamic trees"
239 240

	
240 241
In most cases the \ref lemon::Preflow "Preflow" algorithm provides the
241 242
fastest method to compute the maximum flow. All impelementations
242 243
provides functions to query the minimum cut, which is the dual linear
243 244
programming problem of the maximum flow.
244

	
245 245
*/
246 246

	
247 247
/**
248
@defgroup min_cost_flow Minimum Cost Flow algorithms
248
@defgroup min_cost_flow Minimum Cost Flow Algorithms
249 249
@ingroup algs
250 250

	
251 251
\brief Algorithms for finding minimum cost flows and circulations.
252 252

	
253 253
This group describes the algorithms for finding minimum cost flows and
254 254
circulations.
255 255
*/
256 256

	
257 257
/**
258
@defgroup min_cut Minimum Cut algorithms
258
@defgroup min_cut Minimum Cut Algorithms
259 259
@ingroup algs
260 260

	
261 261
\brief Algorithms for finding minimum cut in graphs.
262 262

	
263 263
This group describes the algorithms for finding minimum cut in graphs.
264 264

	
... ...
@@ -279,41 +279,40 @@
279 279
  calculate minimum cut in undirected graphs
280 280
- \ref lemon::GomoryHuTree "Gomory-Hu tree computation" to calculate all
281 281
  pairs minimum cut in undirected graphs
282 282

	
283 283
If you want to find minimum cut just between two distinict nodes,
284 284
please see the \ref max_flow "Maximum Flow page".
285

	
286 285
*/
287 286

	
288 287
/**
289
@defgroup graph_prop Connectivity and other graph properties
288
@defgroup graph_prop Connectivity and Other Graph Properties
290 289
@ingroup algs
291 290
\brief Algorithms for discovering the graph properties
292 291

	
293 292
This group describes the algorithms for discovering the graph properties
294 293
like connectivity, bipartiteness, euler property, simplicity etc.
295 294

	
296 295
\image html edge_biconnected_components.png
297 296
\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
298 297
*/
299 298

	
300 299
/**
301
@defgroup planar Planarity embedding and drawing
300
@defgroup planar Planarity Embedding and Drawing
302 301
@ingroup algs
303 302
\brief Algorithms for planarity checking, embedding and drawing
304 303

	
305 304
This group describes the algorithms for planarity checking,
306 305
embedding and drawing.
307 306

	
308 307
\image html planar.png
309 308
\image latex planar.eps "Plane graph" width=\textwidth
310 309
*/
311 310

	
312 311
/**
313
@defgroup matching Matching algorithms
312
@defgroup matching Matching Algorithms
314 313
@ingroup algs
315 314
\brief Algorithms for finding matchings in graphs and bipartite graphs.
316 315

	
317 316
This group contains algorithm objects and functions to calculate
318 317
matchings in graphs and bipartite graphs. The general matching problem is
319 318
finding a subset of the arcs which does not shares common endpoints.
... ...
@@ -345,36 +344,35 @@
345 344
- \ref lemon::MaxWeightedPerfectMatching "MaxWeightedPerfectMatching"
346 345
  Edmond's blossom shrinking algorithm for calculate maximum weighted
347 346
  perfect matching in general graph
348 347

	
349 348
\image html bipartite_matching.png
350 349
\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
351

	
352 350
*/
353 351

	
354 352
/**
355
@defgroup spantree Minimum Spanning Tree algorithms
353
@defgroup spantree Minimum Spanning Tree Algorithms
356 354
@ingroup algs
357 355
\brief Algorithms for finding a minimum cost spanning tree in a graph.
358 356

	
359 357
This group describes the algorithms for finding a minimum cost spanning
360 358
tree in a graph
361 359
*/
362 360

	
363

	
364 361
/**
365
@defgroup auxalg Auxiliary algorithms
362
@defgroup auxalg Auxiliary Algorithms
366 363
@ingroup algs
367 364
\brief Auxiliary algorithms implemented in LEMON.
368 365

	
369 366
This group describes some algorithms implemented in LEMON
370 367
in order to make it easier to implement complex algorithms.
371 368
*/
372 369

	
373 370
/**
374
@defgroup approx Approximation algorithms
371
@defgroup approx Approximation Algorithms
372
@ingroup algs
375 373
\brief Approximation algorithms.
376 374

	
377 375
This group describes the approximation and heuristic algorithms
378 376
implemented in LEMON.
379 377
*/
380 378

	
... ...
@@ -382,28 +380,26 @@
382 380
@defgroup gen_opt_group General Optimization Tools
383 381
\brief This group describes some general optimization frameworks
384 382
implemented in LEMON.
385 383

	
386 384
This group describes some general optimization frameworks
387 385
implemented in LEMON.
388

	
389 386
*/
390 387

	
391 388
/**
392
@defgroup lp_group Lp and Mip solvers
389
@defgroup lp_group Lp and Mip Solvers
393 390
@ingroup gen_opt_group
394 391
\brief Lp and Mip solver interfaces for LEMON.
395 392

	
396 393
This group describes Lp and Mip solver interfaces for LEMON. The
397 394
various LP solvers could be used in the same manner with this
398 395
interface.
399

	
400 396
*/
401 397

	
402 398
/**
403
@defgroup lp_utils Tools for Lp and Mip solvers
399
@defgroup lp_utils Tools for Lp and Mip Solvers
404 400
@ingroup lp_group
405 401
\brief Helper tools to the Lp and Mip solvers.
406 402

	
407 403
This group adds some helper tools to general optimization framework
408 404
implemented in LEMON.
409 405
*/
... ...
@@ -438,65 +434,56 @@
438 434

	
439 435
This group describes several useful tools for development,
440 436
debugging and testing.
441 437
*/
442 438

	
443 439
/**
444
@defgroup timecount Time measuring and Counting
440
@defgroup timecount Time Measuring and Counting
445 441
@ingroup misc
446 442
\brief Simple tools for measuring the performance of algorithms.
447 443

	
448 444
This group describes simple tools for measuring the performance
449 445
of algorithms.
450 446
*/
451 447

	
452 448
/**
453
@defgroup graphbits Tools for Graph Implementation
454
@ingroup utils
455
\brief Tools to make it easier to create graphs.
456

	
457
This group describes the tools that makes it easier to create graphs and
458
the maps that dynamically update with the graph changes.
459
*/
460

	
461
/**
462 449
@defgroup exceptions Exceptions
463 450
@ingroup utils
464 451
\brief Exceptions defined in LEMON.
465 452

	
466 453
This group describes the exceptions defined in LEMON.
467 454
*/
468 455

	
469 456
/**
470 457
@defgroup io_group Input-Output
471 458
\brief Graph Input-Output methods
472 459

	
473 460
This group describes the tools for importing and exporting graphs
474
and graph related data. Now it supports the LEMON format, the
475
\c DIMACS format and the encapsulated postscript (EPS) format.
461
and graph related data. Now it supports the \ref lgf-format
462
"LEMON Graph Format", the \c DIMACS format and the encapsulated
463
postscript (EPS) format.
476 464
*/
477 465

	
478 466
/**
479 467
@defgroup lemon_io LEMON Input-Output
480 468
@ingroup io_group
481
\brief Reading and writing \ref lgf-format "LEMON Graph Format".
469
\brief Reading and writing LEMON Graph Format.
482 470

	
483 471
This group describes methods for reading and writing
484 472
\ref lgf-format "LEMON Graph Format".
485 473
*/
486 474

	
487 475
/**
488
@defgroup eps_io Postscript exporting
476
@defgroup eps_io Postscript Exporting
489 477
@ingroup io_group
490 478
\brief General \c EPS drawer and graph exporter
491 479

	
492 480
This group describes general \c EPS drawing methods and special
493 481
graph exporting tools.
494 482
*/
495 483

	
496

	
497 484
/**
498 485
@defgroup concept Concepts
499 486
\brief Skeleton classes and concept checking classes
500 487

	
501 488
This group describes the data/algorithm skeletons and concept checking
502 489
classes implemented in LEMON.
... ...
@@ -518,29 +505,29 @@
518 505

	
519 506
- The concept descriptor classes also provide a <em>checker class</em>
520 507
  that makes it possible to check whether a certain implementation of a
521 508
  concept indeed provides all the required features.
522 509

	
523 510
- Finally, They can serve as a skeleton of a new implementation of a concept.
524

	
525 511
*/
526 512

	
527

	
528 513
/**
529 514
@defgroup graph_concepts Graph Structure Concepts
530 515
@ingroup concept
531 516
\brief Skeleton and concept checking classes for graph structures
532 517

	
533 518
This group describes the skeletons and concept checking classes of LEMON's
534 519
graph structures and helper classes used to implement these.
535 520
*/
536 521

	
537
/* --- Unused group
538
@defgroup experimental Experimental Structures and Algorithms
539
This group describes some Experimental structures and algorithms.
540
The stuff here is subject to change.
522
/**
523
@defgroup map_concepts Map Concepts
524
@ingroup concept
525
\brief Skeleton and concept checking classes for maps
526

	
527
This group describes the skeletons and concept checking classes of maps.
541 528
*/
542 529

	
543 530
/**
544 531
\anchor demoprograms
545 532

	
546 533
@defgroup demos Demo programs
Ignore white space 12 line context
... ...
@@ -47,14 +47,15 @@
47 47

	
48 48
If you already feel like using our library, see the page that tells you
49 49
\ref getstart "How to start using LEMON".
50 50

	
51 51
If you
52 52
want to see how LEMON works, see
53
some \ref demoprograms "demo programs"!
53
some \ref demoprograms "demo programs".
54 54

	
55 55
If you know what you are looking for then try to find it under the
56 56
<a class="el" href="modules.html">Modules</a>
57 57
section.
58 58

	
59
If you are a user of the old (0.x) series of LEMON, please check out the \ref migration "Migration Guide" for the backward incompatibilities.
59
If you are a user of the old (0.x) series of LEMON, please check out the
60
\ref migration "Migration Guide" for the backward incompatibilities.
60 61
*/
Ignore white space 6 line context
... ...
@@ -54,13 +54,13 @@
54 54

	
55 55
\warning
56 56
<b>The <tt>script/lemon-0.x-to-1.x.sh</tt> tool replaces all instances of
57 57
the words \c graph, \c digraph, \c edge and \c arc, so it replaces them
58 58
in strings, comments etc. as well as in all identifiers.</b>
59 59

	
60
\section migration-lgf LGF tools 
60
\section migration-lgf LGF tools
61 61
 - The \ref lgf-format "LGF file format" has changed,
62 62
   <tt>\@nodeset</tt> has changed to <tt>\@nodes</tt>,
63 63
   <tt>\@edgeset</tt> and <tt>\@uedgeset</tt> to <tt>\@arcs</tt> or
64 64
   <tt>\@edges</tt>, which become completely equivalents. The
65 65
   <tt>\@nodes</tt>, <tt>\@edges</tt> and <tt>\@uedges</tt> sections are
66 66
   removed from the format, the content of them should be
Ignore white space 6 line context
... ...
@@ -21,235 +21,229 @@
21 21

	
22 22
#include <vector>
23 23
#include <list>
24 24

	
25 25
#include <lemon/core.h>
26 26

	
27
///\ingroup graphbits
28
///\file
29
///\brief Observer notifier for graph alteration observers.
27
//\ingroup graphbits
28
//\file
29
//\brief Observer notifier for graph alteration observers.
30 30

	
31 31
namespace lemon {
32 32

	
33
  /// \ingroup graphbits
34
  ///
35
  /// \brief Notifier class to notify observes about alterations in
36
  /// a container.
37
  ///
38
  /// The simple graph's can be refered as two containers, one node container
39
  /// and one edge container. But they are not standard containers they
40
  /// does not store values directly they are just key continars for more
41
  /// value containers which are the node and edge maps.
42
  ///
43
  /// The graph's node and edge sets can be changed as we add or erase
44
  /// nodes and edges in the graph. LEMON would like to handle easily
45
  /// that the node and edge maps should contain values for all nodes or
46
  /// edges. If we want to check on every indicing if the map contains
47
  /// the current indicing key that cause a drawback in the performance
48
  /// in the library. We use another solution we notify all maps about
49
  /// an alteration in the graph, which cause only drawback on the
50
  /// alteration of the graph.
51
  ///
52
  /// This class provides an interface to the container. The \e first() and \e
53
  /// next() member functions make possible to iterate on the keys of the
54
  /// container. The \e id() function returns an integer id for each key.
55
  /// The \e maxId() function gives back an upper bound of the ids.
56
  ///
57
  /// For the proper functonality of this class, we should notify it
58
  /// about each alteration in the container. The alterations have four type
59
  /// as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
60
  /// \e erase() signals that only one or few items added or erased to or
61
  /// from the graph. If all items are erased from the graph or from an empty
62
  /// graph a new graph is builded then it can be signaled with the
63
  /// clear() and build() members. Important rule that if we erase items
64
  /// from graph we should first signal the alteration and after that erase
65
  /// them from the container, on the other way on item addition we should
66
  /// first extend the container and just after that signal the alteration.
67
  ///
68
  /// The alteration can be observed with a class inherited from the
69
  /// \e ObserverBase nested class. The signals can be handled with
70
  /// overriding the virtual functions defined in the base class.  The
71
  /// observer base can be attached to the notifier with the
72
  /// \e attach() member and can be detached with detach() function. The
73
  /// alteration handlers should not call any function which signals
74
  /// an other alteration in the same notifier and should not
75
  /// detach any observer from the notifier.
76
  ///
77
  /// Alteration observers try to be exception safe. If an \e add() or
78
  /// a \e clear() function throws an exception then the remaining
79
  /// observeres will not be notified and the fulfilled additions will
80
  /// be rolled back by calling the \e erase() or \e clear()
81
  /// functions. Thence the \e erase() and \e clear() should not throw
82
  /// exception. Actullay, it can be throw only \ref ImmediateDetach 
83
  /// exception which detach the observer from the notifier.
84
  ///
85
  /// There are some place when the alteration observing is not completly
86
  /// reliable. If we want to carry out the node degree in the graph
87
  /// as in the \ref InDegMap and we use the reverseEdge that cause
88
  /// unreliable functionality. Because the alteration observing signals
89
  /// only erasing and adding but not the reversing it will stores bad
90
  /// degrees. The sub graph adaptors cannot signal the alterations because
91
  /// just a setting in the filter map can modify the graph and this cannot
92
  /// be watched in any way.
93
  ///
94
  /// \param _Container The container which is observed.
95
  /// \param _Item The item type which is obserbved.
33
  // \ingroup graphbits
34
  //
35
  // \brief Notifier class to notify observes about alterations in
36
  // a container.
37
  //
38
  // The simple graph's can be refered as two containers, one node container
39
  // and one edge container. But they are not standard containers they
40
  // does not store values directly they are just key continars for more
41
  // value containers which are the node and edge maps.
42
  //
43
  // The graph's node and edge sets can be changed as we add or erase
44
  // nodes and edges in the graph. LEMON would like to handle easily
45
  // that the node and edge maps should contain values for all nodes or
46
  // edges. If we want to check on every indicing if the map contains
47
  // the current indicing key that cause a drawback in the performance
48
  // in the library. We use another solution we notify all maps about
49
  // an alteration in the graph, which cause only drawback on the
50
  // alteration of the graph.
51
  //
52
  // This class provides an interface to the container. The \e first() and \e
53
  // next() member functions make possible to iterate on the keys of the
54
  // container. The \e id() function returns an integer id for each key.
55
  // The \e maxId() function gives back an upper bound of the ids.
56
  //
57
  // For the proper functonality of this class, we should notify it
58
  // about each alteration in the container. The alterations have four type
59
  // as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
60
  // \e erase() signals that only one or few items added or erased to or
61
  // from the graph. If all items are erased from the graph or from an empty
62
  // graph a new graph is builded then it can be signaled with the
63
  // clear() and build() members. Important rule that if we erase items
64
  // from graph we should first signal the alteration and after that erase
65
  // them from the container, on the other way on item addition we should
66
  // first extend the container and just after that signal the alteration.
67
  //
68
  // The alteration can be observed with a class inherited from the
69
  // \e ObserverBase nested class. The signals can be handled with
70
  // overriding the virtual functions defined in the base class.  The
71
  // observer base can be attached to the notifier with the
72
  // \e attach() member and can be detached with detach() function. The
73
  // alteration handlers should not call any function which signals
74
  // an other alteration in the same notifier and should not
75
  // detach any observer from the notifier.
76
  //
77
  // Alteration observers try to be exception safe. If an \e add() or
78
  // a \e clear() function throws an exception then the remaining
79
  // observeres will not be notified and the fulfilled additions will
80
  // be rolled back by calling the \e erase() or \e clear()
81
  // functions. Thence the \e erase() and \e clear() should not throw
82
  // exception. Actullay, it can be throw only \ref ImmediateDetach
83
  // exception which detach the observer from the notifier.
84
  //
85
  // There are some place when the alteration observing is not completly
86
  // reliable. If we want to carry out the node degree in the graph
87
  // as in the \ref InDegMap and we use the reverseEdge that cause
88
  // unreliable functionality. Because the alteration observing signals
89
  // only erasing and adding but not the reversing it will stores bad
90
  // degrees. The sub graph adaptors cannot signal the alterations because
91
  // just a setting in the filter map can modify the graph and this cannot
92
  // be watched in any way.
93
  //
94
  // \param _Container The container which is observed.
95
  // \param _Item The item type which is obserbved.
96 96

	
97 97
  template <typename _Container, typename _Item>
98 98
  class AlterationNotifier {
99 99
  public:
100 100

	
101 101
    typedef True Notifier;
102 102

	
103 103
    typedef _Container Container;
104 104
    typedef _Item Item;
105 105

	
106
    /// \brief Exception which can be called from \e clear() and
107
    /// \e erase().
108
    ///
109
    /// From the \e clear() and \e erase() function only this
110
    /// exception is allowed to throw. The exception immediatly
111
    /// detaches the current observer from the notifier. Because the
112
    /// \e clear() and \e erase() should not throw other exceptions
113
    /// it can be used to invalidate the observer.
106
    // \brief Exception which can be called from \e clear() and
107
    // \e erase().
108
    //
109
    // From the \e clear() and \e erase() function only this
110
    // exception is allowed to throw. The exception immediatly
111
    // detaches the current observer from the notifier. Because the
112
    // \e clear() and \e erase() should not throw other exceptions
113
    // it can be used to invalidate the observer.
114 114
    struct ImmediateDetach {};
115 115

	
116
    /// \brief ObserverBase is the base class for the observers.
117
    ///
118
    /// ObserverBase is the abstract base class for the observers.
119
    /// It will be notified about an item was inserted into or
120
    /// erased from the graph.
121
    ///
122
    /// The observer interface contains some pure virtual functions
123
    /// to override. The add() and erase() functions are
124
    /// to notify the oberver when one item is added or
125
    /// erased.
126
    ///
127
    /// The build() and clear() members are to notify the observer
128
    /// about the container is built from an empty container or
129
    /// is cleared to an empty container.
130

	
116
    // \brief ObserverBase is the base class for the observers.
117
    //
118
    // ObserverBase is the abstract base class for the observers.
119
    // It will be notified about an item was inserted into or
120
    // erased from the graph.
121
    //
122
    // The observer interface contains some pure virtual functions
123
    // to override. The add() and erase() functions are
124
    // to notify the oberver when one item is added or
125
    // erased.
126
    //
127
    // The build() and clear() members are to notify the observer
128
    // about the container is built from an empty container or
129
    // is cleared to an empty container.
131 130
    class ObserverBase {
132 131
    protected:
133 132
      typedef AlterationNotifier Notifier;
134 133

	
135 134
      friend class AlterationNotifier;
136 135

	
137
      /// \brief Default constructor.
138
      ///
139
      /// Default constructor for ObserverBase.
140
      ///
136
      // \brief Default constructor.
137
      //
138
      // Default constructor for ObserverBase.
141 139
      ObserverBase() : _notifier(0) {}
142 140

	
143
      /// \brief Constructor which attach the observer into notifier.
144
      ///
145
      /// Constructor which attach the observer into notifier.
141
      // \brief Constructor which attach the observer into notifier.
142
      //
143
      // Constructor which attach the observer into notifier.
146 144
      ObserverBase(AlterationNotifier& nf) {
147 145
        attach(nf);
148 146
      }
149 147

	
150
      /// \brief Constructor which attach the obserever to the same notifier.
151
      ///
152
      /// Constructor which attach the obserever to the same notifier as
153
      /// the other observer is attached to.
148
      // \brief Constructor which attach the obserever to the same notifier.
149
      //
150
      // Constructor which attach the obserever to the same notifier as
151
      // the other observer is attached to.
154 152
      ObserverBase(const ObserverBase& copy) {
155 153
        if (copy.attached()) {
156 154
          attach(*copy.notifier());
157 155
        }
158 156
      }
159 157

	
160
      /// \brief Destructor
158
      // \brief Destructor
161 159
      virtual ~ObserverBase() {
162 160
        if (attached()) {
163 161
          detach();
164 162
        }
165 163
      }
166 164

	
167
      /// \brief Attaches the observer into an AlterationNotifier.
168
      ///
169
      /// This member attaches the observer into an AlterationNotifier.
170
      ///
165
      // \brief Attaches the observer into an AlterationNotifier.
166
      //
167
      // This member attaches the observer into an AlterationNotifier.
171 168
      void attach(AlterationNotifier& nf) {
172 169
        nf.attach(*this);
173 170
      }
174 171

	
175
      /// \brief Detaches the observer into an AlterationNotifier.
176
      ///
177
      /// This member detaches the observer from an AlterationNotifier.
178
      ///
172
      // \brief Detaches the observer into an AlterationNotifier.
173
      //
174
      // This member detaches the observer from an AlterationNotifier.
179 175
      void detach() {
180 176
        _notifier->detach(*this);
181 177
      }
182 178

	
183
      /// \brief Gives back a pointer to the notifier which the map
184
      /// attached into.
185
      ///
186
      /// This function gives back a pointer to the notifier which the map
187
      /// attached into.
188
      ///
179
      // \brief Gives back a pointer to the notifier which the map
180
      // attached into.
181
      //
182
      // This function gives back a pointer to the notifier which the map
183
      // attached into.
189 184
      Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
190 185

	
191
      /// Gives back true when the observer is attached into a notifier.
186
      // Gives back true when the observer is attached into a notifier.
192 187
      bool attached() const { return _notifier != 0; }
193 188

	
194 189
    private:
195 190

	
196 191
      ObserverBase& operator=(const ObserverBase& copy);
197 192

	
198 193
    protected:
199 194

	
200 195
      Notifier* _notifier;
201 196
      typename std::list<ObserverBase*>::iterator _index;
202 197

	
203
      /// \brief The member function to notificate the observer about an
204
      /// item is added to the container.
205
      ///
206
      /// The add() member function notificates the observer about an item
207
      /// is added to the container. It have to be overrided in the
208
      /// subclasses.
198
      // \brief The member function to notificate the observer about an
199
      // item is added to the container.
200
      //
201
      // The add() member function notificates the observer about an item
202
      // is added to the container. It have to be overrided in the
203
      // subclasses.
209 204
      virtual void add(const Item&) = 0;
210 205

	
211
      /// \brief The member function to notificate the observer about
212
      /// more item is added to the container.
213
      ///
214
      /// The add() member function notificates the observer about more item
215
      /// is added to the container. It have to be overrided in the
216
      /// subclasses.
206
      // \brief The member function to notificate the observer about
207
      // more item is added to the container.
208
      //
209
      // The add() member function notificates the observer about more item
210
      // is added to the container. It have to be overrided in the
211
      // subclasses.
217 212
      virtual void add(const std::vector<Item>& items) = 0;
218 213

	
219
      /// \brief The member function to notificate the observer about an
220
      /// item is erased from the container.
221
      ///
222
      /// The erase() member function notificates the observer about an
223
      /// item is erased from the container. It have to be overrided in
224
      /// the subclasses.
214
      // \brief The member function to notificate the observer about an
215
      // item is erased from the container.
216
      //
217
      // The erase() member function notificates the observer about an
218
      // item is erased from the container. It have to be overrided in
219
      // the subclasses.
225 220
      virtual void erase(const Item&) = 0;
226 221

	
227
      /// \brief The member function to notificate the observer about
228
      /// more item is erased from the container.
229
      ///
230
      /// The erase() member function notificates the observer about more item
231
      /// is erased from the container. It have to be overrided in the
232
      /// subclasses.
222
      // \brief The member function to notificate the observer about
223
      // more item is erased from the container.
224
      //
225
      // The erase() member function notificates the observer about more item
226
      // is erased from the container. It have to be overrided in the
227
      // subclasses.
233 228
      virtual void erase(const std::vector<Item>& items) = 0;
234 229

	
235
      /// \brief The member function to notificate the observer about the
236
      /// container is built.
237
      ///
238
      /// The build() member function notificates the observer about the
239
      /// container is built from an empty container. It have to be
240
      /// overrided in the subclasses.
241

	
230
      // \brief The member function to notificate the observer about the
231
      // container is built.
232
      //
233
      // The build() member function notificates the observer about the
234
      // container is built from an empty container. It have to be
235
      // overrided in the subclasses.
242 236
      virtual void build() = 0;
243 237

	
244
      /// \brief The member function to notificate the observer about all
245
      /// items are erased from the container.
246
      ///
247
      /// The clear() member function notificates the observer about all
248
      /// items are erased from the container. It have to be overrided in
249
      /// the subclasses.
238
      // \brief The member function to notificate the observer about all
239
      // items are erased from the container.
240
      //
241
      // The clear() member function notificates the observer about all
242
      // items are erased from the container. It have to be overrided in
243
      // the subclasses.
250 244
      virtual void clear() = 0;
251 245

	
252 246
    };
253 247

	
254 248
  protected:
255 249

	
... ...
@@ -258,85 +252,82 @@
258 252
    typedef std::list<ObserverBase*> Observers;
259 253
    Observers _observers;
260 254

	
261 255

	
262 256
  public:
263 257

	
264
    /// \brief Default constructor.
265
    ///
266
    /// The default constructor of the AlterationNotifier.
267
    /// It creates an empty notifier.
258
    // \brief Default constructor.
259
    //
260
    // The default constructor of the AlterationNotifier.
261
    // It creates an empty notifier.
268 262
    AlterationNotifier()
269 263
      : container(0) {}
270 264

	
271
    /// \brief Constructor.
272
    ///
273
    /// Constructor with the observed container parameter.
265
    // \brief Constructor.
266
    //
267
    // Constructor with the observed container parameter.
274 268
    AlterationNotifier(const Container& _container)
275 269
      : container(&_container) {}
276 270

	
277
    /// \brief Copy Constructor of the AlterationNotifier.
278
    ///
279
    /// Copy constructor of the AlterationNotifier.
280
    /// It creates only an empty notifier because the copiable
281
    /// notifier's observers have to be registered still into that notifier.
271
    // \brief Copy Constructor of the AlterationNotifier.
272
    //
273
    // Copy constructor of the AlterationNotifier.
274
    // It creates only an empty notifier because the copiable
275
    // notifier's observers have to be registered still into that notifier.
282 276
    AlterationNotifier(const AlterationNotifier& _notifier)
283 277
      : container(_notifier.container) {}
284 278

	
285
    /// \brief Destructor.
286
    ///
287
    /// Destructor of the AlterationNotifier.
288
    ///
279
    // \brief Destructor.
280
    //
281
    // Destructor of the AlterationNotifier.
289 282
    ~AlterationNotifier() {
290 283
      typename Observers::iterator it;
291 284
      for (it = _observers.begin(); it != _observers.end(); ++it) {
292 285
        (*it)->_notifier = 0;
293 286
      }
294 287
    }
295 288

	
296
    /// \brief Sets the container.
297
    ///
298
    /// Sets the container.
289
    // \brief Sets the container.
290
    //
291
    // Sets the container.
299 292
    void setContainer(const Container& _container) {
300 293
      container = &_container;
301 294
    }
302 295

	
303 296
  protected:
304 297

	
305 298
    AlterationNotifier& operator=(const AlterationNotifier&);
306 299

	
307 300
  public:
308 301

	
309

	
310

	
311
    /// \brief First item in the container.
312
    ///
313
    /// Returns the first item in the container. It is
314
    /// for start the iteration on the container.
302
    // \brief First item in the container.
303
    //
304
    // Returns the first item in the container. It is
305
    // for start the iteration on the container.
315 306
    void first(Item& item) const {
316 307
      container->first(item);
317 308
    }
318 309

	
319
    /// \brief Next item in the container.
320
    ///
321
    /// Returns the next item in the container. It is
322
    /// for iterate on the container.
310
    // \brief Next item in the container.
311
    //
312
    // Returns the next item in the container. It is
313
    // for iterate on the container.
323 314
    void next(Item& item) const {
324 315
      container->next(item);
325 316
    }
326 317

	
327
    /// \brief Returns the id of the item.
328
    ///
329
    /// Returns the id of the item provided by the container.
318
    // \brief Returns the id of the item.
319
    //
320
    // Returns the id of the item provided by the container.
330 321
    int id(const Item& item) const {
331 322
      return container->id(item);
332 323
    }
333 324

	
334
    /// \brief Returns the maximum id of the container.
335
    ///
336
    /// Returns the maximum id of the container.
325
    // \brief Returns the maximum id of the container.
326
    //
327
    // Returns the maximum id of the container.
337 328
    int maxId() const {
338 329
      return container->maxId(Item());
339 330
    }
340 331

	
341 332
  protected:
342 333

	
... ...
@@ -350,18 +341,17 @@
350 341
      observer._index = _observers.end();
351 342
      observer._notifier = 0;
352 343
    }
353 344

	
354 345
  public:
355 346

	
356
    /// \brief Notifies all the registed observers about an item added to
357
    /// the container.
358
    ///
359
    /// It notifies all the registed observers about an item added to
360
    /// the container.
361
    ///
347
    // \brief Notifies all the registed observers about an item added to
348
    // the container.
349
    //
350
    // It notifies all the registed observers about an item added to
351
    // the container.
362 352
    void add(const Item& item) {
363 353
      typename Observers::reverse_iterator it;
364 354
      try {
365 355
        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
366 356
          (*it)->add(item);
367 357
        }
... ...
@@ -371,18 +361,17 @@
371 361
          (*jt)->erase(item);
372 362
        }
373 363
        throw;
374 364
      }
375 365
    }
376 366

	
377
    /// \brief Notifies all the registed observers about more item added to
378
    /// the container.
379
    ///
380
    /// It notifies all the registed observers about more item added to
381
    /// the container.
382
    ///
367
    // \brief Notifies all the registed observers about more item added to
368
    // the container.
369
    //
370
    // It notifies all the registed observers about more item added to
371
    // the container.
383 372
    void add(const std::vector<Item>& items) {
384 373
      typename Observers::reverse_iterator it;
385 374
      try {
386 375
        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
387 376
          (*it)->add(items);
388 377
        }
... ...
@@ -392,18 +381,17 @@
392 381
          (*jt)->erase(items);
393 382
        }
394 383
        throw;
395 384
      }
396 385
    }
397 386

	
398
    /// \brief Notifies all the registed observers about an item erased from
399
    /// the container.
400
    ///
401
    /// It notifies all the registed observers about an item erased from
402
    /// the container.
403
    ///
387
    // \brief Notifies all the registed observers about an item erased from
388
    // the container.
389
    //
390
    // It notifies all the registed observers about an item erased from
391
    // the container.
404 392
    void erase(const Item& item) throw() {
405 393
      typename Observers::iterator it = _observers.begin();
406 394
      while (it != _observers.end()) {
407 395
        try {
408 396
          (*it)->erase(item);
409 397
          ++it;
... ...
@@ -412,18 +400,17 @@
412 400
          (*it)->_notifier = 0;
413 401
          it = _observers.erase(it);
414 402
        }
415 403
      }
416 404
    }
417 405

	
418
    /// \brief Notifies all the registed observers about more item erased
419
    /// from the container.
420
    ///
421
    /// It notifies all the registed observers about more item erased from
422
    /// the container.
423
    ///
406
    // \brief Notifies all the registed observers about more item erased
407
    // from the container.
408
    //
409
    // It notifies all the registed observers about more item erased from
410
    // the container.
424 411
    void erase(const std::vector<Item>& items) {
425 412
      typename Observers::iterator it = _observers.begin();
426 413
      while (it != _observers.end()) {
427 414
        try {
428 415
          (*it)->erase(items);
429 416
          ++it;
... ...
@@ -432,17 +419,17 @@
432 419
          (*it)->_notifier = 0;
433 420
          it = _observers.erase(it);
434 421
        }
435 422
      }
436 423
    }
437 424

	
438
    /// \brief Notifies all the registed observers about the container is
439
    /// built.
440
    ///
441
    /// Notifies all the registed observers about the container is built
442
    /// from an empty container.
425
    // \brief Notifies all the registed observers about the container is
426
    // built.
427
    //
428
    // Notifies all the registed observers about the container is built
429
    // from an empty container.
443 430
    void build() {
444 431
      typename Observers::reverse_iterator it;
445 432
      try {
446 433
        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
447 434
          (*it)->build();
448 435
        }
... ...
@@ -452,17 +439,17 @@
452 439
          (*jt)->clear();
453 440
        }
454 441
        throw;
455 442
      }
456 443
    }
457 444

	
458
    /// \brief Notifies all the registed observers about all items are
459
    /// erased.
460
    ///
461
    /// Notifies all the registed observers about all items are erased
462
    /// from the container.
445
    // \brief Notifies all the registed observers about all items are
446
    // erased.
447
    //
448
    // Notifies all the registed observers about all items are erased
449
    // from the container.
463 450
    void clear() {
464 451
      typename Observers::iterator it = _observers.begin();
465 452
      while (it != _observers.end()) {
466 453
        try {
467 454
          (*it)->clear();
468 455
          ++it;
Ignore white space 6 line context
... ...
@@ -23,93 +23,93 @@
23 23

	
24 24
#include <lemon/bits/traits.h>
25 25
#include <lemon/bits/alteration_notifier.h>
26 26
#include <lemon/concept_check.h>
27 27
#include <lemon/concepts/maps.h>
28 28

	
29
/// \ingroup graphbits
30
/// \file
31
/// \brief Graph map based on the array storage.
29
// \ingroup graphbits
30
// \file
31
// \brief Graph map based on the array storage.
32 32

	
33 33
namespace lemon {
34 34

	
35
  /// \ingroup graphbits
36
  ///
37
  /// \brief Graph map based on the array storage.
38
  ///
39
  /// The ArrayMap template class is graph map structure what
40
  /// automatically updates the map when a key is added to or erased from
41
  /// the map. This map uses the allocators to implement
42
  /// the container functionality.
43
  ///
44
  /// The template parameters are the Graph the current Item type and
45
  /// the Value type of the map.
35
  // \ingroup graphbits
36
  //
37
  // \brief Graph map based on the array storage.
38
  //
39
  // The ArrayMap template class is graph map structure what
40
  // automatically updates the map when a key is added to or erased from
41
  // the map. This map uses the allocators to implement
42
  // the container functionality.
43
  //
44
  // The template parameters are the Graph the current Item type and
45
  // the Value type of the map.
46 46
  template <typename _Graph, typename _Item, typename _Value>
47 47
  class ArrayMap
48 48
    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
49 49
  public:
50
    /// The graph type of the maps.
50
    // The graph type of the maps.
51 51
    typedef _Graph Graph;
52
    /// The item type of the map.
52
    // The item type of the map.
53 53
    typedef _Item Item;
54
    /// The reference map tag.
54
    // The reference map tag.
55 55
    typedef True ReferenceMapTag;
56 56

	
57
    /// The key type of the maps.
57
    // The key type of the maps.
58 58
    typedef _Item Key;
59
    /// The value type of the map.
59
    // The value type of the map.
60 60
    typedef _Value Value;
61 61

	
62
    /// The const reference type of the map.
62
    // The const reference type of the map.
63 63
    typedef const _Value& ConstReference;
64
    /// The reference type of the map.
64
    // The reference type of the map.
65 65
    typedef _Value& Reference;
66 66

	
67
    /// The notifier type.
67
    // The notifier type.
68 68
    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
69 69

	
70
    /// The MapBase of the Map which imlements the core regisitry function.
70
    // The MapBase of the Map which imlements the core regisitry function.
71 71
    typedef typename Notifier::ObserverBase Parent;
72 72

	
73 73
  private:
74 74
    typedef std::allocator<Value> Allocator;
75 75

	
76 76
  public:
77 77

	
78
    /// \brief Graph initialized map constructor.
79
    ///
80
    /// Graph initialized map constructor.
78
    // \brief Graph initialized map constructor.
79
    //
80
    // Graph initialized map constructor.
81 81
    explicit ArrayMap(const Graph& graph) {
82 82
      Parent::attach(graph.notifier(Item()));
83 83
      allocate_memory();
84 84
      Notifier* nf = Parent::notifier();
85 85
      Item it;
86 86
      for (nf->first(it); it != INVALID; nf->next(it)) {
87 87
        int id = nf->id(it);;
88 88
        allocator.construct(&(values[id]), Value());
89 89
      }
90 90
    }
91 91

	
92
    /// \brief Constructor to use default value to initialize the map.
93
    ///
94
    /// It constructs a map and initialize all of the the map.
92
    // \brief Constructor to use default value to initialize the map.
93
    //
94
    // It constructs a map and initialize all of the the map.
95 95
    ArrayMap(const Graph& graph, const Value& value) {
96 96
      Parent::attach(graph.notifier(Item()));
97 97
      allocate_memory();
98 98
      Notifier* nf = Parent::notifier();
99 99
      Item it;
100 100
      for (nf->first(it); it != INVALID; nf->next(it)) {
101 101
        int id = nf->id(it);;
102 102
        allocator.construct(&(values[id]), value);
103 103
      }
104 104
    }
105 105

	
106 106
  private:
107
    /// \brief Constructor to copy a map of the same map type.
108
    ///
109
    /// Constructor to copy a map of the same map type.
107
    // \brief Constructor to copy a map of the same map type.
108
    //
109
    // Constructor to copy a map of the same map type.
110 110
    ArrayMap(const ArrayMap& copy) : Parent() {
111 111
      if (copy.attached()) {
112 112
        attach(*copy.notifier());
113 113
      }
114 114
      capacity = copy.capacity;
115 115
      if (capacity == 0) return;
... ...
@@ -119,45 +119,45 @@
119 119
      for (nf->first(it); it != INVALID; nf->next(it)) {
120 120
        int id = nf->id(it);;
121 121
        allocator.construct(&(values[id]), copy.values[id]);
122 122
      }
123 123
    }
124 124

	
125
    /// \brief Assign operator.
126
    ///
127
    /// This operator assigns for each item in the map the
128
    /// value mapped to the same item in the copied map.
129
    /// The parameter map should be indiced with the same
130
    /// itemset because this assign operator does not change
131
    /// the container of the map.
125
    // \brief Assign operator.
126
    //
127
    // This operator assigns for each item in the map the
128
    // value mapped to the same item in the copied map.
129
    // The parameter map should be indiced with the same
130
    // itemset because this assign operator does not change
131
    // the container of the map.
132 132
    ArrayMap& operator=(const ArrayMap& cmap) {
133 133
      return operator=<ArrayMap>(cmap);
134 134
    }
135 135

	
136 136

	
137
    /// \brief Template assign operator.
138
    ///
139
    /// The given parameter should be conform to the ReadMap
140
    /// concecpt and could be indiced by the current item set of
141
    /// the NodeMap. In this case the value for each item
142
    /// is assigned by the value of the given ReadMap.
137
    // \brief Template assign operator.
138
    //
139
    // The given parameter should be conform to the ReadMap
140
    // concecpt and could be indiced by the current item set of
141
    // the NodeMap. In this case the value for each item
142
    // is assigned by the value of the given ReadMap.
143 143
    template <typename CMap>
144 144
    ArrayMap& operator=(const CMap& cmap) {
145 145
      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
146 146
      const typename Parent::Notifier* nf = Parent::notifier();
147 147
      Item it;
148 148
      for (nf->first(it); it != INVALID; nf->next(it)) {
149 149
        set(it, cmap[it]);
150 150
      }
151 151
      return *this;
152 152
    }
153 153

	
154 154
  public:
155
    /// \brief The destructor of the map.
156
    ///
157
    /// The destructor of the map.
155
    // \brief The destructor of the map.
156
    //
157
    // The destructor of the map.
158 158
    virtual ~ArrayMap() {
159 159
      if (attached()) {
160 160
        clear();
161 161
        detach();
162 162
      }
163 163
    }
... ...
@@ -167,44 +167,44 @@
167 167
    using Parent::attach;
168 168
    using Parent::detach;
169 169
    using Parent::attached;
170 170

	
171 171
  public:
172 172

	
173
    /// \brief The subscript operator.
174
    ///
175
    /// The subscript operator. The map can be subscripted by the
176
    /// actual keys of the graph.
173
    // \brief The subscript operator.
174
    //
175
    // The subscript operator. The map can be subscripted by the
176
    // actual keys of the graph.
177 177
    Value& operator[](const Key& key) {
178 178
      int id = Parent::notifier()->id(key);
179 179
      return values[id];
180 180
    }
181 181

	
182
    /// \brief The const subscript operator.
183
    ///
184
    /// The const subscript operator. The map can be subscripted by the
185
    /// actual keys of the graph.
182
    // \brief The const subscript operator.
183
    //
184
    // The const subscript operator. The map can be subscripted by the
185
    // actual keys of the graph.
186 186
    const Value& operator[](const Key& key) const {
187 187
      int id = Parent::notifier()->id(key);
188 188
      return values[id];
189 189
    }
190 190

	
191
    /// \brief Setter function of the map.
192
    ///
193
    /// Setter function of the map. Equivalent with map[key] = val.
194
    /// This is a compatibility feature with the not dereferable maps.
191
    // \brief Setter function of the map.
192
    //
193
    // Setter function of the map. Equivalent with map[key] = val.
194
    // This is a compatibility feature with the not dereferable maps.
195 195
    void set(const Key& key, const Value& val) {
196 196
      (*this)[key] = val;
197 197
    }
198 198

	
199 199
  protected:
200 200

	
201
    /// \brief Adds a new key to the map.
202
    ///
203
    /// It adds a new key to the map. It called by the observer notifier
204
    /// and it overrides the add() member function of the observer base.
201
    // \brief Adds a new key to the map.
202
    //
203
    // It adds a new key to the map. It called by the observer notifier
204
    // and it overrides the add() member function of the observer base.
205 205
    virtual void add(const Key& key) {
206 206
      Notifier* nf = Parent::notifier();
207 207
      int id = nf->id(key);
208 208
      if (id >= capacity) {
209 209
        int new_capacity = (capacity == 0 ? 1 : capacity);
210 210
        while (new_capacity <= id) {
... ...
@@ -223,16 +223,16 @@
223 223
        values = new_values;
224 224
        capacity = new_capacity;
225 225
      }
226 226
      allocator.construct(&(values[id]), Value());
227 227
    }
228 228

	
229
    /// \brief Adds more new keys to the map.
230
    ///
231
    /// It adds more new keys to the map. It called by the observer notifier
232
    /// and it overrides the add() member function of the observer base.
229
    // \brief Adds more new keys to the map.
230
    //
231
    // It adds more new keys to the map. It called by the observer notifier
232
    // and it overrides the add() member function of the observer base.
233 233
    virtual void add(const std::vector<Key>& keys) {
234 234
      Notifier* nf = Parent::notifier();
235 235
      int max_id = -1;
236 236
      for (int i = 0; i < int(keys.size()); ++i) {
237 237
        int id = nf->id(keys[i]);
238 238
        if (id > max_id) {
... ...
@@ -267,50 +267,50 @@
267 267
      for (int i = 0; i < int(keys.size()); ++i) {
268 268
        int id = nf->id(keys[i]);
269 269
        allocator.construct(&(values[id]), Value());
270 270
      }
271 271
    }
272 272

	
273
    /// \brief Erase a key from the map.
274
    ///
275
    /// Erase a key from the map. It called by the observer notifier
276
    /// and it overrides the erase() member function of the observer base.
273
    // \brief Erase a key from the map.
274
    //
275
    // Erase a key from the map. It called by the observer notifier
276
    // and it overrides the erase() member function of the observer base.
277 277
    virtual void erase(const Key& key) {
278 278
      int id = Parent::notifier()->id(key);
279 279
      allocator.destroy(&(values[id]));
280 280
    }
281 281

	
282
    /// \brief Erase more keys from the map.
283
    ///
284
    /// Erase more keys from the map. It called by the observer notifier
285
    /// and it overrides the erase() member function of the observer base.
282
    // \brief Erase more keys from the map.
283
    //
284
    // Erase more keys from the map. It called by the observer notifier
285
    // and it overrides the erase() member function of the observer base.
286 286
    virtual void erase(const std::vector<Key>& keys) {
287 287
      for (int i = 0; i < int(keys.size()); ++i) {
288 288
        int id = Parent::notifier()->id(keys[i]);
289 289
        allocator.destroy(&(values[id]));
290 290
      }
291 291
    }
292 292

	
293
    /// \brief Buildes the map.
294
    ///
295
    /// It buildes the map. It called by the observer notifier
296
    /// and it overrides the build() member function of the observer base.
293
    // \brief Buildes the map.
294
    //
295
    // It buildes the map. It called by the observer notifier
296
    // and it overrides the build() member function of the observer base.
297 297
    virtual void build() {
298 298
      Notifier* nf = Parent::notifier();
299 299
      allocate_memory();
300 300
      Item it;
301 301
      for (nf->first(it); it != INVALID; nf->next(it)) {
302 302
        int id = nf->id(it);;
303 303
        allocator.construct(&(values[id]), Value());
304 304
      }
305 305
    }
306 306

	
307
    /// \brief Clear the map.
308
    ///
309
    /// It erase all items from the map. It called by the observer notifier
310
    /// and it overrides the clear() member function of the observer base.
307
    // \brief Clear the map.
308
    //
309
    // It erase all items from the map. It called by the observer notifier
310
    // and it overrides the clear() member function of the observer base.
311 311
    virtual void clear() {
312 312
      Notifier* nf = Parent::notifier();
313 313
      if (capacity != 0) {
314 314
        Item it;
315 315
        for (nf->first(it); it != INVALID; nf->next(it)) {
316 316
          int id = nf->id(it);
Ignore white space 6 line context
... ...
@@ -25,20 +25,20 @@
25 25
#include <lemon/bits/map_extender.h>
26 26
#include <lemon/bits/default_map.h>
27 27

	
28 28
#include <lemon/concept_check.h>
29 29
#include <lemon/concepts/maps.h>
30 30

	
31
///\ingroup digraphbits
32
///\file
33
///\brief Extenders for the digraph types
31
//\ingroup digraphbits
32
//\file
33
//\brief Extenders for the digraph types
34 34
namespace lemon {
35 35

	
36
  /// \ingroup digraphbits
37
  ///
38
  /// \brief BaseDigraph to BaseGraph extender
36
  // \ingroup digraphbits
37
  //
38
  // \brief BaseDigraph to BaseGraph extender
39 39
  template <typename Base>
40 40
  class UndirDigraphExtender : public Base {
41 41

	
42 42
  public:
43 43

	
44 44
    typedef Base Parent;
... ...
@@ -71,43 +71,43 @@
71 71
      bool operator<(const Arc &that) const {
72 72
        return forward<that.forward ||
73 73
          (!(that.forward<forward) && Edge(*this)<Edge(that));
74 74
      }
75 75
    };
76 76

	
77
    /// First node of the edge
77
    // First node of the edge
78 78
    Node u(const Edge &e) const {
79 79
      return Parent::source(e);
80 80
    }
81 81

	
82
    /// Source of the given arc
82
    // Source of the given arc
83 83
    Node source(const Arc &e) const {
84 84
      return e.forward ? Parent::source(e) : Parent::target(e);
85 85
    }
86 86

	
87
    /// Second node of the edge
87
    // Second node of the edge
88 88
    Node v(const Edge &e) const {
89 89
      return Parent::target(e);
90 90
    }
91 91

	
92
    /// Target of the given arc
92
    // Target of the given arc
93 93
    Node target(const Arc &e) const {
94 94
      return e.forward ? Parent::target(e) : Parent::source(e);
95 95
    }
96 96

	
97
    /// \brief Directed arc from an edge.
98
    ///
99
    /// Returns a directed arc corresponding to the specified edge.
100
    /// If the given bool is true, the first node of the given edge and
101
    /// the source node of the returned arc are the same.
97
    // \brief Directed arc from an edge.
98
    //
99
    // Returns a directed arc corresponding to the specified edge.
100
    // If the given bool is true, the first node of the given edge and
101
    // the source node of the returned arc are the same.
102 102
    static Arc direct(const Edge &e, bool d) {
103 103
      return Arc(e, d);
104 104
    }
105 105

	
106
    /// Returns whether the given directed arc has the same orientation
107
    /// as the corresponding edge.
106
    // Returns whether the given directed arc has the same orientation
107
    // as the corresponding edge.
108 108
    static bool direction(const Arc &a) { return a.forward; }
109 109

	
110 110
    using Parent::first;
111 111
    using Parent::next;
112 112

	
113 113
    void first(Arc &e) const {
Ignore white space 6 line context
... ...
@@ -16,17 +16,17 @@
16 16
 *
17 17
 */
18 18

	
19 19
#ifndef LEMON_BEZIER_H
20 20
#define LEMON_BEZIER_H
21 21

	
22
///\ingroup misc
23
///\file
24
///\brief Classes to compute with Bezier curves.
25
///
26
///Up to now this file is used internally by \ref graph_to_eps.h
22
//\ingroup misc
23
//\file
24
//\brief Classes to compute with Bezier curves.
25
//
26
//Up to now this file is used internally by \ref graph_to_eps.h
27 27

	
28 28
#include<lemon/dim2.h>
29 29

	
30 30
namespace lemon {
31 31
  namespace dim2 {
32 32

	
Ignore white space 6 line context
... ...
@@ -16,20 +16,19 @@
16 16
 *
17 17
 */
18 18

	
19 19
#ifndef LEMON_BITS_DEFAULT_MAP_H
20 20
#define LEMON_BITS_DEFAULT_MAP_H
21 21

	
22

	
23 22
#include <lemon/bits/array_map.h>
24 23
#include <lemon/bits/vector_map.h>
25 24
//#include <lemon/bits/debug_map.h>
26 25

	
27
///\ingroup graphbits
28
///\file
29
///\brief Graph maps that construct and destruct their elements dynamically.
26
//\ingroup graphbits
27
//\file
28
//\brief Graph maps that construct and destruct their elements dynamically.
30 29

	
31 30
namespace lemon {
32 31

	
33 32

	
34 33
  //#ifndef LEMON_USE_DEBUG_MAP
35 34

	
... ...
@@ -146,13 +145,13 @@
146 145
//   struct DefaultMapSelector {
147 146
//     typedef DebugMap<_Graph, _Item, _Value> Map;
148 147
//   };
149 148

	
150 149
// #endif
151 150

	
152
  /// DefaultMap class
151
  // DefaultMap class
153 152
  template <typename _Graph, typename _Item, typename _Value>
154 153
  class DefaultMap
155 154
    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
156 155
  public:
157 156
    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
158 157
    typedef DefaultMap<_Graph, _Item, _Value> Map;
Ignore white space 6 line context
... ...
@@ -32,35 +32,35 @@
32 32
//             Andrew Lumsdaine (lums at osl.iu.edu)
33 33

	
34 34

	
35 35
#ifndef LEMON_BITS_ENABLE_IF_H
36 36
#define LEMON_BITS_ENABLE_IF_H
37 37

	
38
///\file
39
///\brief Miscellaneous basic utilities
38
//\file
39
//\brief Miscellaneous basic utilities
40 40

	
41 41
namespace lemon
42 42
{
43 43

	
44
  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
44
  // Basic type for defining "tags". A "YES" condition for \c enable_if.
45 45

	
46
  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
47
  ///
48
  ///\sa False
46
  // Basic type for defining "tags". A "YES" condition for \c enable_if.
47
  //
48
  //\sa False
49 49
  struct True {
50
    ///\e
50
    //\e
51 51
    static const bool value = true;
52 52
  };
53 53

	
54
  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
54
  // Basic type for defining "tags". A "NO" condition for \c enable_if.
55 55

	
56
  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
57
  ///
58
  ///\sa True
56
  // Basic type for defining "tags". A "NO" condition for \c enable_if.
57
  //
58
  //\sa True
59 59
  struct False {
60
    ///\e
60
    //\e
61 61
    static const bool value = false;
62 62
  };
63 63

	
64 64

	
65 65

	
66 66
  template <typename T>
Ignore white space 6 line context
... ...
@@ -24,20 +24,20 @@
24 24
#include <lemon/bits/map_extender.h>
25 25
#include <lemon/bits/default_map.h>
26 26

	
27 27
#include <lemon/concept_check.h>
28 28
#include <lemon/concepts/maps.h>
29 29

	
30
///\ingroup graphbits
31
///\file
32
///\brief Extenders for the digraph types
30
//\ingroup graphbits
31
//\file
32
//\brief Extenders for the digraph types
33 33
namespace lemon {
34 34

	
35
  /// \ingroup graphbits
36
  ///
37
  /// \brief Extender for the Digraphs
35
  // \ingroup graphbits
36
  //
37
  // \brief Extender for the Digraphs
38 38
  template <typename Base>
39 39
  class DigraphExtender : public Base {
40 40
  public:
41 41

	
42 42
    typedef Base Parent;
43 43
    typedef DigraphExtender Digraph;
... ...
@@ -183,36 +183,36 @@
183 183
        _digraph->nextIn(*this);
184 184
        return *this;
185 185
      }
186 186

	
187 187
    };
188 188

	
189
    /// \brief Base node of the iterator
190
    ///
191
    /// Returns the base node (i.e. the source in this case) of the iterator
189
    // \brief Base node of the iterator
190
    //
191
    // Returns the base node (i.e. the source in this case) of the iterator
192 192
    Node baseNode(const OutArcIt &arc) const {
193 193
      return Parent::source(arc);
194 194
    }
195
    /// \brief Running node of the iterator
196
    ///
197
    /// Returns the running node (i.e. the target in this case) of the
198
    /// iterator
195
    // \brief Running node of the iterator
196
    //
197
    // Returns the running node (i.e. the target in this case) of the
198
    // iterator
199 199
    Node runningNode(const OutArcIt &arc) const {
200 200
      return Parent::target(arc);
201 201
    }
202 202

	
203
    /// \brief Base node of the iterator
204
    ///
205
    /// Returns the base node (i.e. the target in this case) of the iterator
203
    // \brief Base node of the iterator
204
    //
205
    // Returns the base node (i.e. the target in this case) of the iterator
206 206
    Node baseNode(const InArcIt &arc) const {
207 207
      return Parent::target(arc);
208 208
    }
209
    /// \brief Running node of the iterator
210
    ///
211
    /// Returns the running node (i.e. the source in this case) of the
212
    /// iterator
209
    // \brief Running node of the iterator
210
    //
211
    // Returns the running node (i.e. the source in this case) of the
212
    // iterator
213 213
    Node runningNode(const InArcIt &arc) const {
214 214
      return Parent::source(arc);
215 215
    }
216 216

	
217 217

	
218 218
    template <typename _Value>
... ...
@@ -322,15 +322,15 @@
322 322
    ~DigraphExtender() {
323 323
      arc_notifier.clear();
324 324
      node_notifier.clear();
325 325
    }
326 326
  };
327 327

	
328
  /// \ingroup _graphbits
329
  ///
330
  /// \brief Extender for the Graphs
328
  // \ingroup _graphbits
329
  //
330
  // \brief Extender for the Graphs
331 331
  template <typename Base>
332 332
  class GraphExtender : public Base {
333 333
  public:
334 334

	
335 335
    typedef Base Parent;
336 336
    typedef GraphExtender Graph;
... ...
@@ -552,49 +552,49 @@
552 552
      IncEdgeIt& operator++() {
553 553
        _graph->nextInc(*this, _direction);
554 554
        return *this;
555 555
      }
556 556
    };
557 557

	
558
    /// \brief Base node of the iterator
559
    ///
560
    /// Returns the base node (ie. the source in this case) of the iterator
558
    // \brief Base node of the iterator
559
    //
560
    // Returns the base node (ie. the source in this case) of the iterator
561 561
    Node baseNode(const OutArcIt &arc) const {
562 562
      return Parent::source(static_cast<const Arc&>(arc));
563 563
    }
564
    /// \brief Running node of the iterator
565
    ///
566
    /// Returns the running node (ie. the target in this case) of the
567
    /// iterator
564
    // \brief Running node of the iterator
565
    //
566
    // Returns the running node (ie. the target in this case) of the
567
    // iterator
568 568
    Node runningNode(const OutArcIt &arc) const {
569 569
      return Parent::target(static_cast<const Arc&>(arc));
570 570
    }
571 571

	
572
    /// \brief Base node of the iterator
573
    ///
574
    /// Returns the base node (ie. the target in this case) of the iterator
572
    // \brief Base node of the iterator
573
    //
574
    // Returns the base node (ie. the target in this case) of the iterator
575 575
    Node baseNode(const InArcIt &arc) const {
576 576
      return Parent::target(static_cast<const Arc&>(arc));
577 577
    }
578
    /// \brief Running node of the iterator
579
    ///
580
    /// Returns the running node (ie. the source in this case) of the
581
    /// iterator
578
    // \brief Running node of the iterator
579
    //
580
    // Returns the running node (ie. the source in this case) of the
581
    // iterator
582 582
    Node runningNode(const InArcIt &arc) const {
583 583
      return Parent::source(static_cast<const Arc&>(arc));
584 584
    }
585 585

	
586
    /// Base node of the iterator
587
    ///
588
    /// Returns the base node of the iterator
586
    // Base node of the iterator
587
    //
588
    // Returns the base node of the iterator
589 589
    Node baseNode(const IncEdgeIt &edge) const {
590 590
      return edge._direction ? u(edge) : v(edge);
591 591
    }
592
    /// Running node of the iterator
593
    ///
594
    /// Returns the running node of the iterator
592
    // Running node of the iterator
593
    //
594
    // Returns the running node of the iterator
595 595
    Node runningNode(const IncEdgeIt &edge) const {
596 596
      return edge._direction ? v(edge) : u(edge);
597 597
    }
598 598

	
599 599
    // Mappable extension
600 600

	
Ignore white space 6 line context
... ...
@@ -23,20 +23,20 @@
23 23

	
24 24
#include <lemon/bits/traits.h>
25 25

	
26 26
#include <lemon/concept_check.h>
27 27
#include <lemon/concepts/maps.h>
28 28

	
29
///\file
30
///\brief Extenders for iterable maps.
29
//\file
30
//\brief Extenders for iterable maps.
31 31

	
32 32
namespace lemon {
33 33

	
34
  /// \ingroup graphbits
35
  ///
36
  /// \brief Extender for maps
34
  // \ingroup graphbits
35
  //
36
  // \brief Extender for maps
37 37
  template <typename _Map>
38 38
  class MapExtender : public _Map {
39 39
  public:
40 40

	
41 41
    typedef _Map Parent;
42 42
    typedef MapExtender Map;
... ...
@@ -168,15 +168,15 @@
168 168
    protected:
169 169
      const Map& map;
170 170

	
171 171
    };
172 172
  };
173 173

	
174
  /// \ingroup graphbits
175
  ///
176
  /// \brief Extender for maps which use a subset of the items.
174
  // \ingroup graphbits
175
  //
176
  // \brief Extender for maps which use a subset of the items.
177 177
  template <typename _Graph, typename _Map>
178 178
  class SubMapExtender : public _Map {
179 179
  public:
180 180

	
181 181
    typedef _Map Parent;
182 182
    typedef SubMapExtender Map;
Ignore white space 6 line context
... ...
@@ -16,15 +16,15 @@
16 16
 *
17 17
 */
18 18

	
19 19
#ifndef LEMON_BITS_TRAITS_H
20 20
#define LEMON_BITS_TRAITS_H
21 21

	
22
///\file
23
///\brief Traits for graphs and maps
24
///
22
//\file
23
//\brief Traits for graphs and maps
24
//
25 25

	
26 26
#include <lemon/bits/enable_if.h>
27 27

	
28 28
namespace lemon {
29 29

	
30 30
  struct InvalidType {};
Ignore white space 6 line context
... ...
@@ -25,112 +25,112 @@
25 25
#include <lemon/core.h>
26 26
#include <lemon/bits/alteration_notifier.h>
27 27

	
28 28
#include <lemon/concept_check.h>
29 29
#include <lemon/concepts/maps.h>
30 30

	
31
///\ingroup graphbits
32
///
33
///\file
34
///\brief Vector based graph maps.
31
//\ingroup graphbits
32
//
33
//\file
34
//\brief Vector based graph maps.
35 35
namespace lemon {
36 36

	
37
  /// \ingroup graphbits
38
  ///
39
  /// \brief Graph map based on the std::vector storage.
40
  ///
41
  /// The VectorMap template class is graph map structure what
42
  /// automatically updates the map when a key is added to or erased from
43
  /// the map. This map type uses the std::vector to store the values.
44
  ///
45
  /// \tparam _Graph The graph this map is attached to.
46
  /// \tparam _Item The item type of the graph items.
47
  /// \tparam _Value The value type of the map.
37
  // \ingroup graphbits
38
  //
39
  // \brief Graph map based on the std::vector storage.
40
  //
41
  // The VectorMap template class is graph map structure what
42
  // automatically updates the map when a key is added to or erased from
43
  // the map. This map type uses the std::vector to store the values.
44
  //
45
  // \tparam _Graph The graph this map is attached to.
46
  // \tparam _Item The item type of the graph items.
47
  // \tparam _Value The value type of the map.
48 48
  template <typename _Graph, typename _Item, typename _Value>
49 49
  class VectorMap
50 50
    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
51 51
  private:
52 52

	
53
    /// The container type of the map.
53
    // The container type of the map.
54 54
    typedef std::vector<_Value> Container;
55 55

	
56 56
  public:
57 57

	
58
    /// The graph type of the map.
58
    // The graph type of the map.
59 59
    typedef _Graph Graph;
60
    /// The item type of the map.
60
    // The item type of the map.
61 61
    typedef _Item Item;
62
    /// The reference map tag.
62
    // The reference map tag.
63 63
    typedef True ReferenceMapTag;
64 64

	
65
    /// The key type of the map.
65
    // The key type of the map.
66 66
    typedef _Item Key;
67
    /// The value type of the map.
67
    // The value type of the map.
68 68
    typedef _Value Value;
69 69

	
70
    /// The notifier type.
70
    // The notifier type.
71 71
    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
72 72

	
73
    /// The map type.
73
    // The map type.
74 74
    typedef VectorMap Map;
75
    /// The base class of the map.
75
    // The base class of the map.
76 76
    typedef typename Notifier::ObserverBase Parent;
77 77

	
78
    /// The reference type of the map;
78
    // The reference type of the map;
79 79
    typedef typename Container::reference Reference;
80
    /// The const reference type of the map;
80
    // The const reference type of the map;
81 81
    typedef typename Container::const_reference ConstReference;
82 82

	
83 83

	
84
    /// \brief Constructor to attach the new map into the notifier.
85
    ///
86
    /// It constructs a map and attachs it into the notifier.
87
    /// It adds all the items of the graph to the map.
84
    // \brief Constructor to attach the new map into the notifier.
85
    //
86
    // It constructs a map and attachs it into the notifier.
87
    // It adds all the items of the graph to the map.
88 88
    VectorMap(const Graph& graph) {
89 89
      Parent::attach(graph.notifier(Item()));
90 90
      container.resize(Parent::notifier()->maxId() + 1);
91 91
    }
92 92

	
93
    /// \brief Constructor uses given value to initialize the map.
94
    ///
95
    /// It constructs a map uses a given value to initialize the map.
96
    /// It adds all the items of the graph to the map.
93
    // \brief Constructor uses given value to initialize the map.
94
    //
95
    // It constructs a map uses a given value to initialize the map.
96
    // It adds all the items of the graph to the map.
97 97
    VectorMap(const Graph& graph, const Value& value) {
98 98
      Parent::attach(graph.notifier(Item()));
99 99
      container.resize(Parent::notifier()->maxId() + 1, value);
100 100
    }
101 101

	
102 102
  private:
103
    /// \brief Copy constructor
104
    ///
105
    /// Copy constructor.
103
    // \brief Copy constructor
104
    //
105
    // Copy constructor.
106 106
    VectorMap(const VectorMap& _copy) : Parent() {
107 107
      if (_copy.attached()) {
108 108
        Parent::attach(*_copy.notifier());
109 109
        container = _copy.container;
110 110
      }
111 111
    }
112 112

	
113
    /// \brief Assign operator.
114
    ///
115
    /// This operator assigns for each item in the map the
116
    /// value mapped to the same item in the copied map.
117
    /// The parameter map should be indiced with the same
118
    /// itemset because this assign operator does not change
119
    /// the container of the map.
113
    // \brief Assign operator.
114
    //
115
    // This operator assigns for each item in the map the
116
    // value mapped to the same item in the copied map.
117
    // The parameter map should be indiced with the same
118
    // itemset because this assign operator does not change
119
    // the container of the map.
120 120
    VectorMap& operator=(const VectorMap& cmap) {
121 121
      return operator=<VectorMap>(cmap);
122 122
    }
123 123

	
124 124

	
125
    /// \brief Template assign operator.
126
    ///
127
    /// The given parameter should be conform to the ReadMap
128
    /// concecpt and could be indiced by the current item set of
129
    /// the NodeMap. In this case the value for each item
130
    /// is assigned by the value of the given ReadMap.
125
    // \brief Template assign operator.
126
    //
127
    // The given parameter should be conform to the ReadMap
128
    // concecpt and could be indiced by the current item set of
129
    // the NodeMap. In this case the value for each item
130
    // is assigned by the value of the given ReadMap.
131 131
    template <typename CMap>
132 132
    VectorMap& operator=(const CMap& cmap) {
133 133
      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
134 134
      const typename Parent::Notifier* nf = Parent::notifier();
135 135
      Item it;
136 136
      for (nf->first(it); it != INVALID; nf->next(it)) {
... ...
@@ -138,96 +138,96 @@
138 138
      }
139 139
      return *this;
140 140
    }
141 141

	
142 142
  public:
143 143

	
144
    /// \brief The subcript operator.
145
    ///
146
    /// The subscript operator. The map can be subscripted by the
147
    /// actual items of the graph.
144
    // \brief The subcript operator.
145
    //
146
    // The subscript operator. The map can be subscripted by the
147
    // actual items of the graph.
148 148
    Reference operator[](const Key& key) {
149 149
      return container[Parent::notifier()->id(key)];
150 150
    }
151 151

	
152
    /// \brief The const subcript operator.
153
    ///
154
    /// The const subscript operator. The map can be subscripted by the
155
    /// actual items of the graph.
152
    // \brief The const subcript operator.
153
    //
154
    // The const subscript operator. The map can be subscripted by the
155
    // actual items of the graph.
156 156
    ConstReference operator[](const Key& key) const {
157 157
      return container[Parent::notifier()->id(key)];
158 158
    }
159 159

	
160 160

	
161
    /// \brief The setter function of the map.
162
    ///
163
    /// It the same as operator[](key) = value expression.
161
    // \brief The setter function of the map.
162
    //
163
    // It the same as operator[](key) = value expression.
164 164
    void set(const Key& key, const Value& value) {
165 165
      (*this)[key] = value;
166 166
    }
167 167

	
168 168
  protected:
169 169

	
170
    /// \brief Adds a new key to the map.
171
    ///
172
    /// It adds a new key to the map. It called by the observer notifier
173
    /// and it overrides the add() member function of the observer base.
170
    // \brief Adds a new key to the map.
171
    //
172
    // It adds a new key to the map. It called by the observer notifier
173
    // and it overrides the add() member function of the observer base.
174 174
    virtual void add(const Key& key) {
175 175
      int id = Parent::notifier()->id(key);
176 176
      if (id >= int(container.size())) {
177 177
        container.resize(id + 1);
178 178
      }
179 179
    }
180 180

	
181
    /// \brief Adds more new keys to the map.
182
    ///
183
    /// It adds more new keys to the map. It called by the observer notifier
184
    /// and it overrides the add() member function of the observer base.
181
    // \brief Adds more new keys to the map.
182
    //
183
    // It adds more new keys to the map. It called by the observer notifier
184
    // and it overrides the add() member function of the observer base.
185 185
    virtual void add(const std::vector<Key>& keys) {
186 186
      int max = container.size() - 1;
187 187
      for (int i = 0; i < int(keys.size()); ++i) {
188 188
        int id = Parent::notifier()->id(keys[i]);
189 189
        if (id >= max) {
190 190
          max = id;
191 191
        }
192 192
      }
193 193
      container.resize(max + 1);
194 194
    }
195 195

	
196
    /// \brief Erase a key from the map.
197
    ///
198
    /// Erase a key from the map. It called by the observer notifier
199
    /// and it overrides the erase() member function of the observer base.
196
    // \brief Erase a key from the map.
197
    //
198
    // Erase a key from the map. It called by the observer notifier
199
    // and it overrides the erase() member function of the observer base.
200 200
    virtual void erase(const Key& key) {
201 201
      container[Parent::notifier()->id(key)] = Value();
202 202
    }
203 203

	
204
    /// \brief Erase more keys from the map.
205
    ///
206
    /// Erase more keys from the map. It called by the observer notifier
207
    /// and it overrides the erase() member function of the observer base.
204
    // \brief Erase more keys from the map.
205
    //
206
    // Erase more keys from the map. It called by the observer notifier
207
    // and it overrides the erase() member function of the observer base.
208 208
    virtual void erase(const std::vector<Key>& keys) {
209 209
      for (int i = 0; i < int(keys.size()); ++i) {
210 210
        container[Parent::notifier()->id(keys[i])] = Value();
211 211
      }
212 212
    }
213 213

	
214
    /// \brief Buildes the map.
215
    ///
216
    /// It buildes the map. It called by the observer notifier
217
    /// and it overrides the build() member function of the observer base.
214
    // \brief Buildes the map.
215
    //
216
    // It buildes the map. It called by the observer notifier
217
    // and it overrides the build() member function of the observer base.
218 218
    virtual void build() {
219 219
      int size = Parent::notifier()->maxId() + 1;
220 220
      container.reserve(size);
221 221
      container.resize(size);
222 222
    }
223 223

	
224
    /// \brief Clear the map.
225
    ///
226
    /// It erase all items from the map. It called by the observer notifier
227
    /// and it overrides the clear() member function of the observer base.
224
    // \brief Clear the map.
225
    //
226
    // It erase all items from the map. It called by the observer notifier
227
    // and it overrides the clear() member function of the observer base.
228 228
    virtual void clear() {
229 229
      container.clear();
230 230
    }
231 231

	
232 232
  private:
233 233

	
Ignore white space 6 line context
... ...
@@ -19,21 +19,21 @@
19 19
#ifndef LEMON_CONCEPT_MAPS_H
20 20
#define LEMON_CONCEPT_MAPS_H
21 21

	
22 22
#include <lemon/core.h>
23 23
#include <lemon/concept_check.h>
24 24

	
25
///\ingroup concept
25
///\ingroup map_concepts
26 26
///\file
27 27
///\brief The concept of maps.
28 28

	
29 29
namespace lemon {
30 30

	
31 31
  namespace concepts {
32 32

	
33
    /// \addtogroup concept
33
    /// \addtogroup map_concepts
34 34
    /// @{
35 35

	
36 36
    /// Readable map concept
37 37

	
38 38
    /// Readable map concept.
39 39
    ///
Ignore white space 6 line context
... ...
@@ -573,13 +573,13 @@
573 573
    return os;
574 574
  }
575 575

	
576 576
  ///Map of x-coordinates of a <tt>Point</tt>-map
577 577

	
578 578
  ///Map of x-coordinates of a \ref Point "Point"-map.
579
  ///\ingroup maps
579
  ///
580 580
  template<class M>
581 581
  class XMap
582 582
  {
583 583
    M& _map;
584 584
  public:
585 585

	
... ...
@@ -591,14 +591,12 @@
591 591
    void set(Key k,Value v) {_map.set(k,typename M::Value(v,_map[k].y));}
592 592
  };
593 593

	
594 594
  ///Returns an XMap class
595 595

	
596 596
  ///This function just returns an XMap class.
597
  ///
598
  ///\ingroup maps
599 597
  ///\relates XMap
600 598
  template<class M>
601 599
  inline XMap<M> xMap(M &m)
602 600
  {
603 601
    return XMap<M>(m);
604 602
  }
... ...
@@ -609,13 +607,13 @@
609 607
    return XMap<M>(m);
610 608
  }
611 609

	
612 610
  ///Constant (read only) version of XMap
613 611

	
614 612
  ///Constant (read only) version of XMap.
615
  ///\ingroup maps
613
  ///
616 614
  template<class M>
617 615
  class ConstXMap
618 616
  {
619 617
    const M& _map;
620 618
  public:
621 619

	
... ...
@@ -626,25 +624,23 @@
626 624
    Value operator[](Key k) const {return _map[k].x;}
627 625
  };
628 626

	
629 627
  ///Returns a ConstXMap class
630 628

	
631 629
  ///This function just returns a ConstXMap class.
632
  ///
633
  ///\ingroup maps
634 630
  ///\relates ConstXMap
635 631
  template<class M>
636 632
  inline ConstXMap<M> xMap(const M &m)
637 633
  {
638 634
    return ConstXMap<M>(m);
639 635
  }
640 636

	
641 637
  ///Map of y-coordinates of a <tt>Point</tt>-map
642 638

	
643 639
  ///Map of y-coordinates of a \ref Point "Point"-map.
644
  ///\ingroup maps
640
  ///
645 641
  template<class M>
646 642
  class YMap
647 643
  {
648 644
    M& _map;
649 645
  public:
650 646

	
... ...
@@ -656,14 +652,12 @@
656 652
    void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}
657 653
  };
658 654

	
659 655
  ///Returns a YMap class
660 656

	
661 657
  ///This function just returns a YMap class.
662
  ///
663
  ///\ingroup maps
664 658
  ///\relates YMap
665 659
  template<class M>
666 660
  inline YMap<M> yMap(M &m)
667 661
  {
668 662
    return YMap<M>(m);
669 663
  }
... ...
@@ -674,13 +668,13 @@
674 668
    return YMap<M>(m);
675 669
  }
676 670

	
677 671
  ///Constant (read only) version of YMap
678 672

	
679 673
  ///Constant (read only) version of YMap.
680
  ///\ingroup maps
674
  ///
681 675
  template<class M>
682 676
  class ConstYMap
683 677
  {
684 678
    const M& _map;
685 679
  public:
686 680

	
... ...
@@ -691,27 +685,24 @@
691 685
    Value operator[](Key k) const {return _map[k].y;}
692 686
  };
693 687

	
694 688
  ///Returns a ConstYMap class
695 689

	
696 690
  ///This function just returns a ConstYMap class.
697
  ///
698
  ///\ingroup maps
699 691
  ///\relates ConstYMap
700 692
  template<class M>
701 693
  inline ConstYMap<M> yMap(const M &m)
702 694
  {
703 695
    return ConstYMap<M>(m);
704 696
  }
705 697

	
706 698

	
707 699
  ///\brief Map of the normSquare() of a <tt>Point</tt>-map
708 700
  ///
709 701
  ///Map of the \ref Point::normSquare() "normSquare()"
710 702
  ///of a \ref Point "Point"-map.
711
  ///\ingroup maps
712 703
  template<class M>
713 704
  class NormSquareMap
714 705
  {
715 706
    const M& _map;
716 707
  public:
717 708

	
... ...
@@ -722,14 +713,12 @@
722 713
    Value operator[](Key k) const {return _map[k].normSquare();}
723 714
  };
724 715

	
725 716
  ///Returns a NormSquareMap class
726 717

	
727 718
  ///This function just returns a NormSquareMap class.
728
  ///
729
  ///\ingroup maps
730 719
  ///\relates NormSquareMap
731 720
  template<class M>
732 721
  inline NormSquareMap<M> normSquareMap(const M &m)
733 722
  {
734 723
    return NormSquareMap<M>(m);
735 724
  }
Ignore white space 6 line context
... ...
@@ -1680,12 +1680,17 @@
1680 1680
    {
1681 1681
      typedef typename _Iterator::container_type::value_type Value;
1682 1682
    };
1683 1683

	
1684 1684
  }
1685 1685

	
1686
  /// @}
1687

	
1688
  /// \addtogroup maps
1689
  /// @{
1690

	
1686 1691
  /// \brief Writable bool map for logging each \c true assigned element
1687 1692
  ///
1688 1693
  /// A \ref concepts::WriteMap "writable" bool map for logging
1689 1694
  /// each \c true assigned element, i.e it copies subsequently each
1690 1695
  /// keys set to \c true to the given iterator.
1691 1696
  /// The most important usage of it is storing certain nodes or arcs
... ...
@@ -1772,12 +1777,17 @@
1772 1777
  /// \relates LoggerBoolMap
1773 1778
  template<typename Iterator>
1774 1779
  inline LoggerBoolMap<Iterator> loggerBoolMap(Iterator it) {
1775 1780
    return LoggerBoolMap<Iterator>(it);
1776 1781
  }
1777 1782

	
1783
  /// @}
1784

	
1785
  /// \addtogroup graph_maps
1786
  /// @{
1787

	
1778 1788
  /// Provides an immutable and unique id for each item in the graph.
1779 1789

	
1780 1790
  /// The IdMap class provides a unique and immutable id for each item of the
1781 1791
  /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
1782 1792
  /// different items (nodes) get different ids <li>\b immutable: the id of an
1783 1793
  /// item (node) does not change (even if you delete other nodes).  </ul>
... ...
@@ -1879,14 +1889,12 @@
1879 1889

	
1880 1890
    /// The key type of InvertableMap (Node, Arc, Edge).
1881 1891
    typedef typename Map::Key Key;
1882 1892
    /// The value type of the InvertableMap.
1883 1893
    typedef typename Map::Value Value;
1884 1894

	
1885

	
1886

	
1887 1895
    /// \brief Constructor.
1888 1896
    ///
1889 1897
    /// Construct a new InvertableMap for the graph.
1890 1898
    ///
1891 1899
    explicit InvertableMap(const Graph& graph) : Map(graph) {}
1892 1900

	
... ...
@@ -2046,14 +2054,12 @@
2046 2054
    ///
2047 2055
    /// It gives back the just readable inverse map.
2048 2056
    InverseMap inverse() const {
2049 2057
      return InverseMap(*this);
2050 2058
    }
2051 2059

	
2052

	
2053

	
2054 2060
  };
2055 2061

	
2056 2062
  /// \brief Provides a mutable, continuous and unique descriptor for each
2057 2063
  /// item in the graph.
2058 2064
  ///
2059 2065
  /// The DescriptorMap class provides a unique and continuous (but mutable)
Ignore white space 6 line context
... ...
@@ -308,14 +308,14 @@
308 308
    ///
309 309
    Timer(bool run=true) :_running(run) {_reset();}
310 310

	
311 311
    ///\name Control the state of the timer
312 312
    ///Basically a Timer can be either running or stopped,
313 313
    ///but it provides a bit finer control on the execution.
314
    ///The \ref lemon::Timer "Timer" also counts the number of 
315
    ///\ref lemon::Timer::start() "start()" executions, and it stops 
314
    ///The \ref lemon::Timer "Timer" also counts the number of
315
    ///\ref lemon::Timer::start() "start()" executions, and it stops
316 316
    ///only after the same amount (or more) \ref lemon::Timer::stop()
317 317
    ///"stop()"s. This can be useful e.g. to compute the running time
318 318
    ///of recursive functions.
319 319

	
320 320
    ///@{
321 321

	
0 comments (0 inline)