COIN-OR::LEMON - Graph Library

Ticket #631: 93c983122692.patch

File 93c983122692.patch, 8.4 KB (added by Alpar Juttner, 10 months ago)
  • lemon/bits/array_map.h

    # HG changeset patch
    # User David Torres Sanchez <d.torressanchez@lancaster.ac.uk>
    # Date 1637826358 -3600
    #      Thu Nov 25 08:45:58 2021 +0100
    # Node ID 93c983122692826b48d3a40bc40100c8a4ea7650
    # Parent  a278d16bd2d082aa3c52ff4a9b0e2224ddc0549a
    Fix C++20 compatibility issue (#631)
    
    diff --git a/lemon/bits/array_map.h b/lemon/bits/array_map.h
    a b  
    7575    typedef typename Notifier::ObserverBase Parent;
    7676
    7777    typedef std::allocator<Value> Allocator;
     78    typedef std::allocator_traits<std::allocator<Value>> AllocatorTraits;
    7879
    7980  public:
    8081
     
    8788      Notifier* nf = Parent::notifier();
    8889      Item it;
    8990      for (nf->first(it); it != INVALID; nf->next(it)) {
    90         int id = nf->id(it);;
    91         allocator.construct(&(values[id]), Value());
     91        int id = nf->id(it);
     92        AllocatorTraits::construct(allocator, &(values[id]), Value());
    9293      }
    9394    }
    9495
     
    101102      Notifier* nf = Parent::notifier();
    102103      Item it;
    103104      for (nf->first(it); it != INVALID; nf->next(it)) {
    104         int id = nf->id(it);;
    105         allocator.construct(&(values[id]), value);
     105        int id = nf->id(it);
     106        AllocatorTraits::construct(allocator, &(values[id]), value);
    106107      }
    107108    }
    108109
     
    120121      Notifier* nf = Parent::notifier();
    121122      Item it;
    122123      for (nf->first(it); it != INVALID; nf->next(it)) {
    123         int id = nf->id(it);;
    124         allocator.construct(&(values[id]), copy.values[id]);
     124        int id = nf->id(it);
     125        AllocatorTraits::construct(allocator, &(values[id]), copy.values[id]);
    125126      }
    126127    }
    127128
     
    216217        Value* new_values = allocator.allocate(new_capacity);
    217218        Item it;
    218219        for (nf->first(it); it != INVALID; nf->next(it)) {
    219           int jd = nf->id(it);;
     220          int jd = nf->id(it);
    220221          if (id != jd) {
    221             allocator.construct(&(new_values[jd]), values[jd]);
    222             allocator.destroy(&(values[jd]));
     222            AllocatorTraits::construct(allocator, &(new_values[jd]), values[jd]);
     223            AllocatorTraits::destroy(allocator, &(values[jd]));
    223224          }
    224225        }
    225226        if (capacity != 0) allocator.deallocate(values, capacity);
    226227        values = new_values;
    227228        capacity = new_capacity;
    228229      }
    229       allocator.construct(&(values[id]), Value());
     230      AllocatorTraits::construct(allocator, &(values[id]), Value());
    230231    }
    231232
    232233    // \brief Adds more new keys to the map.
     
    260261            }
    261262          }
    262263          if (found) continue;
    263           allocator.construct(&(new_values[id]), values[id]);
    264           allocator.destroy(&(values[id]));
     264          AllocatorTraits::construct(allocator, &(new_values[id]), values[id]);
     265          AllocatorTraits::destroy(allocator, &(values[id]));
    265266        }
    266267        if (capacity != 0) allocator.deallocate(values, capacity);
    267268        values = new_values;
     
    269270      }
    270271      for (int i = 0; i < int(keys.size()); ++i) {
    271272        int id = nf->id(keys[i]);
    272         allocator.construct(&(values[id]), Value());
     273        AllocatorTraits::construct(allocator, &(values[id]), Value());
    273274      }
    274275    }
    275276
     
    279280    // and it overrides the erase() member function of the observer base.
    280281    virtual void erase(const Key& key) {
    281282      int id = Parent::notifier()->id(key);
    282       allocator.destroy(&(values[id]));
     283      AllocatorTraits::destroy(allocator, &(values[id]));
    283284    }
    284285
    285286    // \brief Erase more keys from the map.
     
    289290    virtual void erase(const std::vector<Key>& keys) {
    290291      for (int i = 0; i < int(keys.size()); ++i) {
    291292        int id = Parent::notifier()->id(keys[i]);
    292         allocator.destroy(&(values[id]));
     293        AllocatorTraits::destroy(allocator, &(values[id]));
    293294      }
    294295    }
    295296
     
    302303      allocate_memory();
    303304      Item it;
    304305      for (nf->first(it); it != INVALID; nf->next(it)) {
    305         int id = nf->id(it);;
    306         allocator.construct(&(values[id]), Value());
     306        int id = nf->id(it);
     307        AllocatorTraits::construct(allocator, &(values[id]), Value());
    307308      }
    308309    }
    309310
     
    317318        Item it;
    318319        for (nf->first(it); it != INVALID; nf->next(it)) {
    319320          int id = nf->id(it);
    320           allocator.destroy(&(values[id]));
     321          AllocatorTraits::destroy(allocator, &(values[id]));
    321322        }
    322323        allocator.deallocate(values, capacity);
    323324        capacity = 0;
  • lemon/path.h

    diff --git a/lemon/path.h b/lemon/path.h
    a b  
    448448      data.resize(len);
    449449      int index = 0;
    450450      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
    451         data[index] = it;;
     451        data[index] = it;
    452452        ++index;
    453453      }
    454454    }
     
    460460      int index = len;
    461461      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
    462462        --index;
    463         data[index] = it;;
     463        data[index] = it;
    464464      }
    465465    }
    466466
     
    503503
    504504    Node *first, *last;
    505505
    506     std::allocator<Node> alloc;
     506  private:
     507    typedef std::allocator<Node> Allocator;
     508    typedef std::allocator_traits<std::allocator<Node>> AllocatorTraits;
    507509
    508510  public:
    509511
     
    663665    void clear() {
    664666      while (first != 0) {
    665667        last = first->next;
    666         alloc.destroy(first);
    667         alloc.deallocate(first, 1);
     668        AllocatorTraits::destroy(_allocator, first);
     669        _allocator.deallocate(first, 1);
    668670        first = last;
    669671      }
    670672    }
     
    676678
    677679    /// \brief Add a new arc before the current path
    678680    void addFront(const Arc& arc) {
    679       Node *node = alloc.allocate(1);
    680       alloc.construct(node, Node());
     681      Node *node = _allocator.allocate(1);
     682      AllocatorTraits::construct(_allocator, node, Node());
    681683      node->prev = 0;
    682684      node->next = first;
    683685      node->arc = arc;
     
    698700      } else {
    699701        last = 0;
    700702      }
    701       alloc.destroy(node);
    702       alloc.deallocate(node, 1);
     703      AllocatorTraits::destroy(_allocator, node);
     704      _allocator.deallocate(node, 1);
    703705    }
    704706
    705707    /// \brief The last arc of the path.
     
    709711
    710712    /// \brief Add a new arc behind the current path.
    711713    void addBack(const Arc& arc) {
    712       Node *node = alloc.allocate(1);
    713       alloc.construct(node, Node());
     714      Node *node = _allocator.allocate(1);
     715      AllocatorTraits::construct(_allocator, node, Node());
    714716      node->next = 0;
    715717      node->prev = last;
    716718      node->arc = arc;
     
    731733      } else {
    732734        first = 0;
    733735      }
    734       alloc.destroy(node);
    735       alloc.deallocate(node, 1);
     736      AllocatorTraits::destroy(_allocator, node);
     737      _allocator.deallocate(node, 1);
    736738    }
    737739
    738740    /// \brief Splice a path to the back of the current path.
     
    847849      }
    848850    }
    849851
     852  private:
     853    Allocator _allocator;
     854
    850855  };
    851856
    852857  /// \brief A structure for representing directed paths in a digraph.
     
    875880    /// \brief Default constructor
    876881    ///
    877882    /// Default constructor
    878     StaticPath() : len(0), _arcs(0) {}
     883    StaticPath() : _len(0), _arcs(0) {}
    879884
    880885    /// \brief Copy constructor
    881886    ///
     
    10031008    }
    10041009
    10051010    /// \brief The length of the path.
    1006     int length() const { return len; }
     1011    int length() const { return _len; }
    10071012
    10081013    /// \brief Return true when the path is empty.
    1009     int empty() const { return len == 0; }
     1014    int empty() const { return _len == 0; }
    10101015
    10111016    /// \brief Reset the path to an empty one.
    10121017    void clear() {
    1013       len = 0;
     1018      _len = 0;
    10141019      if (_arcs) delete[] _arcs;
    10151020      _arcs = 0;
    10161021    }
     
    10221027
    10231028    /// \brief The last arc of the path.
    10241029    const Arc& back() const {
    1025       return _arcs[len - 1];
     1030      return _arcs[_len - 1];
    10261031    }
    10271032
    10281033
     
    10301035
    10311036    template <typename CPath>
    10321037    void build(const CPath& path) {
    1033       len = path.length();
    1034       _arcs = new Arc[len];
     1038      _len = path.length();
     1039      _arcs = new Arc[_len];
    10351040      int index = 0;
    10361041      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
    10371042        _arcs[index] = it;
     
    10411046
    10421047    template <typename CPath>
    10431048    void buildRev(const CPath& path) {
    1044       len = path.length();
    1045       _arcs = new Arc[len];
    1046       int index = len;
     1049      _len = path.length();
     1050      _arcs = new Arc[_len];
     1051      int index = _len;
    10471052      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
    10481053        --index;
    10491054        _arcs[index] = it;
     
    10511056    }
    10521057
    10531058  private:
    1054     int len;
     1059    int _len;
    10551060    Arc* _arcs;
    10561061  };
    10571062