chromium源码阅读(3)-scoped_vector

5   // ScopedVector wraps a vector deleting the elements from its
16  // destructor.
17  template <class T>
18  class ScopedVector {
19    MOVE_ONLY_TYPE_FOR_CPP_03(ScopedVector, RValue)
20
21   public:
22    typedef typename std::vector<T*>::allocator_type allocator_type;
23    typedef typename std::vector<T*>::size_type size_type;
24    typedef typename std::vector<T*>::difference_type difference_type;
25    typedef typename std::vector<T*>::pointer pointer;
26    typedef typename std::vector<T*>::const_pointer const_pointer;
27    typedef typename std::vector<T*>::reference reference;
28    typedef typename std::vector<T*>::const_reference const_reference;
29    typedef typename std::vector<T*>::value_type value_type;
30    typedef typename std::vector<T*>::iterator iterator;
31    typedef typename std::vector<T*>::const_iterator const_iterator;
32    typedef typename std::vector<T*>::reverse_iterator reverse_iterator;
33    typedef typename std::vector<T*>::const_reverse_iterator
34        const_reverse_iterator;
35
36    ScopedVector() {}
37    ~ScopedVector() { clear(); }
38    ScopedVector(RValue other) { swap(*other.object); }
39
40    ScopedVector& operator=(RValue rhs) {
41      swap(*rhs.object);
42      return *this;
43    }
44
45    reference operator[](size_t index) { return v_[index]; }
46    const_reference operator[](size_t index) const { return v_[index]; }
47
48    bool empty() const { return v_.empty(); }
49    size_t size() const { return v_.size(); }
50
51    reverse_iterator rbegin() { return v_.rbegin(); }
52    const_reverse_iterator rbegin() const { return v_.rbegin(); }
53    reverse_iterator rend() { return v_.rend(); }
54    const_reverse_iterator rend() const { return v_.rend(); }
55
56    iterator begin() { return v_.begin(); }
57    const_iterator begin() const { return v_.begin(); }
58    iterator end() { return v_.end(); }
59    const_iterator end() const { return v_.end(); }
60
61    const_reference front() const { return v_.front(); }
62    reference front() { return v_.front(); }
63    const_reference back() const { return v_.back(); }
64    reference back() { return v_.back(); }
65
66    void push_back(T* elem) { v_.push_back(elem); }
67
68    void pop_back() {
69      DCHECK(!empty());
70      delete v_.back();
71      v_.pop_back();
72    }
73
74    std::vector<T*>& get() { return v_; }
75    const std::vector<T*>& get() const { return v_; }
76    void swap(std::vector<T*>& other) { v_.swap(other); }
77    void swap(ScopedVector<T>& other) { v_.swap(other.v_); }
78    void release(std::vector<T*>* out) {
79      out->swap(v_);
80      v_.clear();
81    }
82
83    void reserve(size_t capacity) { v_.reserve(capacity); }
84
85    // Resize, deleting elements in the disappearing range if we are shrinking.
86    void resize(size_t new_size) {
87      if (v_.size() > new_size)
88        STLDeleteContainerPointers(v_.begin() + new_size, v_.end());
89      v_.resize(new_size);
90    }
91
92    template<typename InputIterator>
93    void assign(InputIterator begin, InputIterator end) {
94      v_.assign(begin, end);
95    }
96
97    void clear() { STLDeleteElements(&v_); }
98
99    // Like |clear()|, but doesn't delete any elements.
100   void weak_clear() { v_.clear(); }
101
102   // Lets the ScopedVector take ownership of |x|.
103   iterator insert(iterator position, T* x) {
104     return v_.insert(position, x);
105   }
106
107   // Lets the ScopedVector take ownership of elements in [first,last).
108   template<typename InputIterator>
109   void insert(iterator position, InputIterator first, InputIterator last) {
110     v_.insert(position, first, last);
111   }
112
113   iterator erase(iterator position) {
114     delete *position;
115     return v_.erase(position);
116   }
117
118   iterator erase(iterator first, iterator last) {
119     STLDeleteContainerPointers(first, last);
120     return v_.erase(first, last);
121   }
122
123   // Like |erase()|, but doesn't delete the element at |position|.
124   iterator weak_erase(iterator position) {
125     return v_.erase(position);
126   }
127
128   // Like |erase()|, but doesn't delete the elements in [first, last).
129   iterator weak_erase(iterator first, iterator last) {
130     return v_.erase(first, last);
131   }
132
133  private:
134   std::vector<T*> v_;
135 };