lemon/concepts/digraph.h
changeset 1211 a278d16bd2d0
parent 1130 0759d974de81
equal deleted inserted replaced
19:04c9317e4bf8 20:077a33058001
    75 
    75 
    76         /// Copy constructor.
    76         /// Copy constructor.
    77         ///
    77         ///
    78         Node(const Node&) { }
    78         Node(const Node&) { }
    79 
    79 
       
    80         /// Assignment operator
       
    81 
       
    82         /// Assignment operator.
       
    83         ///
       
    84         const Node &operator=(const Node&) { return *this; }
       
    85 
    80         /// %Invalid constructor \& conversion.
    86         /// %Invalid constructor \& conversion.
    81 
    87 
    82         /// Initializes the object to be invalid.
    88         /// Initializes the object to be invalid.
    83         /// \sa Invalid for more details.
    89         /// \sa Invalid for more details.
    84         Node(Invalid) { }
    90         Node(Invalid) { }
   124         /// Copy constructor.
   130         /// Copy constructor.
   125 
   131 
   126         /// Copy constructor.
   132         /// Copy constructor.
   127         ///
   133         ///
   128         NodeIt(const NodeIt& n) : Node(n) { }
   134         NodeIt(const NodeIt& n) : Node(n) { }
       
   135         /// Assignment operator
       
   136 
       
   137         /// Assignment operator.
       
   138         ///
       
   139         const NodeIt &operator=(const NodeIt&) { return *this; }
       
   140 
   129         /// %Invalid constructor \& conversion.
   141         /// %Invalid constructor \& conversion.
   130 
   142 
   131         /// Initializes the iterator to be invalid.
   143         /// Initializes the iterator to be invalid.
   132         /// \sa Invalid for more details.
   144         /// \sa Invalid for more details.
   133         NodeIt(Invalid) { }
   145         NodeIt(Invalid) { }
   183         /// Copy constructor.
   195         /// Copy constructor.
   184 
   196 
   185         /// Copy constructor.
   197         /// Copy constructor.
   186         ///
   198         ///
   187         Arc(const Arc&) { }
   199         Arc(const Arc&) { }
       
   200         /// Assignment operator
       
   201 
       
   202         /// Assignment operator.
       
   203         ///
       
   204         const Arc &operator=(const Arc&) { return *this; }
       
   205 
   188         /// %Invalid constructor \& conversion.
   206         /// %Invalid constructor \& conversion.
   189 
   207 
   190         /// Initializes the object to be invalid.
   208         /// Initializes the object to be invalid.
   191         /// \sa Invalid for more details.
   209         /// \sa Invalid for more details.
   192         Arc(Invalid) { }
   210         Arc(Invalid) { }
   233         /// Copy constructor.
   251         /// Copy constructor.
   234 
   252 
   235         /// Copy constructor.
   253         /// Copy constructor.
   236         ///
   254         ///
   237         OutArcIt(const OutArcIt& e) : Arc(e) { }
   255         OutArcIt(const OutArcIt& e) : Arc(e) { }
       
   256         /// Assignment operator
       
   257 
       
   258         /// Assignment operator.
       
   259         ///
       
   260         const OutArcIt &operator=(const OutArcIt&) { return *this; }
   238         /// %Invalid constructor \& conversion.
   261         /// %Invalid constructor \& conversion.
   239 
   262 
   240         /// Initializes the iterator to be invalid.
   263         /// Initializes the iterator to be invalid.
   241         /// \sa Invalid for more details.
   264         /// \sa Invalid for more details.
   242         OutArcIt(Invalid) { }
   265         OutArcIt(Invalid) { }
   299         /// Copy constructor.
   322         /// Copy constructor.
   300 
   323 
   301         /// Copy constructor.
   324         /// Copy constructor.
   302         ///
   325         ///
   303         InArcIt(const InArcIt& e) : Arc(e) { }
   326         InArcIt(const InArcIt& e) : Arc(e) { }
       
   327         /// Assignment operator
       
   328 
       
   329         /// Assignment operator.
       
   330         ///
       
   331         const InArcIt &operator=(const InArcIt&) { return *this; }
       
   332 
   304         /// %Invalid constructor \& conversion.
   333         /// %Invalid constructor \& conversion.
   305 
   334 
   306         /// Initializes the iterator to be invalid.
   335         /// Initializes the iterator to be invalid.
   307         /// \sa Invalid for more details.
   336         /// \sa Invalid for more details.
   308         InArcIt(Invalid) { }
   337         InArcIt(Invalid) { }
   363         /// Copy constructor.
   392         /// Copy constructor.
   364 
   393 
   365         /// Copy constructor.
   394         /// Copy constructor.
   366         ///
   395         ///
   367         ArcIt(const ArcIt& e) : Arc(e) { }
   396         ArcIt(const ArcIt& e) : Arc(e) { }
       
   397         /// Assignment operator
       
   398 
       
   399         /// Assignment operator.
       
   400         ///
       
   401         const ArcIt &operator=(const ArcIt&) { return *this; }
       
   402 
   368         /// %Invalid constructor \& conversion.
   403         /// %Invalid constructor \& conversion.
   369 
   404 
   370         /// Initializes the iterator to be invalid.
   405         /// Initializes the iterator to be invalid.
   371         /// \sa Invalid for more details.
   406         /// \sa Invalid for more details.
   372         ArcIt(Invalid) { }
   407         ArcIt(Invalid) { }
   519 
   554 
   520       private:
   555       private:
   521         ///Copy constructor
   556         ///Copy constructor
   522         NodeMap(const NodeMap& nm) :
   557         NodeMap(const NodeMap& nm) :
   523           ReferenceMap<Node, T, T&, const T&>(nm) { }
   558           ReferenceMap<Node, T, T&, const T&>(nm) { }
       
   559       public:
   524         ///Assignment operator
   560         ///Assignment operator
       
   561         NodeMap& operator=(const NodeMap&) {
       
   562           return *this;
       
   563         }
       
   564         ///Template Assignment operator
   525         template <typename CMap>
   565         template <typename CMap>
   526         NodeMap& operator=(const CMap&) {
   566         NodeMap& operator=(const CMap&) {
   527           checkConcept<ReadMap<Node, T>, CMap>();
   567           checkConcept<ReadMap<Node, T>, CMap>();
   528           return *this;
   568           return *this;
   529         }
   569         }
   545       private:
   585       private:
   546         ///Copy constructor
   586         ///Copy constructor
   547         ArcMap(const ArcMap& em) :
   587         ArcMap(const ArcMap& em) :
   548           ReferenceMap<Arc, T, T&, const T&>(em) { }
   588           ReferenceMap<Arc, T, T&, const T&>(em) { }
   549         ///Assignment operator
   589         ///Assignment operator
       
   590         ArcMap& operator=(const ArcMap&) {
       
   591           return *this;
       
   592         }
       
   593         ///Template Assignment operator
   550         template <typename CMap>
   594         template <typename CMap>
   551         ArcMap& operator=(const CMap&) {
   595         ArcMap& operator=(const CMap&) {
   552           checkConcept<ReadMap<Arc, T>, CMap>();
   596           checkConcept<ReadMap<Arc, T>, CMap>();
   553           return *this;
   597           return *this;
   554         }
   598         }