Changeset 1620:09feafe81053 in lemon0.x for lemon/concept
 Timestamp:
 08/11/05 15:07:54 (14 years ago)
 Branch:
 default
 Phase:
 public
 Convert:
 svn:c9d7d8f590d60310b91f818b3a526b0e/lemon/trunk@2128
 Location:
 lemon/concept
 Files:

 3 edited
Legend:
 Unmodified
 Added
 Removed

lemon/concept/graph.h
r1563 r1620 32 32 33 33 34 /// \addtogroup graph_concepts35 /// @{36 37 34 /**************** The fullfeatured graph concepts ****************/ 38 35 … … 101 98 }; 102 99 }; 100 101 /// \addtogroup graph_concepts 102 /// @{ 103 103 104 104 /// An empty static graph class. … … 253 253 /// Inequality operator 254 254 255 /// \sa operator==( Node n)255 /// \sa operator==(Edge n) 256 256 /// 257 257 bool operator!=(Edge) const { return true; } 
lemon/concept/graph_component.h
r1563 r1620 30 30 namespace lemon { 31 31 namespace concept { 32 33 /// \addtogroup graph_concepts34 /// @{35 32 36 33 /**************** Graph iterator concepts ****************/ … … 997 994 }; 998 995 999 /// @}1000 1001 996 } 1002 997 
lemon/concept/undir_graph.h
r1448 r1620 27 27 28 28 #include <lemon/concept/graph_component.h> 29 #include <lemon/concept/graph.h> 29 30 #include <lemon/utility.h> 30 31 31 32 namespace lemon { 32 33 namespace concept { 33 34 /// \addtogroup graph_concepts35 /// @{36 37 34 38 35 /// Skeleton class which describes an edge with direction in \ref … … 109 106 checkConcept<BaseIterableGraphComponent, Graph>(); 110 107 checkConcept<GraphItem<>, UndirEdge>(); 111 checkConcept<UndirGraphEdge<Graph>, Edge>();108 //checkConcept<UndirGraphEdge<Graph>, Edge>(); 112 109 113 110 graph.first(ue); … … 217 214 218 215 }; 216 217 /// \addtogroup graph_concepts 218 /// @{ 219 219 220 220 221 /// Class describing the concept of Undirected Graphs. … … 233 234 /// a tutorial about undirected graphs. 234 235 235 class UndirGraph {236 class UndirGraph : public StaticGraph { 236 237 public: 237 238 ///\e … … 241 242 typedef True UndirTag; 242 243 243 /// Type describing a node in the graph 244 typedef GraphNode Node; 245 246 /// Type describing an undirected edge 247 typedef GraphItem<'u'> UndirEdge; 248 249 /// Type describing an UndirEdge with direction 250 #ifndef DOXYGEN 251 typedef UndirGraphEdge<UndirGraph> Edge; 252 #else 253 typedef UndirGraphEdge Edge; 254 #endif 255 256 /// Iterator type which iterates over all nodes 257 #ifndef DOXYGEN 258 typedef GraphIterator<UndirGraph, Node> NodeIt; 259 #else 260 typedef GraphIterator NodeIt; 261 #endif 262 263 /// Iterator type which iterates over all undirected edges 264 #ifndef DOXYGEN 265 typedef GraphIterator<UndirGraph, UndirEdge> UndirEdgeIt; 266 #else 267 typedef GraphIterator UndirEdgeIt; 268 #endif 269 270 /// Iterator type which iterates over all directed edges. 271 272 /// Iterator type which iterates over all edges (each undirected 273 /// edge occurs twice with both directions. 274 #ifndef DOXYGEN 275 typedef GraphIterator<UndirGraph, Edge> EdgeIt; 276 #else 277 typedef GraphIterator EdgeIt; 278 #endif 279 280 281 /// Iterator of undirected edges incident to a node 282 #ifndef DOXYGEN 283 typedef GraphIncIterator<UndirGraph, UndirEdge, 'u'> IncEdgeIt; 284 #else 285 typedef GraphIncIterator IncEdgeIt; 286 #endif 287 288 /// Iterator of edges incoming to a node 289 #ifndef DOXYGEN 290 typedef GraphIncIterator<UndirGraph, Edge, 'i'> InEdgeIt; 291 #else 292 typedef GraphIncIterator InEdgeIt; 293 #endif 294 295 /// Iterator of edges outgoing from a node 296 #ifndef DOXYGEN 297 typedef GraphIncIterator<UndirGraph, Edge, 'o'> OutEdgeIt; 298 #else 299 typedef GraphIncIterator OutEdgeIt; 300 #endif 301 302 /// NodeMap template 303 #ifdef DOXYGEN 304 typedef GraphMap NodeMap<T>; 305 #endif 306 307 /// UndirEdgeMap template 308 #ifdef DOXYGEN 309 typedef GraphMap UndirEdgeMap<T>; 310 #endif 311 312 /// EdgeMap template 313 #ifdef DOXYGEN 314 typedef GraphMap EdgeMap<T>; 315 #endif 316 317 template <typename T> 318 class NodeMap : public GraphMap<UndirGraph, Node, T> { 319 typedef GraphMap<UndirGraph, Node, T> Parent; 244 /// The base type of the undirected edge iterators. 245 246 /// The base type of the undirected edge iterators. 247 /// 248 class UndirEdge { 320 249 public: 321 322 explicit NodeMap(const UndirGraph &g) : Parent(g) {} 323 NodeMap(const UndirGraph &g, T t) : Parent(g, t) {} 324 }; 325 326 template <typename T> 327 class UndirEdgeMap : public GraphMap<UndirGraph, UndirEdge, T> { 328 typedef GraphMap<UndirGraph, UndirEdge, T> Parent; 250 /// Default constructor 251 252 /// @warning The default constructor sets the iterator 253 /// to an undefined value. 254 UndirEdge() { } 255 /// Copy constructor. 256 257 /// Copy constructor. 258 /// 259 UndirEdge(const UndirEdge&) { } 260 /// Edge > UndirEdge conversion 261 262 /// Edge > UndirEdge conversion 263 /// 264 UndirEdge(const Edge&) { } 265 /// Initialize the iterator to be invalid. 266 267 /// Initialize the iterator to be invalid. 268 /// 269 UndirEdge(Invalid) { } 270 /// Equality operator 271 272 /// Two iterators are equal if and only if they point to the 273 /// same object or both are invalid. 274 bool operator==(UndirEdge) const { return true; } 275 /// Inequality operator 276 277 /// \sa operator==(UndirEdge n) 278 /// 279 bool operator!=(UndirEdge) const { return true; } 280 281 ///\e 282 283 ///\todo Do we need this? 284 /// 285 bool operator<(const UndirEdge &that) const { return true; } 286 }; 287 288 /// This iterator goes through each undirected edge. 289 290 /// This iterator goes through each undirected edge of a graph. 291 /// Its usage is quite simple, for example you can count the number 292 /// of edges in a graph \c g of type \c Graph as follows: 293 /// \code 294 /// int count=0; 295 /// for(Graph::UndirEdgeIt e(g); e!=INVALID; ++e) ++count; 296 /// \endcode 297 class UndirEdgeIt : public UndirEdge { 329 298 public: 330 331 explicit UndirEdgeMap(const UndirGraph &g) : Parent(g) {} 332 UndirEdgeMap(const UndirGraph &g, T t) : Parent(g, t) {} 333 }; 334 335 template <typename T> 336 class EdgeMap : public GraphMap<UndirGraph, Edge, T> { 337 typedef GraphMap<UndirGraph, Edge, T> Parent; 299 /// Default constructor 300 301 /// @warning The default constructor sets the iterator 302 /// to an undefined value. 303 UndirEdgeIt() { } 304 /// Copy constructor. 305 306 /// Copy constructor. 307 /// 308 UndirEdgeIt(const UndirEdgeIt& e) : UndirEdge(e) { } 309 /// Initialize the iterator to be invalid. 310 311 /// Initialize the iterator to be invalid. 312 /// 313 UndirEdgeIt(Invalid) { } 314 /// This constructor sets the iterator to the first edge. 315 316 /// This constructor sets the iterator to the first edge of \c g. 317 ///@param g the graph 318 UndirEdgeIt(const UndirGraph&) { } 319 /// UndirEdge > UndirEdgeIt conversion 320 321 /// Sets the iterator to the value of the trivial iterator \c e. 322 /// This feature necessitates that each time we 323 /// iterate the edgeset, the iteration order is the same. 324 UndirEdgeIt(const UndirGraph&, const UndirEdge&) { } 325 ///Next edge 326 327 /// Assign the iterator to the next edge. 328 UndirEdgeIt& operator++() { return *this; } 329 }; 330 331 /// This iterator goes trough the incident undirected edges of a node. 332 333 /// This iterator goes trough the incident undirected edges 334 /// of a certain node 335 /// of a graph. 336 /// Its usage is quite simple, for example you can compute the 337 /// degree (i.e. count the number 338 /// of incident edges of a node \c n 339 /// in graph \c g of type \c Graph as follows. 340 /// \code 341 /// int count=0; 342 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; 343 /// \endcode 344 class IncEdgeIt : public UndirEdge { 338 345 public: 339 340 explicit EdgeMap(const UndirGraph &g) : Parent(g) {} 341 EdgeMap(const UndirGraph &g, T t) : Parent(g, t) {} 346 /// Default constructor 347 348 /// @warning The default constructor sets the iterator 349 /// to an undefined value. 350 IncEdgeIt() { } 351 /// Copy constructor. 352 353 /// Copy constructor. 354 /// 355 IncEdgeIt(const IncEdgeIt& e) : UndirEdge(e) { } 356 /// Initialize the iterator to be invalid. 357 358 /// Initialize the iterator to be invalid. 359 /// 360 IncEdgeIt(Invalid) { } 361 /// This constructor sets the iterator to first incident edge. 362 363 /// This constructor set the iterator to the first incident edge of 364 /// the node. 365 ///@param n the node 366 ///@param g the graph 367 IncEdgeIt(const UndirGraph&, const Node&) { } 368 /// UndirEdge > IncEdgeIt conversion 369 370 /// Sets the iterator to the value of the trivial iterator \c e. 371 /// This feature necessitates that each time we 372 /// iterate the edgeset, the iteration order is the same. 373 IncEdgeIt(const UndirGraph&, const UndirEdge&) { } 374 /// Next incident edge 375 376 /// Assign the iterator to the next incident edge 377 /// of the corresponding node. 378 IncEdgeIt& operator++() { return *this; } 379 }; 380 381 /// Read write map of the undirected edges to type \c T. 382 383 /// Reference map of the edges to type \c T. 384 /// \sa Reference 385 /// \warning Making maps that can handle bool type (UndirEdgeMap<bool>) 386 /// needs some extra attention! 387 template<class T> 388 class UndirEdgeMap : public ReadWriteMap<UndirEdge,T> 389 { 390 public: 391 392 ///\e 393 UndirEdgeMap(const UndirGraph&) { } 394 ///\e 395 UndirEdgeMap(const UndirGraph&, T) { } 396 ///Copy constructor 397 UndirEdgeMap(const UndirEdgeMap& em) : ReadWriteMap<UndirEdge,T>(em) { } 398 ///Assignment operator 399 UndirEdgeMap &operator=(const UndirEdgeMap&) { return *this; } 400 // \todo fix this concept 342 401 }; 343 402
Note: See TracChangeset
for help on using the changeset viewer.