440 template<typename TT> EdgeMap &operator=(const EdgeMap<TT>&) |
443 template<typename TT> EdgeMap &operator=(const EdgeMap<TT>&) |
441 { return *this; } |
444 { return *this; } |
442 }; |
445 }; |
443 }; |
446 }; |
444 |
447 |
445 |
448 struct DummyType { |
|
449 int value; |
|
450 DummyType() {} |
|
451 DummyType(int p) : value(p) {} |
|
452 DummyType& operator=(int p) { value = p; return *this;} |
|
453 }; |
|
454 |
|
455 ///\brief Checks whether \c G meets the |
|
456 ///\ref lemon::skeleton::StaticGraph "StaticGraph" concept |
|
457 template<class Graph> void checkCompileStaticGraph(Graph &G) |
|
458 { |
|
459 typedef typename Graph::Node Node; |
|
460 typedef typename Graph::NodeIt NodeIt; |
|
461 typedef typename Graph::Edge Edge; |
|
462 typedef typename Graph::EdgeIt EdgeIt; |
|
463 typedef typename Graph::InEdgeIt InEdgeIt; |
|
464 typedef typename Graph::OutEdgeIt OutEdgeIt; |
446 |
465 |
|
466 { |
|
467 Node i; Node j(i); Node k(INVALID); |
|
468 i=j; |
|
469 bool b; b=true; |
|
470 b=(i==INVALID); b=(i!=INVALID); |
|
471 b=(i==j); b=(i!=j); b=(i<j); |
|
472 } |
|
473 { |
|
474 NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G); |
|
475 i=j; |
|
476 j=G.first(i); |
|
477 j=++i; |
|
478 bool b; b=true; |
|
479 b=(i==INVALID); b=(i!=INVALID); |
|
480 Node n(i); |
|
481 n=i; |
|
482 b=(i==j); b=(i!=j); b=(i<j); |
|
483 //Node ->NodeIt conversion |
|
484 NodeIt ni(G,n); |
|
485 } |
|
486 { |
|
487 Edge i; Edge j(i); Edge k(INVALID); |
|
488 i=j; |
|
489 bool b; b=true; |
|
490 b=(i==INVALID); b=(i!=INVALID); |
|
491 b=(i==j); b=(i!=j); b=(i<j); |
|
492 } |
|
493 { |
|
494 EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G); |
|
495 i=j; |
|
496 j=G.first(i); |
|
497 j=++i; |
|
498 bool b; b=true; |
|
499 b=(i==INVALID); b=(i!=INVALID); |
|
500 Edge e(i); |
|
501 e=i; |
|
502 b=(i==j); b=(i!=j); b=(i<j); |
|
503 //Edge ->EdgeIt conversion |
|
504 EdgeIt ei(G,e); |
|
505 } |
|
506 { |
|
507 Node n; |
|
508 InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n); |
|
509 i=j; |
|
510 j=G.first(i,n); |
|
511 j=++i; |
|
512 bool b; b=true; |
|
513 b=(i==INVALID); b=(i!=INVALID); |
|
514 Edge e(i); |
|
515 e=i; |
|
516 b=(i==j); b=(i!=j); b=(i<j); |
|
517 //Edge ->InEdgeIt conversion |
|
518 InEdgeIt ei(G,e); |
|
519 } |
|
520 { |
|
521 Node n; |
|
522 OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n); |
|
523 i=j; |
|
524 j=G.first(i,n); |
|
525 j=++i; |
|
526 bool b; b=true; |
|
527 b=(i==INVALID); b=(i!=INVALID); |
|
528 Edge e(i); |
|
529 e=i; |
|
530 b=(i==j); b=(i!=j); b=(i<j); |
|
531 //Edge ->OutEdgeIt conversion |
|
532 OutEdgeIt ei(G,e); |
|
533 } |
|
534 { |
|
535 Node n,m; |
|
536 n=m=INVALID; |
|
537 Edge e; |
|
538 e=INVALID; |
|
539 n=G.tail(e); |
|
540 n=G.head(e); |
|
541 } |
|
542 // id tests |
|
543 { Node n; int i=G.id(n); i=i; } |
|
544 { Edge e; int i=G.id(e); i=i; } |
|
545 //NodeMap tests |
|
546 { |
|
547 Node k; |
|
548 typename Graph::template NodeMap<int> m(G); |
|
549 //Const map |
|
550 typename Graph::template NodeMap<int> const &cm = m; |
|
551 //Inicialize with default value |
|
552 typename Graph::template NodeMap<int> mdef(G,12); |
|
553 //Copy |
|
554 typename Graph::template NodeMap<int> mm(cm); |
|
555 //Copy from another type |
|
556 typename Graph::template NodeMap<double> dm(cm); |
|
557 //Copy to more complex type |
|
558 typename Graph::template NodeMap<DummyType> em(cm); |
|
559 int v; |
|
560 v=m[k]; m[k]=v; m.set(k,v); |
|
561 v=cm[k]; |
|
562 |
|
563 m=cm; |
|
564 dm=cm; //Copy from another type |
|
565 em=cm; //Copy to more complex type |
|
566 { |
|
567 //Check the typedef's |
|
568 typename Graph::template NodeMap<int>::ValueType val; |
|
569 val=1; |
|
570 typename Graph::template NodeMap<int>::KeyType key; |
|
571 key = typename Graph::NodeIt(G); |
|
572 } |
|
573 } |
|
574 { //bool NodeMap |
|
575 Node k; |
|
576 typename Graph::template NodeMap<bool> m(G); |
|
577 typename Graph::template NodeMap<bool> const &cm = m; //Const map |
|
578 //Inicialize with default value |
|
579 typename Graph::template NodeMap<bool> mdef(G,12); |
|
580 typename Graph::template NodeMap<bool> mm(cm); //Copy |
|
581 typename Graph::template NodeMap<int> dm(cm); //Copy from another type |
|
582 bool v; |
|
583 v=m[k]; m[k]=v; m.set(k,v); |
|
584 v=cm[k]; |
|
585 |
|
586 m=cm; |
|
587 dm=cm; //Copy from another type |
|
588 m=dm; //Copy to another type |
|
589 |
|
590 { |
|
591 //Check the typedef's |
|
592 typename Graph::template NodeMap<bool>::ValueType val; |
|
593 val=true; |
|
594 typename Graph::template NodeMap<bool>::KeyType key; |
|
595 key= typename Graph::NodeIt(G); |
|
596 } |
|
597 } |
|
598 //EdgeMap tests |
|
599 { |
|
600 Edge k; |
|
601 typename Graph::template EdgeMap<int> m(G); |
|
602 typename Graph::template EdgeMap<int> const &cm = m; //Const map |
|
603 //Inicialize with default value |
|
604 typename Graph::template EdgeMap<int> mdef(G,12); |
|
605 typename Graph::template EdgeMap<int> mm(cm); //Copy |
|
606 typename Graph::template EdgeMap<double> dm(cm);//Copy from another type |
|
607 int v; |
|
608 v=m[k]; m[k]=v; m.set(k,v); |
|
609 v=cm[k]; |
|
610 |
|
611 m=cm; |
|
612 dm=cm; //Copy from another type |
|
613 { |
|
614 //Check the typedef's |
|
615 typename Graph::template EdgeMap<int>::ValueType val; |
|
616 val=1; |
|
617 typename Graph::template EdgeMap<int>::KeyType key; |
|
618 key= typename Graph::EdgeIt(G); |
|
619 } |
|
620 } |
|
621 { //bool EdgeMap |
|
622 Edge k; |
|
623 typename Graph::template EdgeMap<bool> m(G); |
|
624 typename Graph::template EdgeMap<bool> const &cm = m; //Const map |
|
625 //Inicialize with default value |
|
626 typename Graph::template EdgeMap<bool> mdef(G,12); |
|
627 typename Graph::template EdgeMap<bool> mm(cm); //Copy |
|
628 typename Graph::template EdgeMap<int> dm(cm); //Copy from another type |
|
629 bool v; |
|
630 v=m[k]; m[k]=v; m.set(k,v); |
|
631 v=cm[k]; |
|
632 |
|
633 m=cm; |
|
634 dm=cm; //Copy from another type |
|
635 m=dm; //Copy to another type |
|
636 { |
|
637 //Check the typedef's |
|
638 typename Graph::template EdgeMap<bool>::ValueType val; |
|
639 val=true; |
|
640 typename Graph::template EdgeMap<bool>::KeyType key; |
|
641 key= typename Graph::EdgeIt(G); |
|
642 } |
|
643 } |
|
644 } |
|
645 |
447 /// An empty non-static graph class. |
646 /// An empty non-static graph class. |
448 |
647 |
449 /// This class provides everything that \ref StaticGraph |
648 /// This class provides everything that \ref StaticGraph |
450 /// with additional functionality which enables to build a |
649 /// with additional functionality which enables to build a |
451 /// graph from scratch. |
650 /// graph from scratch. |
452 class ExtendableGraph : public StaticGraph |
651 class ExtendableGraph : public StaticGraph |
453 { |
652 { |
475 /// It also frees the memory allocated to store them. |
674 /// It also frees the memory allocated to store them. |
476 /// \todo It might belong to \ref ErasableGraph. |
675 /// \todo It might belong to \ref ErasableGraph. |
477 void clear() { } |
676 void clear() { } |
478 }; |
677 }; |
479 |
678 |
|
679 |
|
680 ///\brief Checks whether \c G meets the |
|
681 ///\ref lemon::skeleton::ExtendableGraph "ExtendableGraph" concept |
|
682 template<class Graph> void checkCompileExtendableGraph(Graph &G) |
|
683 { |
|
684 checkCompileStaticGraph(G); |
|
685 |
|
686 typedef typename Graph::Node Node; |
|
687 typedef typename Graph::NodeIt NodeIt; |
|
688 typedef typename Graph::Edge Edge; |
|
689 typedef typename Graph::EdgeIt EdgeIt; |
|
690 typedef typename Graph::InEdgeIt InEdgeIt; |
|
691 typedef typename Graph::OutEdgeIt OutEdgeIt; |
|
692 |
|
693 Node n,m; |
|
694 n=G.addNode(); |
|
695 m=G.addNode(); |
|
696 Edge e; |
|
697 e=G.addEdge(n,m); |
|
698 |
|
699 // G.clear(); |
|
700 } |
|
701 |
|
702 |
480 /// An empty erasable graph class. |
703 /// An empty erasable graph class. |
481 |
704 |
482 /// This class is an extension of \ref ExtendableGraph. It also makes it |
705 /// This class is an extension of \ref ExtendableGraph. It also makes it |
483 /// possible to erase edges or nodes. |
706 /// possible to erase edges or nodes. |
484 class ErasableGraph : public ExtendableGraph |
707 class ErasableGraph : public ExtendableGraph |
498 |
721 |
499 /// Deletes edge \c e edge. |
722 /// Deletes edge \c e edge. |
500 /// |
723 /// |
501 void erase(Edge e) { } |
724 void erase(Edge e) { } |
502 }; |
725 }; |
503 |
726 |
|
727 template<class Graph> void checkCompileGraphEraseEdge(Graph &G) |
|
728 { |
|
729 typename Graph::Edge e; |
|
730 G.erase(e); |
|
731 } |
|
732 |
|
733 template<class Graph> void checkCompileGraphEraseNode(Graph &G) |
|
734 { |
|
735 typename Graph::Node n; |
|
736 G.erase(n); |
|
737 } |
|
738 |
|
739 ///\brief Checks whether \c G meets the |
|
740 ///\ref lemon::skeleton::EresableGraph "EresableGraph" concept |
|
741 template<class Graph> void checkCompileErasableGraph(Graph &G) |
|
742 { |
|
743 checkCompileExtendableGraph(G); |
|
744 checkCompileGraphEraseNode(G); |
|
745 checkCompileGraphEraseEdge(G); |
|
746 } |
|
747 |
|
748 ///Checks whether a graph has findEdge() member function. |
|
749 |
|
750 ///\todo findEdge() might be a global function. |
|
751 /// |
|
752 template<class Graph> void checkCompileGraphFindEdge(Graph &G) |
|
753 { |
|
754 typedef typename Graph::NodeIt Node; |
|
755 typedef typename Graph::NodeIt NodeIt; |
|
756 |
|
757 G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G))); |
|
758 G.findEdge(Node(),Node(),G.findEdge(Node(),Node())); |
|
759 } |
|
760 |
504 // @} |
761 // @} |
505 } //namespace skeleton |
762 } //namespace skeleton |
506 } //namespace lemon |
763 } //namespace lemon |
507 |
764 |
508 |
765 |