Add support for custom allocator to vtr::vector.

Signed-off-by: Keith Rothman <[email protected]>

Author: litghost

libs/libvtrutil/src/vtr_vector.h

@@ -15,8 +15,10 @@ namespace vtr {
 //
 //If you need more std::map-like (instead of std::vector-like) behaviour see
 //vtr::vector_map.
-template<typename K, typename V>
-class vector : private std::vector<V> {
+template<typename K, typename V, typename Allocator = std::allocator<V>>
+class vector : private std::vector<V, Allocator> {
+    using storage = std::vector<V, Allocator>;
+
   public:
     typedef K key_type;
 
@@ -25,71 +27,71 @@ class vector : private std::vector<V> {
 
   public:
     //Pass through std::vector's types
-    using typename std::vector<V>::value_type;
-    using typename std::vector<V>::allocator_type;
-    using typename std::vector<V>::reference;
-    using typename std::vector<V>::const_reference;
-    using typename std::vector<V>::pointer;
-    using typename std::vector<V>::const_pointer;
-    using typename std::vector<V>::iterator;
-    using typename std::vector<V>::const_iterator;
-    using typename std::vector<V>::reverse_iterator;
-    using typename std::vector<V>::const_reverse_iterator;
-    using typename std::vector<V>::difference_type;
-    using typename std::vector<V>::size_type;
-
-    //Pass through std::vector's methods
-    using std::vector<V>::vector;
-
-    using std::vector<V>::begin;
-    using std::vector<V>::end;
-    using std::vector<V>::rbegin;
-    using std::vector<V>::rend;
-    using std::vector<V>::cbegin;
-    using std::vector<V>::cend;
-    using std::vector<V>::crbegin;
-    using std::vector<V>::crend;
-
-    using std::vector<V>::size;
-    using std::vector<V>::max_size;
-    using std::vector<V>::resize;
-    using std::vector<V>::capacity;
-    using std::vector<V>::empty;
-    using std::vector<V>::reserve;
-    using std::vector<V>::shrink_to_fit;
-
-    using std::vector<V>::front;
-    using std::vector<V>::back;
-    using std::vector<V>::data;
-
-    using std::vector<V>::assign;
-    using std::vector<V>::push_back;
-    using std::vector<V>::pop_back;
-    using std::vector<V>::insert;
-    using std::vector<V>::erase;
-    using std::vector<V>::swap;
-    using std::vector<V>::clear;
-    using std::vector<V>::emplace;
-    using std::vector<V>::emplace_back;
-    using std::vector<V>::get_allocator;
+    using typename storage::allocator_type;
+    using typename storage::const_iterator;
+    using typename storage::const_pointer;
+    using typename storage::const_reference;
+    using typename storage::const_reverse_iterator;
+    using typename storage::difference_type;
+    using typename storage::iterator;
+    using typename storage::pointer;
+    using typename storage::reference;
+    using typename storage::reverse_iterator;
+    using typename storage::size_type;
+    using typename storage::value_type;
+
+    //Pass through storagemethods
+    using std::vector<V, Allocator>::vector;
+
+    using storage::begin;
+    using storage::cbegin;
+    using storage::cend;
+    using storage::crbegin;
+    using storage::crend;
+    using storage::end;
+    using storage::rbegin;
+    using storage::rend;
+
+    using storage::capacity;
+    using storage::empty;
+    using storage::max_size;
+    using storage::reserve;
+    using storage::resize;
+    using storage::shrink_to_fit;
+    using storage::size;
+
+    using storage::back;
+    using storage::data;
+    using storage::front;
+
+    using storage::assign;
+    using storage::clear;
+    using storage::emplace;
+    using storage::emplace_back;
+    using storage::erase;
+    using storage::get_allocator;
+    using storage::insert;
+    using storage::pop_back;
+    using storage::push_back;
+    using storage::swap;
 
     //Don't include operator[] and at() from std::vector,
     //since we redine them to take key_type instead of size_t
     reference operator[](const key_type id) {
         auto i = size_t(id);
-        return std::vector<V>::operator[](i);
+        return storage::operator[](i);
     }
     const_reference operator[](const key_type id) const {
         auto i = size_t(id);
-        return std::vector<V>::operator[](i);
+        return storage::operator[](i);
     }
     reference at(const key_type id) {
         auto i = size_t(id);
-        return std::vector<V>::at(i);
+        return storage::at(i);
     }
     const_reference at(const key_type id) const {
         auto i = size_t(id);
-        return std::vector<V>::at(i);
+        return storage::at(i);
     }
 
     //Returns a range containing the keys