gravatar
alpar (Alpar Juttner)
alpar@cs.elte.hu
Merge bugfix #311
0 2 0
merge 1.1
0 files changed with 5 insertions and 5 deletions:
↑ Collapse diff ↑
Ignore white space 24 line context
... ...
@@ -528,49 +528,49 @@
528 528
    // Returns the running node of the iterator
529 529
    Node runningNode(const IncEdgeIt &e) const {
530 530
      return e.direction ? v(e) : u(e);
531 531
    }
532 532

	
533 533

	
534 534
    template <typename _Value>
535 535
    class ArcMap 
536 536
      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
537 537
      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
538 538

	
539 539
    public:
540
      ArcMap(const Graph& _g) 
540
      explicit ArcMap(const Graph& _g) 
541 541
	: Parent(_g) {}
542 542
      ArcMap(const Graph& _g, const _Value& _v) 
543 543
	: Parent(_g, _v) {}
544 544

	
545 545
      ArcMap& operator=(const ArcMap& cmap) {
546 546
	return operator=<ArcMap>(cmap);
547 547
      }
548 548

	
549 549
      template <typename CMap>
550 550
      ArcMap& operator=(const CMap& cmap) {
551 551
        Parent::operator=(cmap);
552 552
	return *this;
553 553
      }
554 554

	
555 555
    };
556 556

	
557 557

	
558 558
    template <typename _Value>
559 559
    class EdgeMap 
560 560
      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
561 561
      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
562 562

	
563 563
    public:
564
      EdgeMap(const Graph& _g) 
564
      explicit EdgeMap(const Graph& _g) 
565 565
	: Parent(_g) {}
566 566

	
567 567
      EdgeMap(const Graph& _g, const _Value& _v) 
568 568
	: Parent(_g, _v) {}
569 569

	
570 570
      EdgeMap& operator=(const EdgeMap& cmap) {
571 571
	return operator=<EdgeMap>(cmap);
572 572
      }
573 573

	
574 574
      template <typename CMap>
575 575
      EdgeMap& operator=(const CMap& cmap) {
576 576
        Parent::operator=(cmap);
Ignore white space 24 line context
... ...
@@ -595,73 +595,73 @@
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

	
601 601
    template <typename _Value>
602 602
    class NodeMap
603 603
      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
604 604
      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
605 605

	
606 606
    public:
607
      NodeMap(const Graph& graph)
607
      explicit NodeMap(const Graph& graph)
608 608
        : Parent(graph) {}
609 609
      NodeMap(const Graph& graph, const _Value& value)
610 610
        : Parent(graph, value) {}
611 611

	
612 612
    private:
613 613
      NodeMap& operator=(const NodeMap& cmap) {
614 614
        return operator=<NodeMap>(cmap);
615 615
      }
616 616

	
617 617
      template <typename CMap>
618 618
      NodeMap& operator=(const CMap& cmap) {
619 619
        Parent::operator=(cmap);
620 620
        return *this;
621 621
      }
622 622

	
623 623
    };
624 624

	
625 625
    template <typename _Value>
626 626
    class ArcMap
627 627
      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
628 628
      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
629 629

	
630 630
    public:
631
      ArcMap(const Graph& graph)
631
      explicit ArcMap(const Graph& graph)
632 632
        : Parent(graph) {}
633 633
      ArcMap(const Graph& graph, const _Value& value)
634 634
        : Parent(graph, value) {}
635 635

	
636 636
    private:
637 637
      ArcMap& operator=(const ArcMap& cmap) {
638 638
        return operator=<ArcMap>(cmap);
639 639
      }
640 640

	
641 641
      template <typename CMap>
642 642
      ArcMap& operator=(const CMap& cmap) {
643 643
        Parent::operator=(cmap);
644 644
        return *this;
645 645
      }
646 646
    };
647 647

	
648 648

	
649 649
    template <typename _Value>
650 650
    class EdgeMap
651 651
      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
652 652
      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
653 653

	
654 654
    public:
655
      EdgeMap(const Graph& graph)
655
      explicit EdgeMap(const Graph& graph)
656 656
        : Parent(graph) {}
657 657

	
658 658
      EdgeMap(const Graph& graph, const _Value& value)
659 659
        : Parent(graph, value) {}
660 660

	
661 661
    private:
662 662
      EdgeMap& operator=(const EdgeMap& cmap) {
663 663
        return operator=<EdgeMap>(cmap);
664 664
      }
665 665

	
666 666
      template <typename CMap>
667 667
      EdgeMap& operator=(const CMap& cmap) {
0 comments (0 inline)