COIN-OR::LEMON - Graph Library

Changeset 786:d7b3b13b9df6 in lemon-0.x


Ignore:
Timestamp:
09/02/04 17:21:13 (15 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1079
Message:

Change 'Key' to 'KeyType?' (possibly temporarily).

Location:
src/hugo
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/hugo/array_map_factory.h

    r785 r786  
    2323               
    2424    typedef typename MapRegistry::Graph Graph;
    25     typedef typename MapRegistry::Key Key;
     25    typedef typename MapRegistry::KeyType KeyType;
    2626    typedef typename MapRegistry::KeyIt KeyIt;
    2727
     
    114114       
    115115       
    116       Value& operator[](const Key& key) {
     116      Value& operator[](const KeyType& key) {
    117117        int id = MapBase::getGraph()->id(key);
    118118        return values[id];
    119119      }
    120120               
    121       const Value& operator[](const Key& key) const {
     121      const Value& operator[](const KeyType& key) const {
    122122        int id = MapBase::getGraph()->id(key);
    123123        return values[id];
    124124      }
    125125       
    126       const Value& get(const Key& key) const {
     126      const Value& get(const KeyType& key) const {
    127127        int id = MapBase::getGraph()->id(key);
    128128        return values[id];
    129129      }
    130130               
    131       void set(const Key& key, const Value& val) {
     131      void set(const KeyType& key, const Value& val) {
    132132        int id = MapBase::getGraph()->id(key);
    133133        values[id] = val;
    134134      }
    135135               
    136       void add(const Key& key) {
     136      void add(const KeyType& key) {
    137137        int id = MapBase::getGraph()->id(key);
    138138        if (id >= capacity) {
     
    156156      }
    157157               
    158       void erase(const Key& key) {
     158      void erase(const KeyType& key) {
    159159        int id = MapBase::getGraph()->id(key);
    160160        allocator.destroy(&(values[id]));
     
    185185        iterator() {}
    186186
    187         typedef extended_pair<const Key&, const Key&,
     187        typedef extended_pair<const KeyType&, const KeyType&,
    188188                              Value&, Value&> Reference;
    189189
     
    198198        private:
    199199          Reference data;
    200           Pointer(const Key& key, Value& val) : data(key, val) {}
     200          Pointer(const KeyType& key, Value& val) : data(key, val) {}
    201201        public:
    202202          Reference* operator->() {return &data;}
     
    275275        const_iterator(iterator p_it) : map(p_it.map), it(p_it.it) {}
    276276     
    277         typedef extended_pair<const Key&, const Key&,
     277        typedef extended_pair<const KeyType&, const KeyType&,
    278278          const Value&, const Value&> Reference;
    279279
     
    289289        private:
    290290          Reference data;
    291           Pointer(const Key& key, const Value& val) : data(key, val) {}
     291          Pointer(const KeyType& key, const Value& val) : data(key, val) {}
    292292        public:
    293293          Reference* operator->() {return &data;}
  • src/hugo/map_registry.h

    r785 r786  
    2626  public:
    2727    typedef G Graph;
    28     typedef K Key;
     28    typedef K KeyType;
    2929    typedef KIt KeyIt;
    3030       
     
    3939    public:
    4040      typedef G Graph;
    41       typedef K Key;
     41      typedef K KeyType;
    4242      typedef KIt KeyIt;
    4343
     
    136136      */
    137137       
    138       virtual void add(const Key&) = 0;
     138      virtual void add(const KeyType&) = 0;     
    139139      /**
    140140          The erase member function should be overloaded in the subclasses.
     
    142142      */
    143143       
    144       virtual void erase(const Key&) = 0;
     144      virtual void erase(const KeyType&) = 0;
    145145
    146146      /**
     
    241241     * Notify all the registered maps about a Key added.
    242242     */
    243     void add(Key& key) {
     243    void add(KeyType& key) {
    244244      typename Container::iterator it;
    245245      for (it = container.begin(); it != container.end(); ++it) {
     
    251251     * Notify all the registered maps about a Key erased.
    252252     */
    253     void erase(Key& key) {
     253    void erase(KeyType& key) {
    254254      typename Container::iterator it;
    255255      for (it = container.begin(); it != container.end(); ++it) {
  • src/hugo/sym_map_factory.h

    r782 r786  
    3636               
    3737    typedef typename MapRegistry::Graph Graph;
    38     typedef typename MapRegistry::Key Key;
     38    typedef typename MapRegistry::KeyType KeyType;
    3939    typedef typename MapRegistry::KeyIt KeyIt;
    4040
     
    6969      }
    7070   
    71       Value& operator[](const Key& key) {
     71      Value& operator[](const KeyType& key) {
    7272        int id = MapBase::getGraph()->id(key); 
    7373        return MapImpl::operator[](id >> 1);
    7474      }
    7575               
    76       const Value& operator[](const Key& key) const {
     76      const Value& operator[](const KeyType& key) const {
    7777        int id = MapBase::getGraph()->id(key);
    7878        return MapImpl::operator[](id >> 1);
    7979      }
    8080       
    81       const Value& get(const Key& key) const {
     81      const Value& get(const KeyType& key) const {
    8282        int id = MapBase::getGraph()->id(key);
    8383        return MapImpl::operator[](id >> 1);
    8484      }
    8585               
    86       void set(const Key& key, const Value& val) {
     86      void set(const KeyType& key, const Value& val) {
    8787        int id = MapBase::getGraph()->id(key);
    8888        MapImpl::operator[](id >> 1) = val;
    8989      }
    9090               
    91       void add(const Key& key) {
     91      void add(const KeyType& key) {
    9292        int id = MapBase::getGraph()->id(key);
    9393        if (id & 1) return;
     
    9595      }
    9696               
    97       void erase(const Key& key) {
     97      void erase(const KeyType& key) {
    9898        int id = MapBase::getGraph()->id(key);
    9999        if (id & 1) return;
  • src/hugo/vector_map_factory.h

    r785 r786  
    3131    typedef typename MapRegistry::Graph Graph;
    3232    /// The key type of the maps.
    33     typedef typename MapRegistry::Key Key;
     33    typedef typename MapRegistry::KeyType KeyType;
    3434    /// The iterator to iterate on the keys.
    3535    typedef typename MapRegistry::KeyIt KeyIt;
     
    113113       * actual keys of the graph.
    114114       */
    115       typename Container::reference operator[](const Key& key) {
     115      typename Container::reference operator[](const KeyType& key) {
    116116        int id = getGraph()->id(key);
    117117        return container[id];
     
    122122       * actual keys of the graph.
    123123       */
    124       typename Container::const_reference operator[](const Key& key) const {
     124      typename Container::const_reference operator[](const KeyType& key) const {
    125125        int id = getGraph()->id(key);
    126126        return container[id];
     
    130130       *  This is a compatibility feature with the not dereferable maps.
    131131       */
    132       void set(const Key& key, const Value& val) {
     132      void set(const KeyType& key, const Value& val) {
    133133        int id = getGraph()->id(key);
    134134        container[id] = val;
     
    137137      /** Add a new key to the map. It called by the map registry.
    138138       */
    139       void add(const Key& key) {
     139      void add(const KeyType& key) {
    140140        int id = getGraph()->id(key);
    141141        if (id >= container.size()) {
     
    146146      /** Erase a key from the map. It called by the map registry.
    147147       */
    148       void erase(const Key& key) {}
     148      void erase(const KeyType& key) {}
    149149
    150150      /** Clear the data structure.
     
    173173        iterator() {}
    174174
    175         typedef extended_pair<const Key&, const Key&,
     175        typedef extended_pair<const KeyType&, const KeyType&,
    176176                              Value&, Value&> Reference;
    177177
     
    186186        private:
    187187          Reference data;
    188           Pointer(const Key& key, Value& val) : data(key, val) {}
     188          Pointer(const KeyType& key, Value& val) : data(key, val) {}
    189189        public:
    190190          Reference* operator->() {return &data;}
     
    263263        const_iterator(iterator p_it) : map(p_it.map), it(p_it.it) {}
    264264     
    265         typedef extended_pair<const Key&, const Key&,
     265        typedef extended_pair<const KeyType&, const KeyType&,
    266266          const Value&, const Value&> Reference;
    267267
     
    277277        private:
    278278          Reference data;
    279           Pointer(const Key& key, const Value& val) : data(key, val) {}
     279          Pointer(const KeyType& key, const Value& val) : data(key, val) {}
    280280        public:
    281281          Reference* operator->() {return &data;}
Note: See TracChangeset for help on using the changeset viewer.