Changeset 2031:080d51024ac5 in lemon-0.x
- Timestamp:
- 04/03/06 11:45:23 (19 years ago)
- Branch:
- default
- Phase:
- public
- Convert:
- svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2670
- Location:
- lemon
- Files:
-
- 1 added
- 17 edited
Legend:
- Unmodified
- Added
- Removed
-
lemon/Makefile.am
r2017 r2031 28 28 dfs.h \ 29 29 bin_heap.h \ 30 bpugraph_adaptor.h \ 30 31 color.h \ 31 32 config.h \ -
lemon/bits/array_map.h
r1999 r2031 24 24 #include <lemon/bits/traits.h> 25 25 #include <lemon/bits/alteration_notifier.h> 26 #include <lemon/concept_check.h> 27 #include <lemon/concept/maps.h> 26 28 27 29 /// \ingroup graphbits … … 120 122 } 121 123 124 /// \brief Assign operator. 125 /// 126 /// This operator assigns for each item in the map the 127 /// value mapped to the same item in the copied map. 128 /// The parameter map should be indiced with the same 129 /// itemset because this assign operator does not change 130 /// the container of the map. 131 ArrayMap& operator=(const ArrayMap& cmap) { 132 return operator=<ArrayMap>(cmap); 133 } 134 135 136 /// \brief Template assign operator. 137 /// 138 /// The given parameter should be conform to the ReadMap 139 /// concecpt and could be indiced by the current item set of 140 /// the NodeMap. In this case the value for each item 141 /// is assigned by the value of the given ReadMap. 142 template <typename CMap> 143 ArrayMap& operator=(const CMap& cmap) { 144 checkConcept<concept::ReadMap<Key, _Value>, CMap>(); 145 const typename Parent::Notifier* notifier = Parent::getNotifier(); 146 Item it; 147 for (notifier->first(it); it != INVALID; notifier->next(it)) { 148 set(it, cmap[it]); 149 } 150 return *this; 151 } 152 122 153 /// \brief The destructor of the map. 123 154 /// … … 130 161 } 131 162 132 private:133 134 ArrayMap& operator=(const ArrayMap&);135 136 163 protected: 137 164 -
lemon/bits/base_extender.h
r1999 r2031 467 467 return Edge(edge, direction); 468 468 } 469 470 int edgeNum() const { 471 return 2 * Parent::edgeNum(); 472 } 473 474 int uEdgeNum() const { 475 return Parent::edgeNum(); 476 } 477 469 478 }; 470 479 -
lemon/bits/default_map.h
r1999 r2031 164 164 : Parent(graph, value) {} 165 165 166 DefaultMap& operator=(const DefaultMap& cmap) { 167 return operator=<DefaultMap>(cmap); 168 } 169 170 template <typename CMap> 171 DefaultMap& operator=(const CMap& cmap) { 172 Parent::operator=(cmap); 173 return *this; 174 } 175 166 176 }; 167 177 -
lemon/bits/edge_set_extender.h
r1999 r2031 102 102 103 103 explicit NodeIt(const Graph& _graph) : graph(&_graph) { 104 _graph.first( *static_cast<Node*>(this));104 _graph.first(static_cast<Node&>(*this)); 105 105 } 106 106 … … 125 125 126 126 explicit EdgeIt(const Graph& _graph) : graph(&_graph) { 127 _graph.first( *static_cast<Edge*>(this));127 _graph.first(static_cast<Edge&>(*this)); 128 128 } 129 129 … … 236 236 template <typename CMap> 237 237 EdgeMap& operator=(const CMap& cmap) { 238 checkConcept<concept::ReadMap<Edge, _Value>, CMap>(); 239 const typename Parent::Graph* graph = Parent::getGraph(); 240 Edge it; 241 for (graph->first(it); it != INVALID; graph->next(it)) { 242 Parent::set(it, cmap[it]); 243 } 238 Parent::operator=(cmap); 244 239 return *this; 245 240 } 241 246 242 }; 247 243 … … 365 361 366 362 explicit NodeIt(const Graph& _graph) : graph(&_graph) { 367 _graph.first( *static_cast<Node*>(this));363 _graph.first(static_cast<Node&>(*this)); 368 364 } 369 365 … … 388 384 389 385 explicit EdgeIt(const Graph& _graph) : graph(&_graph) { 390 _graph.first( *static_cast<Edge*>(this));386 _graph.first(static_cast<Edge&>(*this)); 391 387 } 392 388 … … 459 455 460 456 explicit UEdgeIt(const Graph& _graph) : graph(&_graph) { 461 _graph.first( *static_cast<UEdge*>(this));457 _graph.first(static_cast<UEdge&>(*this)); 462 458 } 463 459 … … 557 553 template <typename CMap> 558 554 EdgeMap& operator=(const CMap& cmap) { 559 checkConcept<concept::ReadMap<Edge, _Value>, CMap>(); 560 const typename Parent::Graph* graph = Parent::getGraph(); 561 Edge it; 562 for (graph->first(it); it != INVALID; graph->next(it)) { 563 Parent::set(it, cmap[it]); 564 } 555 Parent::operator=(cmap); 565 556 return *this; 566 557 } 558 567 559 }; 568 560 … … 577 569 UEdgeMap(const Graph& _g) 578 570 : Parent(_g) {} 571 579 572 UEdgeMap(const Graph& _g, const _Value& _v) 580 573 : Parent(_g, _v) {} … … 586 579 template <typename CMap> 587 580 UEdgeMap& operator=(const CMap& cmap) { 588 checkConcept<concept::ReadMap<UEdge, _Value>, CMap>(); 589 const typename Parent::Graph* graph = Parent::getGraph(); 590 UEdge it; 591 for (graph->first(it); it != INVALID; graph->next(it)) { 592 Parent::set(it, cmap[it]); 593 } 581 Parent::operator=(cmap); 594 582 return *this; 595 583 } 584 596 585 }; 597 586 -
lemon/bits/graph_adaptor_extender.h
r1996 r2031 34 34 /// 35 35 /// \brief Extender for the GraphAdaptors 36 template <typename Base>37 class GraphAdaptorExtender : public Base{36 template <typename _Graph> 37 class GraphAdaptorExtender : public _Graph { 38 38 public: 39 39 40 typedef Base Parent; 41 typedef GraphAdaptorExtender Graph; 40 typedef _Graph Parent; 41 typedef _Graph Graph; 42 typedef GraphAdaptorExtender Adaptor; 42 43 43 44 // Base extensions … … 72 73 73 74 class NodeIt : public Node { 74 const Graph* graph;75 const Adaptor* graph; 75 76 public: 76 77 … … 79 80 NodeIt(Invalid i) : Node(i) { } 80 81 81 explicit NodeIt(const Graph& _graph) : graph(&_graph) {82 _graph.first( *static_cast<Node*>(this));83 } 84 85 NodeIt(const Graph& _graph, const Node& node)82 explicit NodeIt(const Adaptor& _graph) : graph(&_graph) { 83 _graph.first(static_cast<Node&>(*this)); 84 } 85 86 NodeIt(const Adaptor& _graph, const Node& node) 86 87 : Node(node), graph(&_graph) {} 87 88 … … 95 96 96 97 class EdgeIt : public Edge { 97 const Graph* graph;98 const Adaptor* graph; 98 99 public: 99 100 … … 102 103 EdgeIt(Invalid i) : Edge(i) { } 103 104 104 explicit EdgeIt(const Graph& _graph) : graph(&_graph) {105 _graph.first( *static_cast<Edge*>(this));106 } 107 108 EdgeIt(const Graph& _graph, const Edge& e) :105 explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) { 106 _graph.first(static_cast<Edge&>(*this)); 107 } 108 109 EdgeIt(const Adaptor& _graph, const Edge& e) : 109 110 Edge(e), graph(&_graph) { } 110 111 … … 118 119 119 120 class OutEdgeIt : public Edge { 120 const Graph* graph;121 const Adaptor* graph; 121 122 public: 122 123 … … 125 126 OutEdgeIt(Invalid i) : Edge(i) { } 126 127 127 OutEdgeIt(const Graph& _graph, const Node& node)128 OutEdgeIt(const Adaptor& _graph, const Node& node) 128 129 : graph(&_graph) { 129 130 _graph.firstOut(*this, node); 130 131 } 131 132 132 OutEdgeIt(const Graph& _graph, const Edge& edge)133 OutEdgeIt(const Adaptor& _graph, const Edge& edge) 133 134 : Edge(edge), graph(&_graph) {} 134 135 … … 142 143 143 144 class InEdgeIt : public Edge { 144 const Graph* graph;145 const Adaptor* graph; 145 146 public: 146 147 … … 149 150 InEdgeIt(Invalid i) : Edge(i) { } 150 151 151 InEdgeIt(const Graph& _graph, const Node& node)152 InEdgeIt(const Adaptor& _graph, const Node& node) 152 153 : graph(&_graph) { 153 154 _graph.firstIn(*this, node); 154 155 } 155 156 156 InEdgeIt(const Graph& _graph, const Edge& edge) :157 InEdgeIt(const Adaptor& _graph, const Edge& edge) : 157 158 Edge(edge), graph(&_graph) {} 158 159 … … 198 199 /// 199 200 /// \brief Extender for the UGraphAdaptors 200 template <typename Base>201 class UGraphAdaptorExtender : public Base{201 template <typename _UGraph> 202 class UGraphAdaptorExtender : public _UGraph { 202 203 public: 203 204 204 typedef Base Parent; 205 typedef UGraphAdaptorExtender Graph; 205 typedef _UGraph Parent; 206 typedef _UGraph UGraph; 207 typedef UGraphAdaptorExtender Adaptor; 206 208 207 209 typedef typename Parent::Node Node; … … 255 257 256 258 class NodeIt : public Node { 257 const Graph* graph;259 const Adaptor* graph; 258 260 public: 259 261 … … 262 264 NodeIt(Invalid i) : Node(i) { } 263 265 264 explicit NodeIt(const Graph& _graph) : graph(&_graph) {265 _graph.first( *static_cast<Node*>(this));266 } 267 268 NodeIt(const Graph& _graph, const Node& node)266 explicit NodeIt(const Adaptor& _graph) : graph(&_graph) { 267 _graph.first(static_cast<Node&>(*this)); 268 } 269 270 NodeIt(const Adaptor& _graph, const Node& node) 269 271 : Node(node), graph(&_graph) {} 270 272 … … 278 280 279 281 class EdgeIt : public Edge { 280 const Graph* graph;282 const Adaptor* graph; 281 283 public: 282 284 … … 285 287 EdgeIt(Invalid i) : Edge(i) { } 286 288 287 explicit EdgeIt(const Graph& _graph) : graph(&_graph) {288 _graph.first( *static_cast<Edge*>(this));289 } 290 291 EdgeIt(const Graph& _graph, const Edge& e) :289 explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) { 290 _graph.first(static_cast<Edge&>(*this)); 291 } 292 293 EdgeIt(const Adaptor& _graph, const Edge& e) : 292 294 Edge(e), graph(&_graph) { } 293 295 … … 301 303 302 304 class OutEdgeIt : public Edge { 303 const Graph* graph;305 const Adaptor* graph; 304 306 public: 305 307 … … 308 310 OutEdgeIt(Invalid i) : Edge(i) { } 309 311 310 OutEdgeIt(const Graph& _graph, const Node& node)312 OutEdgeIt(const Adaptor& _graph, const Node& node) 311 313 : graph(&_graph) { 312 314 _graph.firstOut(*this, node); 313 315 } 314 316 315 OutEdgeIt(const Graph& _graph, const Edge& edge)317 OutEdgeIt(const Adaptor& _graph, const Edge& edge) 316 318 : Edge(edge), graph(&_graph) {} 317 319 … … 325 327 326 328 class InEdgeIt : public Edge { 327 const Graph* graph;329 const Adaptor* graph; 328 330 public: 329 331 … … 332 334 InEdgeIt(Invalid i) : Edge(i) { } 333 335 334 InEdgeIt(const Graph& _graph, const Node& node)336 InEdgeIt(const Adaptor& _graph, const Node& node) 335 337 : graph(&_graph) { 336 338 _graph.firstIn(*this, node); 337 339 } 338 340 339 InEdgeIt(const Graph& _graph, const Edge& edge) :341 InEdgeIt(const Adaptor& _graph, const Edge& edge) : 340 342 Edge(edge), graph(&_graph) {} 341 343 … … 348 350 349 351 class UEdgeIt : public Parent::UEdge { 350 const Graph* graph;352 const Adaptor* graph; 351 353 public: 352 354 … … 355 357 UEdgeIt(Invalid i) : UEdge(i) { } 356 358 357 explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {358 _graph.first( *static_cast<UEdge*>(this));359 } 360 361 UEdgeIt(const Graph& _graph, const UEdge& e) :359 explicit UEdgeIt(const Adaptor& _graph) : graph(&_graph) { 360 _graph.first(static_cast<UEdge&>(*this)); 361 } 362 363 UEdgeIt(const Adaptor& _graph, const UEdge& e) : 362 364 UEdge(e), graph(&_graph) { } 363 365 … … 371 373 class IncEdgeIt : public Parent::UEdge { 372 374 friend class UGraphAdaptorExtender; 373 const Graph* graph;375 const Adaptor* graph; 374 376 bool direction; 375 377 public: … … 379 381 IncEdgeIt(Invalid i) : UEdge(i), direction(false) { } 380 382 381 IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {383 IncEdgeIt(const Adaptor& _graph, const Node &n) : graph(&_graph) { 382 384 _graph.firstInc(static_cast<UEdge&>(*this), direction, n); 383 385 } 384 386 385 IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)387 IncEdgeIt(const Adaptor& _graph, const UEdge &ue, const Node &n) 386 388 : graph(&_graph), UEdge(ue) { 387 389 direction = (_graph.source(ue) == n); … … 437 439 }; 438 440 441 /// \ingroup graphbits 442 /// 443 /// \brief Extender for the BpUGraphAdaptors 444 template <typename Base> 445 class BpUGraphAdaptorExtender : public Base { 446 public: 447 typedef Base Parent; 448 typedef BpUGraphAdaptorExtender Graph; 449 450 typedef typename Parent::Node Node; 451 typedef typename Parent::BNode BNode; 452 typedef typename Parent::ANode ANode; 453 typedef typename Parent::Edge Edge; 454 typedef typename Parent::UEdge UEdge; 455 456 Node oppositeNode(const UEdge& edge, const Node& node) const { 457 return source(edge) == node ? 458 target(edge) : source(edge); 459 } 460 461 462 int maxId(Node) const { 463 return Parent::maxNodeId(); 464 } 465 int maxId(BNode) const { 466 return Parent::maxBNodeId(); 467 } 468 int maxId(ANode) const { 469 return Parent::maxANodeId(); 470 } 471 int maxId(Edge) const { 472 return Parent::maxEdgeId(); 473 } 474 int maxId(UEdge) const { 475 return Parent::maxUEdgeId(); 476 } 477 478 479 Node fromId(int id, Node) const { 480 return Parent::nodeFromId(id); 481 } 482 ANode fromId(int id, ANode) const { 483 return Parent::fromANodeId(id); 484 } 485 BNode fromId(int id, BNode) const { 486 return Parent::fromBNodeId(id); 487 } 488 Edge fromId(int id, Edge) const { 489 return Parent::edgeFromId(id); 490 } 491 UEdge fromId(int id, UEdge) const { 492 return Parent::uEdgeFromId(id); 493 } 494 495 class NodeIt : public Node { 496 const Graph* graph; 497 public: 498 499 NodeIt() { } 500 501 NodeIt(Invalid i) : Node(INVALID) { } 502 503 explicit NodeIt(const Graph& _graph) : graph(&_graph) { 504 graph->first(static_cast<Node&>(*this)); 505 } 506 507 NodeIt(const Graph& _graph, const Node& node) 508 : Node(node), graph(&_graph) { } 509 510 NodeIt& operator++() { 511 graph->next(*this); 512 return *this; 513 } 514 515 }; 516 517 class ANodeIt : public Node { 518 friend class BpUGraphAdaptorExtender; 519 const Graph* graph; 520 public: 521 522 ANodeIt() { } 523 524 ANodeIt(Invalid i) : Node(INVALID) { } 525 526 explicit ANodeIt(const Graph& _graph) : graph(&_graph) { 527 graph->firstANode(static_cast<Node&>(*this)); 528 } 529 530 ANodeIt(const Graph& _graph, const Node& node) 531 : Node(node), graph(&_graph) {} 532 533 ANodeIt& operator++() { 534 graph->nextANode(*this); 535 return *this; 536 } 537 }; 538 539 class BNodeIt : public Node { 540 friend class BpUGraphAdaptorExtender; 541 const Graph* graph; 542 public: 543 544 BNodeIt() { } 545 546 BNodeIt(Invalid i) : Node(INVALID) { } 547 548 explicit BNodeIt(const Graph& _graph) : graph(&_graph) { 549 graph->firstBNode(static_cast<Node&>(*this)); 550 } 551 552 BNodeIt(const Graph& _graph, const Node& node) 553 : Node(node), graph(&_graph) {} 554 555 BNodeIt& operator++() { 556 graph->nextBNode(*this); 557 return *this; 558 } 559 }; 560 561 class EdgeIt : public Edge { 562 friend class BpUGraphAdaptorExtender; 563 const Graph* graph; 564 public: 565 566 EdgeIt() { } 567 568 EdgeIt(Invalid i) : Edge(INVALID) { } 569 570 explicit EdgeIt(const Graph& _graph) : graph(&_graph) { 571 graph->first(static_cast<Edge&>(*this)); 572 } 573 574 EdgeIt(const Graph& _graph, const Edge& edge) 575 : Edge(edge), graph(&_graph) { } 576 577 EdgeIt& operator++() { 578 graph->next(*this); 579 return *this; 580 } 581 582 }; 583 584 class UEdgeIt : public UEdge { 585 friend class BpUGraphAdaptorExtender; 586 const Graph* graph; 587 public: 588 589 UEdgeIt() { } 590 591 UEdgeIt(Invalid i) : UEdge(INVALID) { } 592 593 explicit UEdgeIt(const Graph& _graph) : graph(&_graph) { 594 graph->first(static_cast<UEdge&>(*this)); 595 } 596 597 UEdgeIt(const Graph& _graph, const UEdge& edge) 598 : UEdge(edge), graph(&_graph) { } 599 600 UEdgeIt& operator++() { 601 graph->next(*this); 602 return *this; 603 } 604 }; 605 606 class OutEdgeIt : public Edge { 607 friend class BpUGraphAdaptorExtender; 608 const Graph* graph; 609 public: 610 611 OutEdgeIt() { } 612 613 OutEdgeIt(Invalid i) : Edge(i) { } 614 615 OutEdgeIt(const Graph& _graph, const Node& node) 616 : graph(&_graph) { 617 graph->firstOut(*this, node); 618 } 619 620 OutEdgeIt(const Graph& _graph, const Edge& edge) 621 : Edge(edge), graph(&_graph) {} 622 623 OutEdgeIt& operator++() { 624 graph->nextOut(*this); 625 return *this; 626 } 627 628 }; 629 630 631 class InEdgeIt : public Edge { 632 friend class BpUGraphAdaptorExtender; 633 const Graph* graph; 634 public: 635 636 InEdgeIt() { } 637 638 InEdgeIt(Invalid i) : Edge(i) { } 639 640 InEdgeIt(const Graph& _graph, const Node& node) 641 : graph(&_graph) { 642 graph->firstIn(*this, node); 643 } 644 645 InEdgeIt(const Graph& _graph, const Edge& edge) : 646 Edge(edge), graph(&_graph) {} 647 648 InEdgeIt& operator++() { 649 graph->nextIn(*this); 650 return *this; 651 } 652 653 }; 654 655 /// \brief Base node of the iterator 656 /// 657 /// Returns the base node (ie. the source in this case) of the iterator 658 Node baseNode(const OutEdgeIt &e) const { 659 return Parent::source((Edge&)e); 660 } 661 /// \brief Running node of the iterator 662 /// 663 /// Returns the running node (ie. the target in this case) of the 664 /// iterator 665 Node runningNode(const OutEdgeIt &e) const { 666 return Parent::target((Edge&)e); 667 } 668 669 /// \brief Base node of the iterator 670 /// 671 /// Returns the base node (ie. the target in this case) of the iterator 672 Node baseNode(const InEdgeIt &e) const { 673 return Parent::target((Edge&)e); 674 } 675 /// \brief Running node of the iterator 676 /// 677 /// Returns the running node (ie. the source in this case) of the 678 /// iterator 679 Node runningNode(const InEdgeIt &e) const { 680 return Parent::source((Edge&)e); 681 } 682 683 class IncEdgeIt : public Parent::UEdge { 684 friend class BpUGraphAdaptorExtender; 685 const Graph* graph; 686 bool direction; 687 public: 688 689 IncEdgeIt() { } 690 691 IncEdgeIt(Invalid i) : UEdge(i), direction(true) { } 692 693 IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) { 694 graph->firstInc(*this, direction, n); 695 } 696 697 IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n) 698 : graph(&_graph), UEdge(ue) { 699 direction = (graph->source(ue) == n); 700 } 701 702 IncEdgeIt& operator++() { 703 graph->nextInc(*this, direction); 704 return *this; 705 } 706 }; 707 708 709 /// Base node of the iterator 710 /// 711 /// Returns the base node of the iterator 712 Node baseNode(const IncEdgeIt &e) const { 713 return e.direction ? source(e) : target(e); 714 } 715 716 /// Running node of the iterator 717 /// 718 /// Returns the running node of the iterator 719 Node runningNode(const IncEdgeIt &e) const { 720 return e.direction ? target(e) : source(e); 721 } 722 723 }; 724 439 725 440 726 } -
lemon/bits/graph_extender.h
r1999 r2031 104 104 105 105 explicit NodeIt(const Graph& _graph) : graph(&_graph) { 106 _graph.first( *static_cast<Node*>(this));106 _graph.first(static_cast<Node&>(*this)); 107 107 } 108 108 … … 127 127 128 128 explicit EdgeIt(const Graph& _graph) : graph(&_graph) { 129 _graph.first( *static_cast<Edge*>(this));129 _graph.first(static_cast<Edge&>(*this)); 130 130 } 131 131 … … 233 233 } 234 234 235 236 /// \brief Template assign operator.237 ///238 /// The given parameter should be conform to the ReadMap239 /// concecpt and could be indiced by the current item set of240 /// the NodeMap. In this case the value for each item241 /// is assigned by the value of the given ReadMap.242 235 template <typename CMap> 243 236 NodeMap& operator=(const CMap& cmap) { 244 checkConcept<concept::ReadMap<Node, _Value>, CMap>(); 245 const typename Parent::Notifier* notifier = Parent::getNotifier(); 246 Node it; 247 for (notifier->first(it); it != INVALID; notifier->next(it)) { 248 Parent::set(it, cmap[it]); 249 } 237 Parent::operator=(cmap); 250 238 return *this; 251 239 } … … 271 259 template <typename CMap> 272 260 EdgeMap& operator=(const CMap& cmap) { 273 checkConcept<concept::ReadMap<Edge, _Value>, CMap>(); 274 const typename Parent::Notifier* notifier = Parent::getNotifier(); 275 Edge it; 276 for (notifier->first(it); it != INVALID; notifier->next(it)) { 277 Parent::set(it, cmap[it]); 278 } 261 Parent::operator=(cmap); 279 262 return *this; 280 263 } … … 432 415 433 416 explicit NodeIt(const Graph& _graph) : graph(&_graph) { 434 _graph.first( *static_cast<Node*>(this));417 _graph.first(static_cast<Node&>(*this)); 435 418 } 436 419 … … 455 438 456 439 explicit EdgeIt(const Graph& _graph) : graph(&_graph) { 457 _graph.first( *static_cast<Edge*>(this));440 _graph.first(static_cast<Edge&>(*this)); 458 441 } 459 442 … … 526 509 527 510 explicit UEdgeIt(const Graph& _graph) : graph(&_graph) { 528 _graph.first( *static_cast<UEdge*>(this));511 _graph.first(static_cast<UEdge&>(*this)); 529 512 } 530 513 … … 623 606 } 624 607 625 626 /// \brief Template assign operator.627 ///628 /// The given parameter should be conform to the ReadMap629 /// concecpt and could be indiced by the current item set of630 /// the NodeMap. In this case the value for each item631 /// is assigned by the value of the given ReadMap.632 608 template <typename CMap> 633 609 NodeMap& operator=(const CMap& cmap) { 634 checkConcept<concept::ReadMap<Node, _Value>, CMap>(); 635 const typename Parent::Notifier* notifier = Parent::getNotifier(); 636 Node it; 637 for (notifier->first(it); it != INVALID; notifier->next(it)) { 638 Parent::set(it, cmap[it]); 639 } 610 Parent::operator=(cmap); 640 611 return *this; 641 612 } … … 661 632 template <typename CMap> 662 633 EdgeMap& operator=(const CMap& cmap) { 663 checkConcept<concept::ReadMap<Edge, _Value>, CMap>(); 664 const typename Parent::Notifier* notifier = Parent::getNotifier(); 665 Edge it; 666 for (notifier->first(it); it != INVALID; notifier->next(it)) { 667 Parent::set(it, cmap[it]); 668 } 634 Parent::operator=(cmap); 669 635 return *this; 670 636 } … … 681 647 UEdgeMap(const Graph& graph) 682 648 : Parent(graph) {} 649 683 650 UEdgeMap(const Graph& graph, const _Value& value) 684 651 : Parent(graph, value) {} … … 690 657 template <typename CMap> 691 658 UEdgeMap& operator=(const CMap& cmap) { 692 checkConcept<concept::ReadMap<UEdge, _Value>, CMap>(); 693 const typename Parent::Notifier* notifier = Parent::getNotifier(); 694 Edge it; 695 for (notifier->first(it); it != INVALID; notifier->next(it)) { 696 Parent::set(it, cmap[it]); 697 } 659 Parent::operator=(cmap); 698 660 return *this; 699 661 } 662 700 663 }; 701 664 … … 1105 1068 } 1106 1069 1107 1108 /// \brief Template assign operator.1109 ///1110 /// The given parameter should be conform to the ReadMap1111 /// concept and could be indiced by the current item set of1112 /// the ANodeMap. In this case the value for each item1113 /// is assigned by the value of the given ReadMap.1114 1070 template <typename CMap> 1115 1071 ANodeMap& operator=(const CMap& cmap) { 1116 checkConcept<concept::ReadMap<ANode, _Value>, CMap>(); 1117 const typename Parent::Graph* graph = Parent::getGraph(); 1118 ANode it; 1119 for (graph->first(it); it != INVALID; graph->next(it)) { 1120 Parent::set(it, cmap[it]); 1121 } 1072 Parent::operator=(cmap); 1122 1073 return *this; 1123 1074 } … … 1141 1092 } 1142 1093 1143 1144 /// \brief Template assign operator.1145 ///1146 /// The given parameter should be conform to the ReadMap1147 /// concept and could be indiced by the current item set of1148 /// the BNodeMap. In this case the value for each item1149 /// is assigned by the value of the given ReadMap.1150 1094 template <typename CMap> 1151 1095 BNodeMap& operator=(const CMap& cmap) { 1152 checkConcept<concept::ReadMap<BNode, _Value>, CMap>(); 1153 const typename Parent::Graph* graph = Parent::getGraph(); 1154 BNode it; 1155 for (graph->first(it); it != INVALID; graph->next(it)) { 1156 Parent::set(it, cmap[it]); 1157 } 1096 Parent::operator=(cmap); 1158 1097 return *this; 1159 1098 } … … 1161 1100 }; 1162 1101 1163 p rotected:1102 public: 1164 1103 1165 1104 template <typename _Value> 1166 class NodeMap Base{1105 class NodeMap { 1167 1106 public: 1168 1107 typedef BpUGraphExtender Graph; … … 1178 1117 typedef True ReferenceMapTag; 1179 1118 1180 NodeMapBase(const Graph& graph) 1181 : aNodeMap(graph), bNodeMap(graph) {} 1182 NodeMapBase(const Graph& graph, const _Value& value) 1183 : aNodeMap(graph, value), bNodeMap(graph, value) {} 1119 NodeMap(const Graph& _graph) 1120 : graph(_graph), aNodeMap(_graph), bNodeMap(_graph) {} 1121 NodeMap(const Graph& _graph, const _Value& _value) 1122 : graph(_graph), aNodeMap(_graph, _value), bNodeMap(_graph, _value) {} 1123 1124 NodeMap& operator=(const NodeMap& cmap) { 1125 return operator=<NodeMap>(cmap); 1126 } 1127 1128 template <typename CMap> 1129 NodeMap& operator=(const CMap& cmap) { 1130 checkConcept<concept::ReadMap<Node, _Value>, CMap>(); 1131 const typename Parent::Notifier* notifier = Parent::getNotifier(); 1132 Edge it; 1133 for (graph.first(it); it != INVALID; graph.next(it)) { 1134 Parent::set(it, cmap[it]); 1135 } 1136 return *this; 1137 } 1184 1138 1185 1139 ConstReference operator[](const Key& node) const { … … 1207 1161 } 1208 1162 1209 const Graph* getGraph() const { 1210 return aNodeMap.getGraph(); 1211 } 1212 1163 class MapIt : public NodeIt { 1164 public: 1165 1166 typedef NodeIt Parent; 1167 1168 explicit MapIt(NodeMap& _map) 1169 : Parent(_map.graph), map(_map) {} 1170 1171 typename MapTraits<NodeMap>::ConstReturnValue operator*() const { 1172 return map[*this]; 1173 } 1174 1175 typename MapTraits<NodeMap>::ReturnValue operator*() { 1176 return map[*this]; 1177 } 1178 1179 void set(const Value& value) { 1180 map.set(*this, value); 1181 } 1182 1183 private: 1184 NodeMap& map; 1185 }; 1186 1187 class ConstMapIt : public NodeIt { 1188 public: 1189 1190 typedef NodeIt Parent; 1191 1192 explicit ConstMapIt(const NodeMap& _map) 1193 : Parent(_map.graph), map(_map) {} 1194 1195 typename MapTraits<NodeMap>::ConstReturnValue operator*() const { 1196 return map[*this]; 1197 } 1198 1199 private: 1200 const NodeMap& map; 1201 }; 1202 1203 class ItemIt : public NodeIt { 1204 public: 1205 1206 typedef NodeIt Parent; 1207 1208 explicit ItemIt(const NodeMap& _map) 1209 : Parent(_map.graph) {} 1210 1211 }; 1212 1213 1213 private: 1214 const Graph& graph; 1214 1215 ANodeMap<_Value> aNodeMap; 1215 1216 BNodeMap<_Value> bNodeMap; 1216 1217 }; 1217 1218 1218 public:1219 1220 template <typename _Value>1221 class NodeMap1222 : public MapExtender<NodeMapBase<_Value> > {1223 public:1224 typedef BpUGraphExtender Graph;1225 typedef MapExtender< NodeMapBase<_Value> > Parent;1226 1227 NodeMap(const Graph& graph)1228 : Parent(graph) {}1229 NodeMap(const Graph& graph, const _Value& value)1230 : Parent(graph, value) {}1231 1232 NodeMap& operator=(const NodeMap& cmap) {1233 return operator=<NodeMap>(cmap);1234 }1235 1236 1237 /// \brief Template assign operator.1238 ///1239 /// The given parameter should be conform to the ReadMap1240 /// concept and could be indiced by the current item set of1241 /// the NodeMap. In this case the value for each item1242 /// is assigned by the value of the given ReadMap.1243 template <typename CMap>1244 NodeMap& operator=(const CMap& cmap) {1245 checkConcept<concept::ReadMap<Node, _Value>, CMap>();1246 const typename Parent::Notifier* notifier = Parent::getNotifier();1247 Edge it;1248 for (notifier->first(it); it != INVALID; notifier->next(it)) {1249 Parent::set(it, cmap[it]);1250 }1251 return *this;1252 }1253 1254 };1255 1256 1257 1219 1258 1220 template <typename _Value> … … 1274 1236 template <typename CMap> 1275 1237 EdgeMap& operator=(const CMap& cmap) { 1276 checkConcept<concept::ReadMap<Edge, _Value>, CMap>(); 1277 const typename Parent::Notifier* notifier = Parent::getNotifier(); 1278 Edge it; 1279 for (notifier->first(it); it != INVALID; notifier->next(it)) { 1280 Parent::set(it, cmap[it]); 1281 } 1238 Parent::operator=(cmap); 1282 1239 return *this; 1283 1240 } … … 1302 1259 template <typename CMap> 1303 1260 UEdgeMap& operator=(const CMap& cmap) { 1304 checkConcept<concept::ReadMap<UEdge, _Value>, CMap>(); 1305 const typename Parent::Notifier* notifier = Parent::getNotifier(); 1306 Edge it; 1307 for (notifier->first(it); it != INVALID; notifier->next(it)) { 1308 Parent::set(it, cmap[it]); 1309 } 1261 Parent::operator=(cmap); 1310 1262 return *this; 1311 1263 } -
lemon/bits/map_extender.h
r1999 r2031 23 23 24 24 #include <lemon/bits/traits.h> 25 26 #include <lemon/concept_check.h> 27 #include <lemon/concept/maps.h> 25 28 26 29 ///\file … … 60 63 : Parent(graph, value) {} 61 64 65 MapExtender& operator=(const MapExtender& cmap) { 66 return operator=<MapExtender>(cmap); 67 } 68 69 template <typename CMap> 70 MapExtender& operator=(const CMap& cmap) { 71 Parent::operator=(cmap); 72 return *this; 73 } 62 74 63 75 class MapIt : public Item { … … 131 143 }; 132 144 133 class ItemIt : Item {145 class ItemIt : public Item { 134 146 public: 135 147 … … 141 153 142 154 explicit ItemIt(Map& _map) : map(_map) { 143 map ->getNotifier()->first(*this);155 map.getNotifier()->first(*this); 144 156 } 145 157 … … 158 170 }; 159 171 172 /// \ingroup graphbits 173 /// 174 /// \brief Extender for maps which use a subset of the items. 175 template <typename _Graph, typename _Map> 176 class SubMapExtender : public _Map { 177 public: 178 179 typedef _Map Parent; 180 typedef SubMapExtender Map; 181 182 typedef _Graph Graph; 183 184 typedef typename Parent::Key Item; 185 186 typedef typename Parent::Key Key; 187 typedef typename Parent::Value Value; 188 189 class MapIt; 190 class ConstMapIt; 191 192 friend class MapIt; 193 friend class ConstMapIt; 194 195 public: 196 197 SubMapExtender(const Graph& _graph) 198 : Parent(_graph), graph(_graph) {} 199 200 SubMapExtender(const Graph& _graph, const Value& _value) 201 : Parent(_graph, _value), graph(_graph) {} 202 203 SubMapExtender& operator=(const SubMapExtender& cmap) { 204 return operator=<MapExtender>(cmap); 205 } 206 207 template <typename CMap> 208 SubMapExtender& operator=(const CMap& cmap) { 209 checkConcept<concept::ReadMap<Key, Value>, CMap>(); 210 Item it; 211 for (graph.first(it); it != INVALID; graph.next(it)) { 212 Parent::set(it, cmap[it]); 213 } 214 return *this; 215 } 216 217 class MapIt : public Item { 218 public: 219 220 typedef Item Parent; 221 typedef typename Map::Value Value; 222 223 MapIt() {} 224 225 MapIt(Invalid i) : Parent(i) { } 226 227 explicit MapIt(Map& _map) : map(_map) { 228 map.graph.first(*this); 229 } 230 231 MapIt(const Map& _map, const Item& item) 232 : Parent(item), map(_map) {} 233 234 MapIt& operator++() { 235 map.graph.next(*this); 236 return *this; 237 } 238 239 typename MapTraits<Map>::ConstReturnValue operator*() const { 240 return map[*this]; 241 } 242 243 typename MapTraits<Map>::ReturnValue operator*() { 244 return map[*this]; 245 } 246 247 void set(const Value& value) { 248 map.set(*this, value); 249 } 250 251 protected: 252 Map& map; 253 254 }; 255 256 class ConstMapIt : public Item { 257 public: 258 259 typedef Item Parent; 260 261 typedef typename Map::Value Value; 262 263 ConstMapIt() {} 264 265 ConstMapIt(Invalid i) : Parent(i) { } 266 267 explicit ConstMapIt(Map& _map) : map(_map) { 268 map.graph.first(*this); 269 } 270 271 ConstMapIt(const Map& _map, const Item& item) 272 : Parent(item), map(_map) {} 273 274 ConstMapIt& operator++() { 275 map.graph.next(*this); 276 return *this; 277 } 278 279 typename MapTraits<Map>::ConstReturnValue operator*() const { 280 return map[*this]; 281 } 282 283 protected: 284 const Map& map; 285 }; 286 287 class ItemIt : public Item { 288 public: 289 290 typedef Item Parent; 291 292 ItemIt() {} 293 294 ItemIt(Invalid i) : Parent(i) { } 295 296 explicit ItemIt(Map& _map) : map(_map) { 297 map.graph.first(*this); 298 } 299 300 ItemIt(const Map& _map, const Item& item) 301 : Parent(item), map(_map) {} 302 303 ItemIt& operator++() { 304 map.graph.next(*this); 305 return *this; 306 } 307 308 protected: 309 const Map& map; 310 311 }; 312 313 private: 314 315 const Graph& graph; 316 317 }; 318 160 319 } 161 320 -
lemon/bits/vector_map.h
r1999 r2031 27 27 28 28 #include <lemon/bits/alteration_notifier.h> 29 30 #include <lemon/concept_check.h> 31 #include <lemon/concept/maps.h> 29 32 30 33 ///\ingroup graphbits … … 113 116 } 114 117 115 private: 116 117 VectorMap& operator=(const VectorMap&); 118 118 /// \brief Assign operator. 119 /// 120 /// This operator assigns for each item in the map the 121 /// value mapped to the same item in the copied map. 122 /// The parameter map should be indiced with the same 123 /// itemset because this assign operator does not change 124 /// the container of the map. 125 VectorMap& operator=(const VectorMap& cmap) { 126 return operator=<VectorMap>(cmap); 127 } 128 129 130 /// \brief Template assign operator. 131 /// 132 /// The given parameter should be conform to the ReadMap 133 /// concecpt and could be indiced by the current item set of 134 /// the NodeMap. In this case the value for each item 135 /// is assigned by the value of the given ReadMap. 136 template <typename CMap> 137 VectorMap& operator=(const CMap& cmap) { 138 checkConcept<concept::ReadMap<Key, _Value>, CMap>(); 139 const typename Parent::Notifier* notifier = Parent::getNotifier(); 140 Item it; 141 for (notifier->first(it); it != INVALID; notifier->next(it)) { 142 set(it, cmap[it]); 143 } 144 return *this; 145 } 146 119 147 public: 120 148 -
lemon/edge_set.h
r1999 r2031 207 207 class NodeMap : public Graph::template NodeMap<_Value> { 208 208 public: 209 209 210 typedef typename _Graph::template NodeMap<_Value> Parent; 211 210 212 explicit NodeMap(const ListEdgeSetBase<Graph>& edgeset) 211 : Parent(*edgeset.graph) { } 213 : Parent(*edgeset.graph) {} 214 212 215 NodeMap(const ListEdgeSetBase<Graph>& edgeset, const _Value& value) 213 : Parent(*edgeset.graph, value) { } 216 : Parent(*edgeset.graph, value) {} 217 218 NodeMap& operator=(const NodeMap& cmap) { 219 return operator=<NodeMap>(cmap); 220 } 221 222 template <typename CMap> 223 NodeMap& operator=(const CMap& cmap) { 224 Parent::operator=(cmap); 225 return *this; 226 } 214 227 }; 215 228 … … 522 535 class NodeMap : public Graph::template NodeMap<_Value> { 523 536 public: 537 524 538 typedef typename _Graph::template NodeMap<_Value> Parent; 539 525 540 explicit NodeMap(const SmartEdgeSetBase<Graph>& edgeset) 526 541 : Parent(*edgeset.graph) { } 542 527 543 NodeMap(const SmartEdgeSetBase<Graph>& edgeset, const _Value& value) 528 544 : Parent(*edgeset.graph, value) { } 545 546 NodeMap& operator=(const NodeMap& cmap) { 547 return operator=<NodeMap>(cmap); 548 } 549 550 template <typename CMap> 551 NodeMap& operator=(const CMap& cmap) { 552 Parent::operator=(cmap); 553 return *this; 554 } 529 555 }; 530 556 … … 668 694 669 695 void eraseNode(const Node& node) { 670 if ( Parent::IncEdgeIt(*this, node) == INVALID) {696 if (typename Parent::IncEdgeIt(*this, node) == INVALID) { 671 697 return; 672 698 } -
lemon/full_graph.h
r1999 r2031 646 646 } 647 647 648 typedef True NodeNumTag; 649 int nodeNum() const { return _aNodeNum + _bNodeNum; } 650 int aNodeNum() const { return _aNodeNum; } 651 int bNodeNum() const { return _bNodeNum; } 652 653 typedef True EdgeNumTag; 654 int edgeNum() const { return _edgeNum; } 655 648 656 }; 649 657 -
lemon/graph_adaptor.h
r1999 r2031 20 20 #define LEMON_GRAPH_ADAPTOR_H 21 21 22 /// \ingroup graph_adaptors23 /// \file24 /// \brief Several graph adaptors.22 /// \ingroup graph_adaptors 23 /// \file 24 /// \brief Several graph adaptors. 25 25 /// 26 /// This file contains several useful graph adaptor functions.26 /// This file contains several useful graph adaptor functions. 27 27 /// 28 /// \author Marton Makai28 /// \author Marton Makai and Balazs Dezso 29 29 30 30 #include <lemon/bits/invalid.h> … … 62 62 public: 63 63 typedef _Graph Graph; 64 typedef GraphAdaptorBase Adaptor; 64 65 typedef Graph ParentGraph; 65 66 … … 116 117 int id(const Edge& e) const { return graph->id(e); } 117 118 119 Node fromNodeId(int id) const { 120 return graph->fromNodeId(id); 121 } 122 123 Edge fromEdgeId(int id) const { 124 return graph->fromEdgeId(id); 125 } 126 118 127 int maxNodeId() const { 119 128 return graph->maxNodeId(); … … 137 146 138 147 template <typename _Value> 139 class NodeMap : public _Graph::template NodeMap<_Value> {148 class NodeMap : public Graph::template NodeMap<_Value> { 140 149 public: 141 typedef typename _Graph::template NodeMap<_Value> Parent; 142 explicit NodeMap(const GraphAdaptorBase<_Graph>& ga) 143 : Parent(*ga.graph) { } 144 NodeMap(const GraphAdaptorBase<_Graph>& ga, const _Value& value) 150 151 typedef typename Graph::template NodeMap<_Value> Parent; 152 153 explicit NodeMap(const Adaptor& ga) 154 : Parent(*ga.graph) {} 155 156 NodeMap(const Adaptor& ga, const _Value& value) 145 157 : Parent(*ga.graph, value) { } 158 159 NodeMap& operator=(const NodeMap& cmap) { 160 return operator=<NodeMap>(cmap); 161 } 162 163 template <typename CMap> 164 NodeMap& operator=(const CMap& cmap) { 165 Parent::operator=(cmap); 166 return *this; 167 } 168 146 169 }; 147 170 148 171 template <typename _Value> 149 class EdgeMap : public _Graph::template EdgeMap<_Value> {172 class EdgeMap : public Graph::template EdgeMap<_Value> { 150 173 public: 151 typedef typename _Graph::template EdgeMap<_Value> Parent; 152 explicit EdgeMap(const GraphAdaptorBase<_Graph>& ga) 153 : Parent(*ga.graph) { } 154 EdgeMap(const GraphAdaptorBase<_Graph>& ga, const _Value& value) 155 : Parent(*ga.graph, value) { } 174 175 typedef typename Graph::template EdgeMap<_Value> Parent; 176 177 explicit EdgeMap(const Adaptor& ga) 178 : Parent(*ga.graph) {} 179 180 EdgeMap(const Adaptor& ga, const _Value& value) 181 : Parent(*ga.graph, value) {} 182 183 EdgeMap& operator=(const EdgeMap& cmap) { 184 return operator=<EdgeMap>(cmap); 185 } 186 187 template <typename CMap> 188 EdgeMap& operator=(const CMap& cmap) { 189 Parent::operator=(cmap); 190 return *this; 191 } 192 156 193 }; 157 194 … … 256 293 public: 257 294 typedef _Graph Graph; 295 typedef SubGraphAdaptorBase Adaptor; 258 296 typedef GraphAdaptorBase<_Graph> Parent; 259 297 protected: … … 378 416 return edge; 379 417 } 418 419 template <typename _Value> 420 class NodeMap 421 : public SubMapExtender<Adaptor, 422 typename Parent::template NodeMap<_Value> > 423 { 424 public: 425 typedef Adaptor Graph; 426 typedef SubMapExtender<Adaptor, typename Parent:: 427 template NodeMap<_Value> > Parent; 428 429 NodeMap(const Graph& graph) 430 : Parent(graph) {} 431 NodeMap(const Graph& graph, const _Value& value) 432 : Parent(graph, value) {} 433 434 NodeMap& operator=(const NodeMap& cmap) { 435 return operator=<NodeMap>(cmap); 436 } 437 438 template <typename CMap> 439 NodeMap& operator=(const CMap& cmap) { 440 Parent::operator=(cmap); 441 return *this; 442 } 443 }; 444 445 template <typename _Value> 446 class EdgeMap 447 : public SubMapExtender<Adaptor, 448 typename Parent::template EdgeMap<_Value> > 449 { 450 public: 451 typedef Adaptor Graph; 452 typedef SubMapExtender<Adaptor, typename Parent:: 453 template EdgeMap<_Value> > Parent; 454 455 EdgeMap(const Graph& graph) 456 : Parent(graph) {} 457 EdgeMap(const Graph& graph, const _Value& value) 458 : Parent(graph, value) {} 459 460 EdgeMap& operator=(const EdgeMap& cmap) { 461 return operator=<EdgeMap>(cmap); 462 } 463 464 template <typename CMap> 465 EdgeMap& operator=(const CMap& cmap) { 466 Parent::operator=(cmap); 467 return *this; 468 } 469 }; 470 380 471 }; 381 472 … … 385 476 public: 386 477 typedef _Graph Graph; 478 typedef SubGraphAdaptorBase Adaptor; 387 479 typedef GraphAdaptorBase<_Graph> Parent; 388 480 protected: … … 497 589 return edge; 498 590 } 591 592 template <typename _Value> 593 class NodeMap 594 : public SubMapExtender<Adaptor, 595 typename Parent::template NodeMap<_Value> > 596 { 597 public: 598 typedef Adaptor Graph; 599 typedef SubMapExtender<Adaptor, typename Parent:: 600 template NodeMap<_Value> > Parent; 601 602 NodeMap(const Graph& graph) 603 : Parent(graph) {} 604 NodeMap(const Graph& graph, const _Value& value) 605 : Parent(graph, value) {} 606 607 NodeMap& operator=(const NodeMap& cmap) { 608 return operator=<NodeMap>(cmap); 609 } 610 611 template <typename CMap> 612 NodeMap& operator=(const CMap& cmap) { 613 Parent::operator=(cmap); 614 return *this; 615 } 616 }; 617 618 template <typename _Value> 619 class EdgeMap 620 : public SubMapExtender<Adaptor, 621 typename Parent::template EdgeMap<_Value> > 622 { 623 public: 624 typedef Adaptor Graph; 625 typedef SubMapExtender<Adaptor, typename Parent:: 626 template EdgeMap<_Value> > Parent; 627 628 EdgeMap(const Graph& graph) 629 : Parent(graph) {} 630 EdgeMap(const Graph& graph, const _Value& value) 631 : Parent(graph, value) {} 632 633 EdgeMap& operator=(const EdgeMap& cmap) { 634 return operator=<EdgeMap>(cmap); 635 } 636 637 template <typename CMap> 638 EdgeMap& operator=(const CMap& cmap) { 639 Parent::operator=(cmap); 640 return *this; 641 } 642 }; 643 499 644 }; 500 645 … … 567 712 public: 568 713 typedef _Graph Graph; 569 typedef GraphAdaptorExtender< 570 SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent; 714 typedef GraphAdaptorExtender< SubGraphAdaptorBase<_Graph, NodeFilterMap, 715 EdgeFilterMap, checked> > 716 Parent; 717 571 718 protected: 572 719 SubGraphAdaptor() { } 573 720 public: 721 574 722 SubGraphAdaptor(_Graph& _graph, NodeFilterMap& _node_filter_map, 575 723 EdgeFilterMap& _edge_filter_map) { … … 578 726 setEdgeFilterMap(_edge_filter_map); 579 727 } 728 580 729 }; 581 730 … … 636 785 ConstMap<typename Graph::Edge,bool>, checked> { 637 786 public: 787 638 788 typedef SubGraphAdaptor<Graph, NodeFilterMap, 639 ConstMap<typename Graph::Edge,bool> > Parent; 789 ConstMap<typename Graph::Edge,bool>, checked > 790 Parent; 791 640 792 protected: 641 793 ConstMap<typename Graph::Edge, bool> const_true_map; … … 646 798 647 799 public: 800 648 801 NodeSubGraphAdaptor(Graph& _graph, NodeFilterMap& _node_filter_map) : 649 802 Parent(), const_true_map(true) { … … 652 805 Parent::setEdgeFilterMap(const_true_map); 653 806 } 807 654 808 }; 655 809 … … 821 975 822 976 public: 977 823 978 EdgeSubGraphAdaptor(Graph& _graph, EdgeFilterMap& _edge_filter_map) : 824 979 Parent(), const_true_map(true) { … … 827 982 Parent::setEdgeFilterMap(_edge_filter_map); 828 983 } 984 829 985 }; 830 986 … … 849 1005 public: 850 1006 typedef _Graph Graph; 1007 typedef UndirGraphAdaptorBase Adaptor; 851 1008 typedef UGraphBaseExtender<GraphAdaptorBase<_Graph> > Parent; 852 1009 … … 860 1017 typedef typename Parent::Edge Edge; 861 1018 1019 private: 862 1020 863 1021 template <typename _Value> 864 class EdgeMap {1022 class EdgeMapBase { 865 1023 private: 866 1024 … … 874 1032 typedef Edge Key; 875 1033 876 EdgeMap (const UndirGraphAdaptorBase<_Graph>& _g) :877 forward_map(* (_g.graph)), backward_map(*(_g.graph)) {}878 879 EdgeMap (const UndirGraphAdaptorBase<_Graph>& _g, const Value& a)880 : forward_map(* (_g.graph), a), backward_map(*(_g.graph), a) {}1034 EdgeMapBase(const Adaptor& adaptor) : 1035 forward_map(*adaptor.graph), backward_map(*adaptor.graph) {} 1036 1037 EdgeMapBase(const Adaptor& adaptor, const Value& v) 1038 : forward_map(*adaptor.graph, v), backward_map(*adaptor.graph, v) {} 881 1039 882 1040 void set(const Edge& e, const Value& a) { … … 909 1067 910 1068 }; 1069 1070 public: 1071 1072 template <typename _Value> 1073 class EdgeMap 1074 : public SubMapExtender<Adaptor, EdgeMapBase<_Value> > 1075 { 1076 public: 1077 typedef Adaptor Graph; 1078 typedef SubMapExtender<Adaptor, EdgeMapBase<_Value> > Parent; 1079 1080 EdgeMap(const Graph& graph) 1081 : Parent(graph) {} 1082 EdgeMap(const Graph& graph, const _Value& value) 1083 : Parent(graph, value) {} 1084 1085 EdgeMap& operator=(const EdgeMap& cmap) { 1086 return operator=<EdgeMap>(cmap); 1087 } 1088 1089 template <typename CMap> 1090 EdgeMap& operator=(const CMap& cmap) { 1091 Parent::operator=(cmap); 1092 return *this; 1093 } 1094 }; 911 1095 912 1096 template <typename _Value> 913 class UEdgeMap : public _Graph::template EdgeMap<_Value> {1097 class UEdgeMap : public Graph::template EdgeMap<_Value> { 914 1098 public: 915 916 typedef typename _Graph::template EdgeMap<_Value> Parent; 917 918 UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) 919 : Parent(*(g.graph)) {} 920 921 UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, const _Value& a) 922 : Parent(*(g.graph), a) {} 923 1099 1100 typedef typename Graph::template EdgeMap<_Value> Parent; 1101 1102 explicit UEdgeMap(const Adaptor& ga) 1103 : Parent(*ga.graph) {} 1104 1105 UEdgeMap(const Adaptor& ga, const _Value& value) 1106 : Parent(*ga.graph, value) {} 1107 1108 UEdgeMap& operator=(const UEdgeMap& cmap) { 1109 return operator=<UEdgeMap>(cmap); 1110 } 1111 1112 template <typename CMap> 1113 UEdgeMap& operator=(const CMap& cmap) { 1114 Parent::operator=(cmap); 1115 return *this; 1116 } 1117 924 1118 }; 925 1119 … … 934 1128 935 1129 typedef _Graph Graph; 1130 typedef UndirGraphAdaptorBase Adaptor; 936 1131 typedef UGraphBaseExtender<GraphAdaptorBase<_Graph> > Parent; 937 1132 … … 1034 1229 NotifierProxy edge_notifier_proxy; 1035 1230 1036 public: 1037 1231 private: 1038 1232 1039 1233 template <typename _Value> 1040 class EdgeMap {1234 class EdgeMapBase { 1041 1235 private: 1042 1236 … … 1050 1244 typedef Edge Key; 1051 1245 1052 EdgeMap (const UndirGraphAdaptorBase<_Graph>& _g) :1053 forward_map(* (_g.graph)), backward_map(*(_g.graph)) {}1054 1055 EdgeMap (const UndirGraphAdaptorBase<_Graph>& _g, const Value& a)1056 : forward_map(* (_g.graph), a), backward_map(*(_g.graph), a) {}1246 EdgeMapBase(const Adaptor& adaptor) : 1247 forward_map(*adaptor.graph), backward_map(*adaptor.graph) {} 1248 1249 EdgeMapBase(const Adaptor& adaptor, const Value& v) 1250 : forward_map(*adaptor.graph, v), backward_map(*adaptor.graph, v) {} 1057 1251 1058 1252 void set(const Edge& e, const Value& a) { … … 1064 1258 } 1065 1259 1066 typename MapTraits<MapImpl>::ConstReturnValue 1067 operator[](const Edge& e) const { 1260 typename MapTraits<MapImpl>::ConstReturnValue operator[](Edge e) const { 1068 1261 if (Parent::direction(e)) { 1069 1262 return forward_map[e]; … … 1073 1266 } 1074 1267 1075 typename MapTraits<MapImpl>::ReturnValue 1076 operator[](const Edge& e) { 1268 typename MapTraits<MapImpl>::ReturnValue operator[](Edge e) { 1077 1269 if (Parent::direction(e)) { 1078 1270 return forward_map[e]; … … 1087 1279 1088 1280 }; 1281 1282 public: 1283 1284 template <typename _Value> 1285 class EdgeMap 1286 : public SubMapExtender<Adaptor, EdgeMapBase<_Value> > 1287 { 1288 public: 1289 typedef Adaptor Graph; 1290 typedef SubMapExtender<Adaptor, EdgeMapBase<_Value> > Parent; 1291 1292 EdgeMap(const Graph& graph) 1293 : Parent(graph) {} 1294 EdgeMap(const Graph& graph, const _Value& value) 1295 : Parent(graph, value) {} 1296 1297 EdgeMap& operator=(const EdgeMap& cmap) { 1298 return operator=<EdgeMap>(cmap); 1299 } 1300 1301 template <typename CMap> 1302 EdgeMap& operator=(const CMap& cmap) { 1303 Parent::operator=(cmap); 1304 return *this; 1305 } 1306 }; 1089 1307 1090 1308 template <typename _Value> 1091 class UEdgeMap : public _Graph::template EdgeMap<_Value> {1309 class UEdgeMap : public Graph::template EdgeMap<_Value> { 1092 1310 public: 1093 1094 typedef typename _Graph::template EdgeMap<_Value> Parent; 1095 1096 UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) 1097 : Parent(*(g.graph)) {} 1098 1099 UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, const _Value& a) 1100 : Parent(*(g.graph), a) {} 1101 1311 1312 typedef typename Graph::template EdgeMap<_Value> Parent; 1313 1314 explicit UEdgeMap(const Adaptor& ga) 1315 : Parent(*ga.graph) {} 1316 1317 UEdgeMap(const Adaptor& ga, const _Value& value) 1318 : Parent(*ga.graph, value) {} 1319 1320 UEdgeMap& operator=(const UEdgeMap& cmap) { 1321 return operator=<UEdgeMap>(cmap); 1322 } 1323 1324 template <typename CMap> 1325 UEdgeMap& operator=(const CMap& cmap) { 1326 Parent::operator=(cmap); 1327 return *this; 1328 } 1329 1102 1330 }; 1103 1331 -
lemon/graph_utils.h
r2029 r2031 49 49 ///This \c \#define creates convenience typedefs for the following types 50 50 ///of \c Graph: \c Node, \c NodeIt, \c Edge, \c EdgeIt, \c InEdgeIt, 51 ///\c OutEdgeIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap, 52 ///\c BoolEdgeMap, \c IntEdgeMap, \c DoubleEdgeMap. 51 ///\c OutEdgeIt 53 52 ///\note If \c G it a template parameter, it should be used in this way. 54 53 ///\code … … 65 64 typedef Graph:: InEdgeIt InEdgeIt; \ 66 65 typedef Graph::OutEdgeIt OutEdgeIt; 67 // typedef Graph::template NodeMap<bool> BoolNodeMap; 68 // typedef Graph::template NodeMap<int> IntNodeMap; 69 // typedef Graph::template NodeMap<double> DoubleNodeMap; 70 // typedef Graph::template EdgeMap<bool> BoolEdgeMap; 71 // typedef Graph::template EdgeMap<int> IntEdgeMap; 72 // typedef Graph::template EdgeMap<double> DoubleEdgeMap; 73 66 74 67 ///Creates convenience typedefs for the undirected graph types and iterators 75 68 … … 77 70 ///\ref GRAPH_TYPEDEFS(Graph) and three more, namely it creates 78 71 ///\c UEdge, \c UEdgeIt, \c IncEdgeIt, 79 ///\c BoolUEdgeMap, \c IntUEdgeMap, \c DoubleUEdgeMap.80 72 /// 81 73 ///\note If \c G it a template parameter, it should be used in this way. … … 94 86 // typedef Graph::template UEdgeMap<int> IntUEdgeMap; 95 87 // typedef Graph::template UEdgeMap<double> DoubleUEdgeMap; 96 97 88 89 ///\brief Creates convenience typedefs for the bipartite undirected graph 90 ///types and iterators 91 92 ///This \c \#define creates the same convenience typedefs as defined by 93 ///\ref UGRAPH_TYPEDEFS(Graph) and two more, namely it creates 94 ///\c ANodeIt, \c BNodeIt, 95 /// 96 ///\note If \c G it a template parameter, it should be used in this way. 97 ///\code 98 /// BPUGRAPH_TYPEDEFS(typename G) 99 ///\endcode 100 /// 101 ///\warning There are no typedefs for the graph maps because of the lack of 102 ///template typedefs in C++. 103 #define BPUGRAPH_TYPEDEFS(Graph) \ 104 UGRAPH_TYPEDEFS(Graph) \ 105 typedef Graph::ANodeIt ANodeIt; \ 106 typedef Graph::BNodeIt BNodeIt; 98 107 99 108 /// \brief Function to count the items in the graph. … … 431 440 if (u != v) { 432 441 if (e == INVALID) { 433 g.firstInc(e, u, b);442 g.firstInc(e, b, u); 434 443 } else { 435 444 b = g.source(e) == u; … … 441 450 } else { 442 451 if (e == INVALID) { 443 g.firstInc(e, u, b);452 g.firstInc(e, b, u); 444 453 } else { 445 454 b = true; … … 486 495 ///\endcode 487 496 template <typename Graph> 488 inline typename Graph::UEdge find Edge(const Graph &g,489 typename Graph::Node u,490 typename Graph::Node v,491 typename Graph::UEdge prev= INVALID) {492 return _graph_utils_bits::FindUEdgeSelector<Graph>::find(g, u, v, p rev);497 inline typename Graph::UEdge findUEdge(const Graph &g, 498 typename Graph::Node u, 499 typename Graph::Node v, 500 typename Graph::UEdge p = INVALID) { 501 return _graph_utils_bits::FindUEdgeSelector<Graph>::find(g, u, v, p); 493 502 } 494 503 -
lemon/iterable_maps.h
r1993 r2031 21 21 22 22 #include <lemon/bits/default_map.h> 23 #include <lemon/bits/map_extender.h> 23 24 24 25 #include <vector> … … 401 402 template <typename _Graph, typename _Item> 402 403 class IterableIntMap 403 : protected DefaultMap<_Graph, _Item, _iterable_maps_bits::404 IterableIntMapNode<_Item> >{404 : protected MapExtender<DefaultMap<_Graph, _Item, _iterable_maps_bits:: 405 IterableIntMapNode<_Item> > >{ 405 406 public: 406 typedef DefaultMap<_Graph, _Item, _iterable_maps_bits:: 407 IterableIntMapNode<_Item> > 408 Parent; 407 typedef MapExtender<DefaultMap<_Graph, _Item, _iterable_maps_bits:: 408 IterableIntMapNode<_Item> > > Parent; 409 409 410 410 /// The key type … … 690 690 template <typename _Graph, typename _Item, typename _Value> 691 691 class IterableValueMap 692 : protected DefaultMap<_Graph, _Item, _iterable_maps_bits::693 IterableValueMapNode<_Item, _Value> >{692 : protected MapExtender<DefaultMap<_Graph, _Item, _iterable_maps_bits:: 693 IterableValueMapNode<_Item, _Value> > >{ 694 694 public: 695 typedef DefaultMap<_Graph, _Item, _iterable_maps_bits:: 696 IterableValueMapNode<_Item, _Value> > Parent; 695 typedef MapExtender<DefaultMap<_Graph, _Item, _iterable_maps_bits:: 696 IterableValueMapNode<_Item, _Value> > > 697 Parent; 697 698 698 699 /// The key type … … 703 704 typedef _Graph Graph; 704 705 705 protected:706 707 typedef typename ItemSetTraits<_Graph, Key>::ItemIt KeyIt;708 709 706 public: 710 707 … … 716 713 : Parent(graph, _iterable_maps_bits:: 717 714 IterableValueMapNode<_Item, _Value>(value)) { 718 for ( KeyIt it(*Parent::getGraph()); it != INVALID; ++it) {715 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) { 719 716 lace(it); 720 717 } … … 904 901 virtual void build() { 905 902 Parent::build(); 906 for ( KeyIt it(*Parent::getGraph()); it != INVALID; ++it) {903 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) { 907 904 lace(it); 908 905 } -
lemon/list_graph.h
r1999 r2031 67 67 68 68 int id; 69 Node(int pid) { id = pid;}69 explicit Node(int pid) { id = pid;} 70 70 71 71 public: … … 82 82 83 83 int id; 84 Edge(int pid) { id = pid;}84 explicit Edge(int pid) { id = pid;} 85 85 86 86 public: … … 111 111 int maxEdgeId() const { return edges.size()-1; } 112 112 113 Node source(Edge e) const { return edges[e.id].source; }114 Node target(Edge e) const { return edges[e.id].target; }113 Node source(Edge e) const { return Node(edges[e.id].source); } 114 Node target(Edge e) const { return Node(edges[e.id].target); } 115 115 116 116 … … 677 677 int id; 678 678 679 Node(int _id) : id(_id) {}679 explicit Node(int _id) : id(_id) {} 680 680 public: 681 681 Node() {} … … 691 691 int id; 692 692 693 Edge(int _id) { id = _id;}693 explicit Edge(int _id) { id = _id;} 694 694 public: 695 695 Edge() {} -
lemon/smart_graph.h
r1999 r2031 576 576 } 577 577 578 typedef True NodeNumTag; 579 int nodeNum() const { return aNodes.size() + bNodes.size(); } 580 int aNodeNum() const { return aNodes.size(); } 581 int bNodeNum() const { return bNodes.size(); } 582 583 typedef True EdgeNumTag; 584 int edgeNum() const { return edges.size(); } 585 578 586 }; 579 587 -
lemon/ugraph_adaptor.h
r1993 r2031 102 102 typedef EdgeNumTagIndicator<Graph> EdgeNumTag; 103 103 int edgeNum() const { return graph->edgeNum(); } 104 int uEdgeNum() const { return graph->uEdgeNum(); } 104 105 105 106 typedef FindEdgeTagIndicator<Graph> FindEdgeTag; … … 119 120 120 121 void erase(const Node& i) const { graph->erase(i); } 121 void erase(const Edge& i) const { graph->erase(i); }122 void erase(const UEdge& i) const { graph->erase(i); } 122 123 123 124 void clear() const { graph->clear(); } 124 125 125 int id(const Node& v) const { return graph->id(v); }126 int id(const UEdge& e) const { return graph->id(e); }127 128 126 bool direction(const Edge& e) const { return graph->direction(e); } 129 127 Edge direct(const UEdge& e, bool d) const { return graph->direct(e, d); } 128 129 int id(const Node& v) const { return graph->id(v); } 130 int id(const Edge& e) const { return graph->id(e); } 131 int id(const UEdge& e) const { return graph->id(e); } 132 133 Node fromNodeId(int id) const { 134 return graph->fromNodeId(id); 135 } 136 137 Edge fromEdgeId(int id) const { 138 return graph->fromEdgeId(id); 139 } 140 141 UEdge fromUEdgeId(int id) const { 142 return graph->fromUEdgeId(id); 143 } 130 144 131 145 int maxNodeId() const { … … 174 188 template <typename CMap> 175 189 NodeMap& operator=(const CMap& cmap) { 176 checkConcept<concept::ReadMap<Node, _Value>, CMap>(); 177 const typename Parent::Graph* graph = Parent::getGraph(); 178 Node it; 179 for (graph->first(it); it != INVALID; graph->next(it)) { 180 Parent::set(it, cmap[it]); 181 } 182 return *this; 183 } 190 Parent::operator=(cmap); 191 return *this; 192 } 193 184 194 }; 185 195 … … 199 209 template <typename CMap> 200 210 EdgeMap& operator=(const CMap& cmap) { 201 checkConcept<concept::ReadMap<Edge, _Value>, CMap>(); 202 const typename Parent::Graph* graph = Parent::getGraph(); 203 Edge it; 204 for (graph->first(it); it != INVALID; graph->next(it)) { 205 Parent::set(it, cmap[it]); 206 } 211 Parent::operator=(cmap); 207 212 return *this; 208 213 } … … 224 229 template <typename CMap> 225 230 UEdgeMap& operator=(const CMap& cmap) { 226 checkConcept<concept::ReadMap<UEdge, _Value>, CMap>(); 227 const typename Parent::Graph* graph = Parent::getGraph(); 228 UEdge it; 229 for (graph->first(it); it != INVALID; graph->next(it)) { 230 Parent::set(it, cmap[it]); 231 } 232 return *this; 231 Parent::operator=(cmap); 232 return *this; 233 233 } 234 234 }; … … 255 255 public: 256 256 typedef _UGraph Graph; 257 typedef SubUGraphAdaptorBase Adaptor; 257 258 typedef UGraphAdaptorBase<_UGraph> Parent; 258 259 protected: … … 417 418 return uedge; 418 419 } 420 421 template <typename _Value> 422 class NodeMap 423 : public SubMapExtender<Adaptor, 424 typename Parent::template NodeMap<_Value> > 425 { 426 public: 427 typedef Adaptor Graph; 428 typedef SubMapExtender<Adaptor, typename Parent:: 429 template NodeMap<_Value> > Parent; 430 431 NodeMap(const Graph& graph) 432 : Parent(graph) {} 433 NodeMap(const Graph& graph, const _Value& value) 434 : Parent(graph, value) {} 435 436 NodeMap& operator=(const NodeMap& cmap) { 437 return operator=<NodeMap>(cmap); 438 } 439 440 template <typename CMap> 441 NodeMap& operator=(const CMap& cmap) { 442 Parent::operator=(cmap); 443 return *this; 444 } 445 }; 446 447 template <typename _Value> 448 class EdgeMap 449 : public SubMapExtender<Adaptor, 450 typename Parent::template EdgeMap<_Value> > 451 { 452 public: 453 typedef Adaptor Graph; 454 typedef SubMapExtender<Adaptor, typename Parent:: 455 template EdgeMap<_Value> > Parent; 456 457 EdgeMap(const Graph& graph) 458 : Parent(graph) {} 459 EdgeMap(const Graph& graph, const _Value& value) 460 : Parent(graph, value) {} 461 462 EdgeMap& operator=(const EdgeMap& cmap) { 463 return operator=<EdgeMap>(cmap); 464 } 465 466 template <typename CMap> 467 EdgeMap& operator=(const CMap& cmap) { 468 Parent::operator=(cmap); 469 return *this; 470 } 471 }; 472 473 template <typename _Value> 474 class UEdgeMap 475 : public SubMapExtender<Adaptor, 476 typename Parent::template UEdgeMap<_Value> > 477 { 478 public: 479 typedef Adaptor Graph; 480 typedef SubMapExtender<Adaptor, typename Parent:: 481 template UEdgeMap<_Value> > Parent; 482 483 UEdgeMap(const Graph& graph) 484 : Parent(graph) {} 485 UEdgeMap(const Graph& graph, const _Value& value) 486 : Parent(graph, value) {} 487 488 UEdgeMap& operator=(const UEdgeMap& cmap) { 489 return operator=<UEdgeMap>(cmap); 490 } 491 492 template <typename CMap> 493 UEdgeMap& operator=(const CMap& cmap) { 494 Parent::operator=(cmap); 495 return *this; 496 } 497 }; 498 419 499 }; 420 500 … … 424 504 public: 425 505 typedef _UGraph Graph; 506 typedef SubUGraphAdaptorBase Adaptor; 426 507 typedef UGraphAdaptorBase<_UGraph> Parent; 427 508 protected: … … 560 641 return uedge; 561 642 } 643 644 template <typename _Value> 645 class NodeMap 646 : public SubMapExtender<Adaptor, 647 typename Parent::template NodeMap<_Value> > 648 { 649 public: 650 typedef Adaptor Graph; 651 typedef SubMapExtender<Adaptor, typename Parent:: 652 template NodeMap<_Value> > Parent; 653 654 NodeMap(const Graph& graph) 655 : Parent(graph) {} 656 NodeMap(const Graph& graph, const _Value& value) 657 : Parent(graph, value) {} 658 659 NodeMap& operator=(const NodeMap& cmap) { 660 return operator=<NodeMap>(cmap); 661 } 662 663 template <typename CMap> 664 NodeMap& operator=(const CMap& cmap) { 665 Parent::operator=(cmap); 666 return *this; 667 } 668 }; 669 670 template <typename _Value> 671 class EdgeMap 672 : public SubMapExtender<Adaptor, 673 typename Parent::template EdgeMap<_Value> > 674 { 675 public: 676 typedef Adaptor Graph; 677 typedef SubMapExtender<Adaptor, typename Parent:: 678 template EdgeMap<_Value> > Parent; 679 680 EdgeMap(const Graph& graph) 681 : Parent(graph) {} 682 EdgeMap(const Graph& graph, const _Value& value) 683 : Parent(graph, value) {} 684 685 EdgeMap& operator=(const EdgeMap& cmap) { 686 return operator=<EdgeMap>(cmap); 687 } 688 689 template <typename CMap> 690 EdgeMap& operator=(const CMap& cmap) { 691 Parent::operator=(cmap); 692 return *this; 693 } 694 }; 695 696 template <typename _Value> 697 class UEdgeMap 698 : public SubMapExtender<Adaptor, 699 typename Parent::template UEdgeMap<_Value> > 700 { 701 public: 702 typedef Adaptor Graph; 703 typedef SubMapExtender<Adaptor, typename Parent:: 704 template UEdgeMap<_Value> > Parent; 705 706 UEdgeMap(const Graph& graph) 707 : Parent(graph) {} 708 UEdgeMap(const Graph& graph, const _Value& value) 709 : Parent(graph, value) {} 710 711 UEdgeMap& operator=(const UEdgeMap& cmap) { 712 return operator=<UEdgeMap>(cmap); 713 } 714 715 template <typename CMap> 716 UEdgeMap& operator=(const CMap& cmap) { 717 Parent::operator=(cmap); 718 return *this; 719 } 720 }; 562 721 }; 563 722 … … 679 838 } 680 839 681 682 840 /// \brief An adaptor for hiding undirected edges from an undirected graph. 683 841 /// … … 705 863 706 864 public: 865 707 866 EdgeSubUGraphAdaptor(Graph& _graph, UEdgeFilterMap& _uedge_filter_map) : 708 867 Parent(), const_true_map(true) { … … 711 870 Parent::setUEdgeFilterMap(_uedge_filter_map); 712 871 } 872 713 873 }; 714 874 … … 838 998 class NodeMap : public _UGraph::template NodeMap<_Value> { 839 999 public: 1000 840 1001 typedef typename _UGraph::template NodeMap<_Value> Parent; 1002 841 1003 explicit NodeMap(const DirUGraphAdaptorBase& ga) 842 : Parent(*ga.graph) { } 1004 : Parent(*ga.graph) {} 1005 843 1006 NodeMap(const DirUGraphAdaptorBase& ga, const _Value& value) 844 : Parent(*ga.graph, value) { } 1007 : Parent(*ga.graph, value) {} 1008 1009 NodeMap& operator=(const NodeMap& cmap) { 1010 return operator=<NodeMap>(cmap); 1011 } 1012 1013 template <typename CMap> 1014 NodeMap& operator=(const CMap& cmap) { 1015 Parent::operator=(cmap); 1016 return *this; 1017 } 1018 845 1019 }; 846 1020 … … 848 1022 class EdgeMap : public _UGraph::template UEdgeMap<_Value> { 849 1023 public: 1024 850 1025 typedef typename _UGraph::template UEdgeMap<_Value> Parent; 1026 851 1027 explicit EdgeMap(const DirUGraphAdaptorBase& ga) 852 1028 : Parent(*ga.graph) { } 1029 853 1030 EdgeMap(const DirUGraphAdaptorBase& ga, const _Value& value) 854 1031 : Parent(*ga.graph, value) { } 1032 1033 EdgeMap& operator=(const EdgeMap& cmap) { 1034 return operator=<EdgeMap>(cmap); 1035 } 1036 1037 template <typename CMap> 1038 EdgeMap& operator=(const CMap& cmap) { 1039 Parent::operator=(cmap); 1040 return *this; 1041 } 855 1042 }; 856 1043
Note: See TracChangeset
for help on using the changeset viewer.