COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #137: be8a861d3bb7.patch

File be8a861d3bb7.patch, 7.9 KB (added by Peter Kovacs, 16 years ago)

  • lemon/bits/array_map.h 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1221510512 -7200
# Node ID be8a861d3bb7cac5c1ee56cbd8a9ceecef514292
# Parent  c691064dfd4f2e3d4e230a1fd9845a1d96de2a5d
Make copy constr and op= of the default maps private (ticket #137)

diff -r c691064dfd4f -r be8a861d3bb7 lemon/bits/array_map.h
    a b  
    103103      }
    104104    }
    105105
     106  private:
    106107    /// \brief Constructor to copy a map of the same map type.
    107108    ///
    108109    /// Constructor to copy a map of the same map type.
    … …  
    150151      return *this;
    151152    }
    152153
     154  public:
    153155    /// \brief The destructor of the map.
    154156    ///
    155157    /// The destructor of the map.

  • lemon/bits/graph_extender.h 

    diff -r c691064dfd4f -r be8a861d3bb7 lemon/bits/graph_extender.h
    a b  
    227227      NodeMap(const Digraph& digraph, const _Value& value)
    228228        : Parent(digraph, value) {}
    229229
     230    private:
    230231      NodeMap& operator=(const NodeMap& cmap) {
    231232        return operator=<NodeMap>(cmap);
    232233      }
    … …  
    251252      ArcMap(const Digraph& digraph, const _Value& value)
    252253        : Parent(digraph, value) {}
    253254
     255    private:
    254256      ArcMap& operator=(const ArcMap& cmap) {
    255257        return operator=<ArcMap>(cmap);
    256258      }
    … …  
    608610      NodeMap(const Graph& graph, const _Value& value)
    609611        : Parent(graph, value) {}
    610612
     613    private:
    611614      NodeMap& operator=(const NodeMap& cmap) {
    612615        return operator=<NodeMap>(cmap);
    613616      }
    … …  
    632635      ArcMap(const Graph& graph, const _Value& value)
    633636        : Parent(graph, value) {}
    634637
     638    private:
    635639      ArcMap& operator=(const ArcMap& cmap) {
    636640        return operator=<ArcMap>(cmap);
    637641      }
    … …  
    657661      EdgeMap(const Graph& graph, const _Value& value)
    658662        : Parent(graph, value) {}
    659663
     664    private:
    660665      EdgeMap& operator=(const EdgeMap& cmap) {
    661666        return operator=<EdgeMap>(cmap);
    662667      }

  • lemon/bits/map_extender.h 

    diff -r c691064dfd4f -r be8a861d3bb7 lemon/bits/map_extender.h
    a b  
    6262    MapExtender(const Graph& graph, const Value& value)
    6363      : Parent(graph, value) {}
    6464
     65  private:
    6566    MapExtender& operator=(const MapExtender& cmap) {
    6667      return operator=<MapExtender>(cmap);
    6768    }
    … …  
    7273      return *this;
    7374    }
    7475
     76  public:
    7577    class MapIt : public Item {
    7678    public:
    7779
    … …  
    200202    SubMapExtender(const Graph& _graph, const Value& _value)
    201203      : Parent(_graph, _value), graph(_graph) {}
    202204
     205  private:
    203206    SubMapExtender& operator=(const SubMapExtender& cmap) {
    204207      return operator=<MapExtender>(cmap);
    205208    }
    … …  
    214217      return *this;
    215218    }
    216219
     220  public:
    217221    class MapIt : public Item {
    218222    public:
    219223

  • lemon/bits/vector_map.h 

    diff -r c691064dfd4f -r be8a861d3bb7 lemon/bits/vector_map.h
    a b  
    100100      container.resize(Parent::notifier()->maxId() + 1, value);
    101101    }
    102102
     103  private:
    103104    /// \brief Copy constructor
    104105    ///
    105106    /// Copy constructor.

  • lemon/concepts/digraph.h 

    diff -r c691064dfd4f -r be8a861d3bb7 lemon/concepts/digraph.h
    a b  
    434434        ///\e
    435435        NodeMap(const Digraph&, T) { }
    436436
     437      private:
    437438        ///Copy constructor
    438439        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
    439440        ///Assignment operator
    … …  
    456457        ArcMap(const Digraph&) { }
    457458        ///\e
    458459        ArcMap(const Digraph&, T) { }
     460      private:
    459461        ///Copy constructor
    460462        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
    461463        ///Assignment operator

  • lemon/concepts/graph.h 

    diff -r c691064dfd4f -r be8a861d3bb7 lemon/concepts/graph.h
    a b  
    512512        ///\e
    513513        NodeMap(const Graph&, T) { }
    514514
     515      private:
    515516        ///Copy constructor
    516517        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
    517518        ///Assignment operator
    … …  
    535536        ArcMap(const Graph&) { }
    536537        ///\e
    537538        ArcMap(const Graph&, T) { }
     539      private:
    538540        ///Copy constructor
    539541        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
    540542        ///Assignment operator
    … …  
    558560        EdgeMap(const Graph&) { }
    559561        ///\e
    560562        EdgeMap(const Graph&, T) { }
     563      private:
    561564        ///Copy constructor
    562565        EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) {}
    563566        ///Assignment operator

  • lemon/concepts/graph_components.h 

    diff -r c691064dfd4f -r be8a861d3bb7 lemon/concepts/graph_components.h
    a b  
    10051005      ///
    10061006      /// Construct a new map for the graph and initalise the values.
    10071007      GraphMap(const Graph&, const Value&) {}
     1008
     1009    private:
    10081010      /// \brief Copy constructor.
    10091011      ///
    10101012      /// Copy Constructor.
    … …  
    10211023        return *this;
    10221024      }
    10231025
     1026    public:
    10241027      template<typename _Map>
    10251028      struct Constraints {
    10261029        void constraints() {
    … …  
    10301033          // Constructor with a graph and a default value parameter
    10311034          _Map a2(g,t);
    10321035          // Copy constructor.
    1033           _Map b(c);
     1036          // _Map b(c);
    10341037
    1035           ReadMap<Key, Value> cmap;
    1036           b = cmap;
     1038          // ReadMap<Key, Value> cmap;
     1039          // b = cmap;
    10371040
     1041          ignore_unused_variable_warning(a);
    10381042          ignore_unused_variable_warning(a2);
    1039           ignore_unused_variable_warning(b);
     1043          // ignore_unused_variable_warning(b);
    10401044        }
    10411045
    10421046        const _Map &c;
    … …  
    10821086        NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
    10831087          : Parent(digraph, value) {}
    10841088
     1089      private:
    10851090        /// \brief Copy constructor.
    10861091        ///
    10871092        /// Copy Constructor.
    … …  
    11191124        ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
    11201125          : Parent(digraph, value) {}
    11211126
     1127      private:
    11221128        /// \brief Copy constructor.
    11231129        ///
    11241130        /// Copy Constructor.
    … …  
    12151221        EdgeMap(const MappableGraphComponent& graph, const _Value& value)
    12161222          : Parent(graph, value) {}
    12171223
     1224      private:
    12181225        /// \brief Copy constructor.
    12191226        ///
    12201227        /// Copy Constructor.

  • test/graph_test.h 

    diff -r c691064dfd4f -r be8a861d3bb7 test/graph_test.h
    a b  
    212212    }
    213213    check(s == 0, "Wrong sum.");
    214214
    215     map = constMap<Node>(12);
    216     for (NodeIt it(G); it != INVALID; ++it) {
    217       check(map[it] == 12, "Wrong operator[].");
    218     }
     215    // map = constMap<Node>(12);
     216    // for (NodeIt it(G); it != INVALID; ++it) {
     217    //   check(map[it] == 12, "Wrong operator[].");
     218    // }
    219219  }
    220220
    221221  template <typename Graph>
    … …  
    242242    }
    243243    check(s == 0, "Wrong sum.");
    244244
    245     map = constMap<Arc>(12);
    246     for (ArcIt it(G); it != INVALID; ++it) {
    247       check(map[it] == 12, "Wrong operator[].");
    248     }
     245    // map = constMap<Arc>(12);
     246    // for (ArcIt it(G); it != INVALID; ++it) {
     247    //   check(map[it] == 12, "Wrong operator[].");
     248    // }
    249249  }
    250250
    251251  template <typename Graph>
    … …  
    272272    }
    273273    check(s == 0, "Wrong sum.");
    274274
    275     map = constMap<Edge>(12);
    276     for (EdgeIt it(G); it != INVALID; ++it) {
    277       check(map[it] == 12, "Wrong operator[].");
    278     }
     275    // map = constMap<Edge>(12);
     276    // for (EdgeIt it(G); it != INVALID; ++it) {
     277    //   check(map[it] == 12, "Wrong operator[].");
     278    // }
    279279  }
    280280
    281281