lemon/concepts/graph.h
changeset 1210 da87dbdf3daf
parent 1130 0759d974de81
equal deleted inserted replaced
23:c2b382237846 24:63033add9e04
   106         /// Copy constructor.
   106         /// Copy constructor.
   107 
   107 
   108         /// Copy constructor.
   108         /// Copy constructor.
   109         ///
   109         ///
   110         Node(const Node&) { }
   110         Node(const Node&) { }
       
   111         /// Assignment operator
       
   112 
       
   113         /// Assignment operator.
       
   114         ///
       
   115         const Node &operator=(const Node&) { return *this; }
   111 
   116 
   112         /// %Invalid constructor \& conversion.
   117         /// %Invalid constructor \& conversion.
   113 
   118 
   114         /// Initializes the object to be invalid.
   119         /// Initializes the object to be invalid.
   115         /// \sa Invalid for more details.
   120         /// \sa Invalid for more details.
   157         /// Copy constructor.
   162         /// Copy constructor.
   158 
   163 
   159         /// Copy constructor.
   164         /// Copy constructor.
   160         ///
   165         ///
   161         NodeIt(const NodeIt& n) : Node(n) { }
   166         NodeIt(const NodeIt& n) : Node(n) { }
       
   167         /// Assignment operator
       
   168 
       
   169         /// Assignment operator.
       
   170         ///
       
   171         const NodeIt &operator=(const NodeIt&) { return *this; }
       
   172 
   162         /// %Invalid constructor \& conversion.
   173         /// %Invalid constructor \& conversion.
   163 
   174 
   164         /// Initializes the iterator to be invalid.
   175         /// Initializes the iterator to be invalid.
   165         /// \sa Invalid for more details.
   176         /// \sa Invalid for more details.
   166         NodeIt(Invalid) { }
   177         NodeIt(Invalid) { }
   216         /// Copy constructor.
   227         /// Copy constructor.
   217 
   228 
   218         /// Copy constructor.
   229         /// Copy constructor.
   219         ///
   230         ///
   220         Edge(const Edge&) { }
   231         Edge(const Edge&) { }
       
   232         /// Assignment operator
       
   233 
       
   234         /// Assignment operator.
       
   235         ///
       
   236         const Edge &operator=(const Edge&) { return *this; }
       
   237 
   221         /// %Invalid constructor \& conversion.
   238         /// %Invalid constructor \& conversion.
   222 
   239 
   223         /// Initializes the object to be invalid.
   240         /// Initializes the object to be invalid.
   224         /// \sa Invalid for more details.
   241         /// \sa Invalid for more details.
   225         Edge(Invalid) { }
   242         Edge(Invalid) { }
   264         /// Copy constructor.
   281         /// Copy constructor.
   265 
   282 
   266         /// Copy constructor.
   283         /// Copy constructor.
   267         ///
   284         ///
   268         EdgeIt(const EdgeIt& e) : Edge(e) { }
   285         EdgeIt(const EdgeIt& e) : Edge(e) { }
       
   286         /// Assignment operator
       
   287 
       
   288         /// Assignment operator.
       
   289         ///
       
   290         const EdgeIt &operator=(const EdgeIt&) { return *this; }
       
   291 
   269         /// %Invalid constructor \& conversion.
   292         /// %Invalid constructor \& conversion.
   270 
   293 
   271         /// Initializes the iterator to be invalid.
   294         /// Initializes the iterator to be invalid.
   272         /// \sa Invalid for more details.
   295         /// \sa Invalid for more details.
   273         EdgeIt(Invalid) { }
   296         EdgeIt(Invalid) { }
   333         /// Copy constructor.
   356         /// Copy constructor.
   334 
   357 
   335         /// Copy constructor.
   358         /// Copy constructor.
   336         ///
   359         ///
   337         IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
   360         IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
       
   361         /// Assignment operator
       
   362 
       
   363         /// Assignment operator.
       
   364         ///
       
   365         const IncEdgeIt &operator=(const IncEdgeIt&) { return *this; }
       
   366 
   338         /// %Invalid constructor \& conversion.
   367         /// %Invalid constructor \& conversion.
   339 
   368 
   340         /// Initializes the iterator to be invalid.
   369         /// Initializes the iterator to be invalid.
   341         /// \sa Invalid for more details.
   370         /// \sa Invalid for more details.
   342         IncEdgeIt(Invalid) { }
   371         IncEdgeIt(Invalid) { }
   394         /// Copy constructor.
   423         /// Copy constructor.
   395 
   424 
   396         /// Copy constructor.
   425         /// Copy constructor.
   397         ///
   426         ///
   398         Arc(const Arc&) { }
   427         Arc(const Arc&) { }
       
   428         /// Assignment operator
       
   429 
       
   430         /// Assignment operator.
       
   431         ///
       
   432         const Arc &operator=(const Arc&) { return *this; }
       
   433 
   399         /// %Invalid constructor \& conversion.
   434         /// %Invalid constructor \& conversion.
   400 
   435 
   401         /// Initializes the object to be invalid.
   436         /// Initializes the object to be invalid.
   402         /// \sa Invalid for more details.
   437         /// \sa Invalid for more details.
   403         Arc(Invalid) { }
   438         Arc(Invalid) { }
   448         /// Copy constructor.
   483         /// Copy constructor.
   449 
   484 
   450         /// Copy constructor.
   485         /// Copy constructor.
   451         ///
   486         ///
   452         ArcIt(const ArcIt& e) : Arc(e) { }
   487         ArcIt(const ArcIt& e) : Arc(e) { }
       
   488         /// Assignment operator
       
   489 
       
   490         /// Assignment operator.
       
   491         ///
       
   492         const ArcIt &operator=(const ArcIt&) { return *this; }
       
   493 
   453         /// %Invalid constructor \& conversion.
   494         /// %Invalid constructor \& conversion.
   454 
   495 
   455         /// Initializes the iterator to be invalid.
   496         /// Initializes the iterator to be invalid.
   456         /// \sa Invalid for more details.
   497         /// \sa Invalid for more details.
   457         ArcIt(Invalid) { }
   498         ArcIt(Invalid) { }
   516         /// Copy constructor.
   557         /// Copy constructor.
   517 
   558 
   518         /// Copy constructor.
   559         /// Copy constructor.
   519         ///
   560         ///
   520         OutArcIt(const OutArcIt& e) : Arc(e) { }
   561         OutArcIt(const OutArcIt& e) : Arc(e) { }
       
   562         /// Assignment operator
       
   563 
       
   564         /// Assignment operator.
       
   565         ///
       
   566         const OutArcIt &operator=(const OutArcIt&) { return *this; }
       
   567 
   521         /// %Invalid constructor \& conversion.
   568         /// %Invalid constructor \& conversion.
   522 
   569 
   523         /// Initializes the iterator to be invalid.
   570         /// Initializes the iterator to be invalid.
   524         /// \sa Invalid for more details.
   571         /// \sa Invalid for more details.
   525         OutArcIt(Invalid) { }
   572         OutArcIt(Invalid) { }
   585         /// Copy constructor.
   632         /// Copy constructor.
   586 
   633 
   587         /// Copy constructor.
   634         /// Copy constructor.
   588         ///
   635         ///
   589         InArcIt(const InArcIt& e) : Arc(e) { }
   636         InArcIt(const InArcIt& e) : Arc(e) { }
       
   637         /// Assignment operator
       
   638 
       
   639         /// Assignment operator.
       
   640         ///
       
   641         const InArcIt &operator=(const InArcIt&) { return *this; }
       
   642 
   590         /// %Invalid constructor \& conversion.
   643         /// %Invalid constructor \& conversion.
   591 
   644 
   592         /// Initializes the iterator to be invalid.
   645         /// Initializes the iterator to be invalid.
   593         /// \sa Invalid for more details.
   646         /// \sa Invalid for more details.
   594         InArcIt(Invalid) { }
   647         InArcIt(Invalid) { }
   649       private:
   702       private:
   650         ///Copy constructor
   703         ///Copy constructor
   651         NodeMap(const NodeMap& nm) :
   704         NodeMap(const NodeMap& nm) :
   652           ReferenceMap<Node, T, T&, const T&>(nm) { }
   705           ReferenceMap<Node, T, T&, const T&>(nm) { }
   653         ///Assignment operator
   706         ///Assignment operator
       
   707         NodeMap& operator=(const NodeMap&) {
       
   708           return *this;
       
   709         }
       
   710         ///Template Assignment operator
   654         template <typename CMap>
   711         template <typename CMap>
   655         NodeMap& operator=(const CMap&) {
   712         NodeMap& operator=(const CMap&) {
   656           checkConcept<ReadMap<Node, T>, CMap>();
   713           checkConcept<ReadMap<Node, T>, CMap>();
   657           return *this;
   714           return *this;
   658         }
   715         }
   675       private:
   732       private:
   676         ///Copy constructor
   733         ///Copy constructor
   677         ArcMap(const ArcMap& em) :
   734         ArcMap(const ArcMap& em) :
   678           ReferenceMap<Arc, T, T&, const T&>(em) { }
   735           ReferenceMap<Arc, T, T&, const T&>(em) { }
   679         ///Assignment operator
   736         ///Assignment operator
       
   737         ArcMap& operator=(const ArcMap&) {
       
   738           return *this;
       
   739         }
       
   740         ///Template Assignment operator
   680         template <typename CMap>
   741         template <typename CMap>
   681         ArcMap& operator=(const CMap&) {
   742         ArcMap& operator=(const CMap&) {
   682           checkConcept<ReadMap<Arc, T>, CMap>();
   743           checkConcept<ReadMap<Arc, T>, CMap>();
   683           return *this;
   744           return *this;
   684         }
   745         }
   701       private:
   762       private:
   702         ///Copy constructor
   763         ///Copy constructor
   703         EdgeMap(const EdgeMap& em) :
   764         EdgeMap(const EdgeMap& em) :
   704           ReferenceMap<Edge, T, T&, const T&>(em) {}
   765           ReferenceMap<Edge, T, T&, const T&>(em) {}
   705         ///Assignment operator
   766         ///Assignment operator
       
   767         EdgeMap& operator=(const EdgeMap&) {
       
   768           return *this;
       
   769         }
       
   770         ///Template Assignment operator
   706         template <typename CMap>
   771         template <typename CMap>
   707         EdgeMap& operator=(const CMap&) {
   772         EdgeMap& operator=(const CMap&) {
   708           checkConcept<ReadMap<Edge, T>, CMap>();
   773           checkConcept<ReadMap<Edge, T>, CMap>();
   709           return *this;
   774           return *this;
   710         }
   775         }