COIN-OR::LEMON - Graph Library

Ticket #633: fix-gcc9.patch

File fix-gcc9.patch, 13.7 KB (added by Alpar Juttner, 3 years ago)
  • lemon/concepts/bpgraph.h

    # HG changeset patch
    # Parent  4790f64d6f51834e7bee1670bf4861ff483e9076
    Resolve deprecation warnings of gcc 9
    
    diff --git a/lemon/concepts/bpgraph.h b/lemon/concepts/bpgraph.h
    a b  
    9595        /// Copy constructor.
    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.
    100105
     
    143148        /// Copy constructor.
    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.
    148158
     
    170180        /// Copy constructor.
    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.
    175191
     
    200216        /// Copy constructor.
    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
    205226        /// Initializes the iterator to be invalid.
     
    259280        /// Copy constructor.
    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
    264290        /// Initializes the iterator to be invalid.
     
    318344        /// Copy constructor.
    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
    323354        /// Initializes the iterator to be invalid.
     
    374405        /// Copy constructor.
    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
    379415        /// Initializes the object to be invalid.
     
    422458        /// Copy constructor.
    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
    427468        /// Initializes the iterator to be invalid.
     
    487528        /// Copy constructor.
    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
    492538        /// Initializes the iterator to be invalid.
     
    545591        /// Copy constructor.
    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
    550601        /// Initializes the object to be invalid.
     
    599650        /// Copy constructor.
    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
    604660        /// Initializes the iterator to be invalid.
     
    664720        /// Copy constructor.
    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
    669730        /// Initializes the iterator to be invalid.
     
    730791        /// Copy constructor.
    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
    735801        /// Initializes the iterator to be invalid.
  • lemon/concepts/digraph.h

    diff --git a/lemon/concepts/digraph.h b/lemon/concepts/digraph.h
    a b  
    7777        ///
    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
    8288        /// Initializes the object to be invalid.
     
    126132        /// Copy constructor.
    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
    131143        /// Initializes the iterator to be invalid.
     
    185197        /// Copy constructor.
    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
    190208        /// Initializes the object to be invalid.
     
    235253        /// Copy constructor.
    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
    240263        /// Initializes the iterator to be invalid.
     
    301324        /// Copy constructor.
    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
    306335        /// Initializes the iterator to be invalid.
     
    365394        /// Copy constructor.
    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
    370405        /// Initializes the iterator to be invalid.
     
    521556        ///Copy constructor
    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&) {
    527567          checkConcept<ReadMap<Node, T>, CMap>();
  • lemon/concepts/graph.h

    diff --git a/lemon/concepts/graph.h b/lemon/concepts/graph.h
    a b  
    108108        /// Copy constructor.
    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.
    113118
     
    159164        /// Copy constructor.
    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
    164175        /// Initializes the iterator to be invalid.
     
    218229        /// Copy constructor.
    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
    223240        /// Initializes the object to be invalid.
     
    266283        /// Copy constructor.
    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
    271294        /// Initializes the iterator to be invalid.
     
    335358        /// Copy constructor.
    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
    340369        /// Initializes the iterator to be invalid.
     
    396425        /// Copy constructor.
    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
    401436        /// Initializes the object to be invalid.
     
    450485        /// Copy constructor.
    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
    455496        /// Initializes the iterator to be invalid.
     
    518559        /// Copy constructor.
    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
    523570        /// Initializes the iterator to be invalid.
     
    587634        /// Copy constructor.
    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
    592645        /// Initializes the iterator to be invalid.
  • lemon/concepts/graph_components.h

    diff --git a/lemon/concepts/graph_components.h b/lemon/concepts/graph_components.h
    a b  
    219219        /// Copy constructor.
    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        ///
    224230        /// Constructor for conversion from \c INVALID.
     
    336342        ///
    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.
    341352        ///
     
    365376        ///
    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.
    370387        ///
  • lemon/list_graph.h

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    16571657      RedNode() {}
    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
    16621663    class BlueNode : public Node {
     
    16691670      BlueNode() {}
    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
    16741676    class Edge {
  • lemon/maps.h

    diff --git a/lemon/maps.h b/lemon/maps.h
    a b  
    294294
    295295  private:
    296296
    297     RangeMap& operator=(const RangeMap&);
     297    // RangeMap& operator=(const RangeMap&);
    298298
    299299  public:
    300300
     301    // ///\e
     302    // RangeMap(const RangeMap&);
     303
    301304    ///\e
    302305    Reference operator[](const Key &k) {
    303306      return _vector[k];
  • lemon/smart_graph.h

    diff --git a/lemon/smart_graph.h b/lemon/smart_graph.h
    a b  
    863863    public:
    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
    869870    class BlueNode : public Node {
     
    876877      BlueNode() {}
    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
    881883    class Edge {
  • test/maps_test.cc

    diff --git a/test/maps_test.cc b/test/maps_test.cc
    a b  
    6161  typedef A argument_type;
    6262  typedef B result_type;
    6363
     64  F() {};
     65  F(const F&) {};
     66
    6467  B operator()(const A&) const { return B(); }
    6568private:
    6669  F& operator=(const F&);