Home | History | Annotate | Download | only in memory 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef BASE_MEMORY_SCOPED_VECTOR_H_
      6 #define BASE_MEMORY_SCOPED_VECTOR_H_
      7 
      8 #include <stddef.h>
      9 
     10 #include <memory>
     11 #include <vector>
     12 
     13 #include "base/logging.h"
     14 #include "base/macros.h"
     15 #include "base/stl_util.h"
     16 
     17 // ScopedVector wraps a vector deleting the elements from its
     18 // destructor.
     19 //
     20 // TODO(http://crbug.com/554289): DEPRECATED: Use std::vector instead (now that
     21 // we have support for moveable types inside containers).
     22 template <class T>
     23 class ScopedVector {
     24  public:
     25   typedef typename std::vector<T*>::allocator_type allocator_type;
     26   typedef typename std::vector<T*>::size_type size_type;
     27   typedef typename std::vector<T*>::difference_type difference_type;
     28   typedef typename std::vector<T*>::pointer pointer;
     29   typedef typename std::vector<T*>::const_pointer const_pointer;
     30   typedef typename std::vector<T*>::reference reference;
     31   typedef typename std::vector<T*>::const_reference const_reference;
     32   typedef typename std::vector<T*>::value_type value_type;
     33   typedef typename std::vector<T*>::iterator iterator;
     34   typedef typename std::vector<T*>::const_iterator const_iterator;
     35   typedef typename std::vector<T*>::reverse_iterator reverse_iterator;
     36   typedef typename std::vector<T*>::const_reverse_iterator
     37       const_reverse_iterator;
     38 
     39   ScopedVector() {}
     40   ~ScopedVector() { clear(); }
     41   ScopedVector(ScopedVector&& other) { swap(other); }
     42 
     43   ScopedVector& operator=(ScopedVector&& rhs) {
     44     swap(rhs);
     45     return *this;
     46   }
     47 
     48   reference operator[](size_t index) { return v_[index]; }
     49   const_reference operator[](size_t index) const { return v_[index]; }
     50 
     51   bool empty() const { return v_.empty(); }
     52   size_t size() const { return v_.size(); }
     53 
     54   reverse_iterator rbegin() { return v_.rbegin(); }
     55   const_reverse_iterator rbegin() const { return v_.rbegin(); }
     56   reverse_iterator rend() { return v_.rend(); }
     57   const_reverse_iterator rend() const { return v_.rend(); }
     58 
     59   iterator begin() { return v_.begin(); }
     60   const_iterator begin() const { return v_.begin(); }
     61   iterator end() { return v_.end(); }
     62   const_iterator end() const { return v_.end(); }
     63 
     64   const_reference front() const { return v_.front(); }
     65   reference front() { return v_.front(); }
     66   const_reference back() const { return v_.back(); }
     67   reference back() { return v_.back(); }
     68 
     69   void push_back(T* elem) { v_.push_back(elem); }
     70   void push_back(std::unique_ptr<T> elem) { v_.push_back(elem.release()); }
     71 
     72   void pop_back() {
     73     DCHECK(!empty());
     74     delete v_.back();
     75     v_.pop_back();
     76   }
     77 
     78   std::vector<T*>& get() { return v_; }
     79   const std::vector<T*>& get() const { return v_; }
     80   void swap(std::vector<T*>& other) { v_.swap(other); }
     81   void swap(ScopedVector<T>& other) { v_.swap(other.v_); }
     82   void release(std::vector<T*>* out) {
     83     out->swap(v_);
     84     v_.clear();
     85   }
     86 
     87   void reserve(size_t capacity) { v_.reserve(capacity); }
     88 
     89   // Resize, deleting elements in the disappearing range if we are shrinking.
     90   void resize(size_t new_size) {
     91     if (v_.size() > new_size)
     92       STLDeleteContainerPointers(v_.begin() + new_size, v_.end());
     93     v_.resize(new_size);
     94   }
     95 
     96   template<typename InputIterator>
     97   void assign(InputIterator begin, InputIterator end) {
     98     v_.assign(begin, end);
     99   }
    100 
    101   void clear() { STLDeleteElements(&v_); }
    102 
    103   // Like |clear()|, but doesn't delete any elements.
    104   void weak_clear() { v_.clear(); }
    105 
    106   // Lets the ScopedVector take ownership of |x|.
    107   iterator insert(iterator position, T* x) {
    108     return v_.insert(position, x);
    109   }
    110 
    111   iterator insert(iterator position, std::unique_ptr<T> x) {
    112     return v_.insert(position, x.release());
    113   }
    114 
    115   // Lets the ScopedVector take ownership of elements in [first,last).
    116   template<typename InputIterator>
    117   void insert(iterator position, InputIterator first, InputIterator last) {
    118     v_.insert(position, first, last);
    119   }
    120 
    121   iterator erase(iterator position) {
    122     delete *position;
    123     return v_.erase(position);
    124   }
    125 
    126   iterator erase(iterator first, iterator last) {
    127     STLDeleteContainerPointers(first, last);
    128     return v_.erase(first, last);
    129   }
    130 
    131   // Like |erase()|, but doesn't delete the element at |position|.
    132   iterator weak_erase(iterator position) {
    133     return v_.erase(position);
    134   }
    135 
    136   // Like |erase()|, but doesn't delete the elements in [first, last).
    137   iterator weak_erase(iterator first, iterator last) {
    138     return v_.erase(first, last);
    139   }
    140 
    141  private:
    142   std::vector<T*> v_;
    143 
    144   DISALLOW_COPY_AND_ASSIGN(ScopedVector);
    145 };
    146 
    147 #endif  // BASE_MEMORY_SCOPED_VECTOR_H_
    148