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