COIN-OR::LEMON - Graph Library

Changeset 1210:da87dbdf3daf in lemon-main


Ignore:
Timestamp:
07/28/20 21:23:36 (12 months ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Phase:
public
Message:

Resolve deprecation warnings of gcc 9 (#633)

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • lemon/concepts/bpgraph.h

    r1130 r1210  
    9696        ///
    9797        Node(const Node&) { }
     98        /// Assignment operator
     99
     100        /// Assignment operator.
     101        ///
     102        const Node &operator=(const Node&) { return *this; }
    98103
    99104        /// %Invalid constructor \& conversion.
     
    144149        ///
    145150        RedNode(const RedNode&) : Node() { }
     151        /// Assignment operator
     152
     153        /// Assignment operator.
     154        ///
     155        const RedNode &operator=(const RedNode&) { return *this; }
    146156
    147157        /// %Invalid constructor \& conversion.
     
    171181        ///
    172182        BlueNode(const BlueNode&) : Node() { }
     183        /// Assignment operator
     184
     185        /// Assignment operator.
     186        ///
     187        const BlueNode &operator=(const BlueNode&) { return *this; }
     188
    173189
    174190        /// %Invalid constructor \& conversion.
     
    201217        ///
    202218        RedNodeIt(const RedNodeIt& n) : RedNode(n) { }
     219        /// Assignment operator
     220
     221        /// Assignment operator.
     222        ///
     223        const RedNodeIt &operator=(const RedNodeIt&) { return *this; }
    203224        /// %Invalid constructor \& conversion.
    204225
     
    260281        ///
    261282        BlueNodeIt(const BlueNodeIt& n) : BlueNode(n) { }
     283        /// Assignment operator
     284
     285        /// Assignment operator.
     286        ///
     287        const BlueNodeIt &operator=(const BlueNodeIt&) { return *this; }
    262288        /// %Invalid constructor \& conversion.
    263289
     
    319345        ///
    320346        NodeIt(const NodeIt& n) : Node(n) { }
     347        /// Assignment operator
     348
     349        /// Assignment operator.
     350        ///
     351        const NodeIt &operator=(const NodeIt&) { return *this; }
    321352        /// %Invalid constructor \& conversion.
    322353
     
    375406        ///
    376407        Edge(const Edge&) { }
     408        /// Assignment operator
     409
     410        /// Assignment operator.
     411        ///
     412        const Edge &operator=(const Edge&) { return *this; }
    377413        /// %Invalid constructor \& conversion.
    378414
     
    423459        ///
    424460        EdgeIt(const EdgeIt& e) : Edge(e) { }
     461        /// Assignment operator
     462
     463        /// Assignment operator.
     464        ///
     465        const EdgeIt &operator=(const EdgeIt&) { return *this; }
    425466        /// %Invalid constructor \& conversion.
    426467
     
    488529        ///
    489530        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
     531        /// Assignment operator
     532
     533        /// Assignment operator.
     534        ///
     535        const IncEdgeIt &operator=(const IncEdgeIt&) { return *this; }
    490536        /// %Invalid constructor \& conversion.
    491537
     
    546592        ///
    547593        Arc(const Arc&) { }
     594        /// Assignment operator
     595
     596        /// Assignment operator.
     597        ///
     598        const Arc &operator=(const Arc&) { return *this; }
    548599        /// %Invalid constructor \& conversion.
    549600
     
    600651        ///
    601652        ArcIt(const ArcIt& e) : Arc(e) { }
     653        /// Assignment operator
     654
     655        /// Assignment operator.
     656        ///
     657        const ArcIt &operator=(const ArcIt&) { return *this; }
    602658        /// %Invalid constructor \& conversion.
    603659
     
    665721        ///
    666722        OutArcIt(const OutArcIt& e) : Arc(e) { }
     723        /// Assignment operator
     724
     725        /// Assignment operator.
     726        ///
     727        const OutArcIt &operator=(const OutArcIt&) { return *this; }
    667728        /// %Invalid constructor \& conversion.
    668729
     
    731792        ///
    732793        InArcIt(const InArcIt& e) : Arc(e) { }
     794        /// Assignment operator
     795
     796        /// Assignment operator.
     797        ///
     798        const InArcIt &operator=(const InArcIt&) { return *this; }
    733799        /// %Invalid constructor \& conversion.
    734800
  • lemon/concepts/digraph.h

    r1130 r1210  
    7878        Node(const Node&) { }
    7979
     80        /// Assignment operator
     81
     82        /// Assignment operator.
     83        ///
     84        const Node &operator=(const Node&) { return *this; }
     85
    8086        /// %Invalid constructor \& conversion.
    8187
     
    127133        ///
    128134        NodeIt(const NodeIt& n) : Node(n) { }
     135        /// Assignment operator
     136
     137        /// Assignment operator.
     138        ///
     139        const NodeIt &operator=(const NodeIt&) { return *this; }
     140
    129141        /// %Invalid constructor \& conversion.
    130142
     
    186198        ///
    187199        Arc(const Arc&) { }
     200        /// Assignment operator
     201
     202        /// Assignment operator.
     203        ///
     204        const Arc &operator=(const Arc&) { return *this; }
     205
    188206        /// %Invalid constructor \& conversion.
    189207
     
    236254        ///
    237255        OutArcIt(const OutArcIt& e) : Arc(e) { }
     256        /// Assignment operator
     257
     258        /// Assignment operator.
     259        ///
     260        const OutArcIt &operator=(const OutArcIt&) { return *this; }
    238261        /// %Invalid constructor \& conversion.
    239262
     
    302325        ///
    303326        InArcIt(const InArcIt& e) : Arc(e) { }
     327        /// Assignment operator
     328
     329        /// Assignment operator.
     330        ///
     331        const InArcIt &operator=(const InArcIt&) { return *this; }
     332
    304333        /// %Invalid constructor \& conversion.
    305334
     
    366395        ///
    367396        ArcIt(const ArcIt& e) : Arc(e) { }
     397        /// Assignment operator
     398
     399        /// Assignment operator.
     400        ///
     401        const ArcIt &operator=(const ArcIt&) { return *this; }
     402
    368403        /// %Invalid constructor \& conversion.
    369404
     
    522557        NodeMap(const NodeMap& nm) :
    523558          ReferenceMap<Node, T, T&, const T&>(nm) { }
     559      public:
    524560        ///Assignment operator
     561        NodeMap& operator=(const NodeMap&) {
     562          return *this;
     563        }
     564        ///Template Assignment operator
    525565        template <typename CMap>
    526566        NodeMap& operator=(const CMap&) {
     
    548588          ReferenceMap<Arc, T, T&, const T&>(em) { }
    549589        ///Assignment operator
     590        ArcMap& operator=(const ArcMap&) {
     591          return *this;
     592        }
     593        ///Template Assignment operator
    550594        template <typename CMap>
    551595        ArcMap& operator=(const CMap&) {
  • lemon/concepts/graph.h

    r1130 r1210  
    109109        ///
    110110        Node(const Node&) { }
     111        /// Assignment operator
     112
     113        /// Assignment operator.
     114        ///
     115        const Node &operator=(const Node&) { return *this; }
    111116
    112117        /// %Invalid constructor \& conversion.
     
    160165        ///
    161166        NodeIt(const NodeIt& n) : Node(n) { }
     167        /// Assignment operator
     168
     169        /// Assignment operator.
     170        ///
     171        const NodeIt &operator=(const NodeIt&) { return *this; }
     172
    162173        /// %Invalid constructor \& conversion.
    163174
     
    219230        ///
    220231        Edge(const Edge&) { }
     232        /// Assignment operator
     233
     234        /// Assignment operator.
     235        ///
     236        const Edge &operator=(const Edge&) { return *this; }
     237
    221238        /// %Invalid constructor \& conversion.
    222239
     
    267284        ///
    268285        EdgeIt(const EdgeIt& e) : Edge(e) { }
     286        /// Assignment operator
     287
     288        /// Assignment operator.
     289        ///
     290        const EdgeIt &operator=(const EdgeIt&) { return *this; }
     291
    269292        /// %Invalid constructor \& conversion.
    270293
     
    336359        ///
    337360        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
     361        /// Assignment operator
     362
     363        /// Assignment operator.
     364        ///
     365        const IncEdgeIt &operator=(const IncEdgeIt&) { return *this; }
     366
    338367        /// %Invalid constructor \& conversion.
    339368
     
    397426        ///
    398427        Arc(const Arc&) { }
     428        /// Assignment operator
     429
     430        /// Assignment operator.
     431        ///
     432        const Arc &operator=(const Arc&) { return *this; }
     433
    399434        /// %Invalid constructor \& conversion.
    400435
     
    451486        ///
    452487        ArcIt(const ArcIt& e) : Arc(e) { }
     488        /// Assignment operator
     489
     490        /// Assignment operator.
     491        ///
     492        const ArcIt &operator=(const ArcIt&) { return *this; }
     493
    453494        /// %Invalid constructor \& conversion.
    454495
     
    519560        ///
    520561        OutArcIt(const OutArcIt& e) : Arc(e) { }
     562        /// Assignment operator
     563
     564        /// Assignment operator.
     565        ///
     566        const OutArcIt &operator=(const OutArcIt&) { return *this; }
     567
    521568        /// %Invalid constructor \& conversion.
    522569
     
    588635        ///
    589636        InArcIt(const InArcIt& e) : Arc(e) { }
     637        /// Assignment operator
     638
     639        /// Assignment operator.
     640        ///
     641        const InArcIt &operator=(const InArcIt&) { return *this; }
     642
    590643        /// %Invalid constructor \& conversion.
    591644
     
    652705          ReferenceMap<Node, T, T&, const T&>(nm) { }
    653706        ///Assignment operator
     707        NodeMap& operator=(const NodeMap&) {
     708          return *this;
     709        }
     710        ///Template Assignment operator
    654711        template <typename CMap>
    655712        NodeMap& operator=(const CMap&) {
     
    678735          ReferenceMap<Arc, T, T&, const T&>(em) { }
    679736        ///Assignment operator
     737        ArcMap& operator=(const ArcMap&) {
     738          return *this;
     739        }
     740        ///Template Assignment operator
    680741        template <typename CMap>
    681742        ArcMap& operator=(const CMap&) {
     
    704765          ReferenceMap<Edge, T, T&, const T&>(em) {}
    705766        ///Assignment operator
     767        EdgeMap& operator=(const EdgeMap&) {
     768          return *this;
     769        }
     770        ///Template Assignment operator
    706771        template <typename CMap>
    707772        EdgeMap& operator=(const CMap&) {
  • lemon/concepts/graph_components.h

    r1197 r1210  
    220220        Edge(const Edge &) : Parent() {}
    221221
     222        /// Assignment operator
     223
     224        /// Assignment operator.
     225        ///
     226        const Edge &operator=(const Edge&) { return *this; }
     227
    222228        /// \brief Constructor for conversion from \c INVALID.
    223229        ///
     
    337343        /// Copy constructor.
    338344        RedNode(const RedNode &) : Parent() {}
     345        /// Assignment operator
     346
     347        /// Assignment operator.
     348        ///
     349        const RedNode &operator=(const RedNode&) { return *this; }
    339350
    340351        /// \brief Constructor for conversion from \c INVALID.
     
    366377        /// Copy constructor.
    367378        BlueNode(const BlueNode &) : Parent() {}
     379        /// Assignment operator
     380
     381        /// Assignment operator.
     382        ///
     383        const BlueNode &operator=(const BlueNode&) { return *this; }
     384
    368385
    369386        /// \brief Constructor for conversion from \c INVALID.
  • lemon/dim2.h

    r1112 r1210  
    5555
    5656      ///Default constructor
    57       Point() {}
     57      Point() : x(), y() {}
    5858
    5959      ///Construct an instance from coordinates
  • lemon/list_graph.h

    r1149 r1210  
    16581658      RedNode(const RedNode& node) : Node(node) {}
    16591659      RedNode(Invalid) : Node(INVALID){}
     1660      const RedNode& operator=(const RedNode& node) { Node::operator=(node); return *this;}
    16601661    };
    16611662
     
    16701671      BlueNode(const BlueNode& node) : Node(node) {}
    16711672      BlueNode(Invalid) : Node(INVALID){}
     1673      const BlueNode& operator=(const BlueNode& node) { Node::operator=(node); return *this;}
    16721674    };
    16731675
  • lemon/maps.h

    r1130 r1210  
    295295  private:
    296296
    297     RangeMap& operator=(const RangeMap&);
    298 
    299   public:
     297    // RangeMap& operator=(const RangeMap&);
     298
     299  public:
     300
     301    // ///\e
     302    // RangeMap(const RangeMap&);
    300303
    301304    ///\e
  • lemon/smart_graph.h

    r1130 r1210  
    864864      RedNode() {}
    865865      RedNode(const RedNode& node) : Node(node) {}
    866       RedNode(Invalid) : Node(INVALID){}
     866      RedNode(Invalid) : Node(INVALID) {}
     867      const RedNode& operator=(const RedNode& node) { Node::operator=(node); return *this;}
    867868    };
    868869
     
    877878      BlueNode(const BlueNode& node) : Node(node) {}
    878879      BlueNode(Invalid) : Node(INVALID){}
     880      const BlueNode& operator=(const BlueNode& node) { Node::operator=(node); return *this;}
    879881    };
    880882
  • test/maps_test.cc

    r1131 r1210  
    6262  typedef B result_type;
    6363
     64  F() {};
     65  F(const F&) {};
     66
    6467  B operator()(const A&) const { return B(); }
    6568private:
Note: See TracChangeset for help on using the changeset viewer.