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