Reduce dependency of TiclInvalidationService on Profile
[chromium-blink-merge.git] / cc / base / scoped_ptr_vector.h
blob288cb6fa47bfba2c36caaeeecb091984a7d9e539
1 // Copyright 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.
5 #ifndef CC_BASE_SCOPED_PTR_VECTOR_H_
6 #define CC_BASE_SCOPED_PTR_VECTOR_H_
8 #include <algorithm>
9 #include <vector>
11 #include "base/basictypes.h"
12 #include "base/logging.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/stl_util.h"
16 namespace cc {
18 // This type acts like a vector<scoped_ptr> based on top of std::vector. The
19 // ScopedPtrVector has ownership of all elements in the vector.
20 template <typename T>
21 class ScopedPtrVector {
22 public:
23 typedef typename std::vector<T*>::const_iterator const_iterator;
24 typedef typename std::vector<T*>::reverse_iterator reverse_iterator;
25 typedef typename std::vector<T*>::const_reverse_iterator
26 const_reverse_iterator;
28 #if defined(OS_ANDROID)
29 // On Android the iterator is not a class, so we can't block assignment.
30 typedef typename std::vector<T*>::iterator iterator;
31 #else
32 // Ban setting values on the iterator directly. New pointers must be passed
33 // to methods on the ScopedPtrVector class to appear in the vector.
34 class iterator : public std::vector<T*>::iterator {
35 public:
36 iterator(const typename std::vector<T*>::iterator& other) // NOLINT
37 : std::vector<T*>::iterator(other) {}
38 T* const& operator*() { return std::vector<T*>::iterator::operator*(); }
40 #endif
42 ScopedPtrVector() {}
44 ~ScopedPtrVector() { clear(); }
46 size_t size() const {
47 return data_.size();
50 T* at(size_t index) const {
51 DCHECK(index < size());
52 return data_[index];
55 T* operator[](size_t index) const {
56 return at(index);
59 T* front() const {
60 DCHECK(!empty());
61 return at(0);
64 T* back() const {
65 DCHECK(!empty());
66 return at(size() - 1);
69 bool empty() const {
70 return data_.empty();
73 scoped_ptr<T> take(iterator position) {
74 if (position == end())
75 return scoped_ptr<T>();
76 DCHECK(position < end());
78 typename std::vector<T*>::iterator writable_position = position;
79 scoped_ptr<T> ret(*writable_position);
80 *writable_position = NULL;
81 return ret.Pass();
84 scoped_ptr<T> take_back() {
85 DCHECK(!empty());
86 if (empty())
87 return scoped_ptr<T>(NULL);
88 return take(end() - 1);
91 void erase(iterator position) {
92 if (position == end())
93 return;
94 typename std::vector<T*>::iterator writable_position = position;
95 delete *writable_position;
96 data_.erase(position);
99 void erase(iterator first, iterator last) {
100 DCHECK(first <= last);
101 for (iterator it = first; it != last; ++it) {
102 DCHECK(it < end());
104 typename std::vector<T*>::iterator writable_it = it;
105 delete *writable_it;
107 data_.erase(first, last);
110 void reserve(size_t size) {
111 data_.reserve(size);
114 void clear() {
115 STLDeleteElements(&data_);
118 void push_back(scoped_ptr<T> item) {
119 data_.push_back(item.release());
122 void pop_back() {
123 delete data_.back();
124 data_.pop_back();
127 void insert(iterator position, scoped_ptr<T> item) {
128 DCHECK(position <= end());
129 data_.insert(position, item.release());
132 void insert_and_take(iterator position,
133 ScopedPtrVector<T>& other) {
134 std::vector<T*> tmp_data;
135 for (ScopedPtrVector<T>::iterator it = other.begin();
136 it != other.end();
137 ++it) {
138 tmp_data.push_back(other.take(it).release());
140 data_.insert(position, tmp_data.begin(), tmp_data.end());
143 template <typename Predicate>
144 iterator partition(Predicate predicate) {
145 typename std::vector<T*>::iterator first = begin();
146 typename std::vector<T*>::iterator last = end();
147 return static_cast<iterator>(std::partition(first, last, predicate));
150 void swap(ScopedPtrVector<T>& other) {
151 data_.swap(other.data_);
154 void swap(iterator a, iterator b) {
155 DCHECK(a < end());
156 DCHECK(b < end());
157 if (a == end() || b == end() || a == b)
158 return;
159 typename std::vector<T*>::iterator writable_a = a;
160 typename std::vector<T*>::iterator writable_b = b;
161 std::swap(*writable_a, *writable_b);
164 template<class Compare>
165 inline void sort(Compare comp) {
166 std::sort(data_.begin(), data_.end(), comp);
169 iterator begin() { return static_cast<iterator>(data_.begin()); }
170 const_iterator begin() const { return data_.begin(); }
171 iterator end() { return static_cast<iterator>(data_.end()); }
172 const_iterator end() const { return data_.end(); }
174 reverse_iterator rbegin() { return data_.rbegin(); }
175 const_reverse_iterator rbegin() const { return data_.rbegin(); }
176 reverse_iterator rend() { return data_.rend(); }
177 const_reverse_iterator rend() const { return data_.rend(); }
179 private:
180 std::vector<T*> data_;
182 DISALLOW_COPY_AND_ASSIGN(ScopedPtrVector);
185 } // namespace cc
187 #endif // CC_BASE_SCOPED_PTR_VECTOR_H_