Line data Source code
1 : /*
2 : * Copyright (C) 2005 The Android Open Source Project
3 : *
4 : * Licensed under the Apache License, Version 2.0 (the "License");
5 : * you may not use this file except in compliance with the License.
6 : * You may obtain a copy of the License at
7 : *
8 : * http://www.apache.org/licenses/LICENSE-2.0
9 : *
10 : * Unless required by applicable law or agreed to in writing, software
11 : * distributed under the License is distributed on an "AS IS" BASIS,
12 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 : * See the License for the specific language governing permissions and
14 : * limitations under the License.
15 : */
16 :
17 : #ifndef ANDROID_VECTOR_H
18 : #define ANDROID_VECTOR_H
19 :
20 : #include <new>
21 : #include <assert.h>
22 : #include <stdint.h>
23 : #include <sys/types.h>
24 :
25 : #include <cutils/log.h>
26 :
27 : #include <utils/VectorImpl.h>
28 : #include <utils/TypeHelpers.h>
29 :
30 : // ---------------------------------------------------------------------------
31 :
32 : namespace stagefright {
33 :
34 : template <typename TYPE>
35 : class SortedVector;
36 :
37 : /*!
38 : * The main templated vector class ensuring type safety
39 : * while making use of VectorImpl.
40 : * This is the class users want to use.
41 : */
42 :
43 : template <class TYPE>
44 : class Vector : private VectorImpl
45 : {
46 : public:
47 : typedef TYPE value_type;
48 :
49 : /*!
50 : * Constructors and destructors
51 : */
52 :
53 : Vector();
54 : Vector(const Vector<TYPE>& rhs);
55 : explicit Vector(const SortedVector<TYPE>& rhs);
56 : virtual ~Vector();
57 :
58 : /*! copy operator */
59 : Vector<TYPE>& operator = (const Vector<TYPE>& rhs);
60 :
61 : Vector<TYPE>& operator = (const SortedVector<TYPE>& rhs);
62 :
63 : /*
64 : * empty the vector
65 : */
66 :
67 0 : inline void clear() { VectorImpl::clear(); }
68 :
69 : /*!
70 : * vector stats
71 : */
72 :
73 : //! returns number of items in the vector
74 0 : inline size_t size() const { return VectorImpl::size(); }
75 : //! returns whether or not the vector is empty
76 : inline bool isEmpty() const { return VectorImpl::isEmpty(); }
77 : //! returns how many items can be stored without reallocating the backing store
78 : inline size_t capacity() const { return VectorImpl::capacity(); }
79 : //! sets the capacity. capacity can never be reduced less than size()
80 : inline ssize_t setCapacity(size_t size) { return VectorImpl::setCapacity(size); }
81 :
82 : /*!
83 : * set the size of the vector. items are appended with the default
84 : * constructor, or removed from the end as needed.
85 : */
86 : inline ssize_t resize(size_t size) { return VectorImpl::resize(size); }
87 :
88 : /*!
89 : * C-style array access
90 : */
91 :
92 : //! read-only C-style access
93 : inline const TYPE* array() const;
94 : //! read-write C-style access
95 : TYPE* editArray();
96 :
97 : /*!
98 : * accessors
99 : */
100 :
101 : //! read-only access to an item at a given index
102 : inline const TYPE& operator [] (size_t index) const;
103 : //! alternate name for operator []
104 : inline const TYPE& itemAt(size_t index) const;
105 : //! stack-usage of the vector. returns the top of the stack (last element)
106 : const TYPE& top() const;
107 :
108 : /*!
109 : * modifying the array
110 : */
111 :
112 : //! copy-on write support, grants write access to an item
113 : TYPE& editItemAt(size_t index);
114 : //! grants right access to the top of the stack (last element)
115 : TYPE& editTop();
116 :
117 : /*!
118 : * append/insert another vector
119 : */
120 :
121 : //! insert another vector at a given index
122 : ssize_t insertVectorAt(const Vector<TYPE>& vector, size_t index);
123 :
124 : //! append another vector at the end of this one
125 : ssize_t appendVector(const Vector<TYPE>& vector);
126 :
127 :
128 : //! insert an array at a given index
129 : ssize_t insertArrayAt(const TYPE* array, size_t index, size_t length);
130 :
131 : //! append an array at the end of this vector
132 : ssize_t appendArray(const TYPE* array, size_t length);
133 :
134 : /*!
135 : * add/insert/replace items
136 : */
137 :
138 : //! insert one or several items initialized with their default constructor
139 : inline ssize_t insertAt(size_t index, size_t numItems = 1);
140 : //! insert one or several items initialized from a prototype item
141 : ssize_t insertAt(const TYPE& prototype_item, size_t index, size_t numItems = 1);
142 : //! pop the top of the stack (removes the last element). No-op if the stack's empty
143 : inline void pop();
144 : //! pushes an item initialized with its default constructor
145 : inline void push();
146 : //! pushes an item on the top of the stack
147 : void push(const TYPE& item);
148 : //! same as push() but returns the index the item was added at (or an error)
149 : inline ssize_t add();
150 : //! same as push() but returns the index the item was added at (or an error)
151 : ssize_t add(const TYPE& item);
152 : //! replace an item with a new one initialized with its default constructor
153 : inline ssize_t replaceAt(size_t index);
154 : //! replace an item with a new one
155 : ssize_t replaceAt(const TYPE& item, size_t index);
156 :
157 : /*!
158 : * remove items
159 : */
160 :
161 : //! remove several items
162 : inline ssize_t removeItemsAt(size_t index, size_t count = 1);
163 : //! remove one item
164 : inline ssize_t removeAt(size_t index) { return removeItemsAt(index); }
165 :
166 : /*!
167 : * sort (stable) the array
168 : */
169 :
170 : typedef int (*compar_t)(const TYPE* lhs, const TYPE* rhs);
171 : typedef int (*compar_r_t)(const TYPE* lhs, const TYPE* rhs, void* state);
172 :
173 : inline status_t sort(compar_t cmp) {
174 : return VectorImpl::sort((VectorImpl::compar_t)cmp);
175 : }
176 : inline status_t sort(compar_r_t cmp, void* state) {
177 : return VectorImpl::sort((VectorImpl::compar_r_t)cmp, state);
178 : }
179 :
180 : // for debugging only
181 : inline size_t getItemSize() const { return itemSize(); }
182 :
183 :
184 : /*
185 : * these inlines add some level of compatibility with STL. eventually
186 : * we should probably turn things around.
187 : */
188 : typedef TYPE* iterator;
189 : typedef TYPE const* const_iterator;
190 :
191 : inline iterator begin() { return editArray(); }
192 : inline iterator end() { return editArray() + size(); }
193 : inline const_iterator begin() const { return array(); }
194 : inline const_iterator end() const { return array() + size(); }
195 : inline void reserve(size_t n) { assert(setCapacity(n) >= 0); }
196 : inline bool empty() const{ return isEmpty(); }
197 : inline void push_back(const TYPE& item) { insertAt(item, size(), 1); }
198 : inline void push_front(const TYPE& item) { insertAt(item, 0, 1); }
199 : inline iterator erase(iterator pos) {
200 : ssize_t index = removeItemsAt(pos-array());
201 : return begin() + index;
202 : }
203 :
204 : protected:
205 : virtual void do_construct(void* storage, size_t num) const;
206 : virtual void do_destroy(void* storage, size_t num) const;
207 : virtual void do_copy(void* dest, const void* from, size_t num) const;
208 : virtual void do_splat(void* dest, const void* item, size_t num) const;
209 : virtual void do_move_forward(void* dest, const void* from, size_t num) const;
210 : virtual void do_move_backward(void* dest, const void* from, size_t num) const;
211 : };
212 :
213 : // Vector<T> can be trivially moved using memcpy() because moving does not
214 : // require any change to the underlying SharedBuffer contents or reference count.
215 : template<typename T> struct trait_trivial_move<Vector<T> > { enum { value = true }; };
216 :
217 : // ---------------------------------------------------------------------------
218 : // No user serviceable parts from here...
219 : // ---------------------------------------------------------------------------
220 :
221 : template<class TYPE> inline
222 3 : Vector<TYPE>::Vector()
223 : : VectorImpl(sizeof(TYPE),
224 : ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
225 : |(traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
226 : |(traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))
227 3 : )
228 : {
229 3 : }
230 :
231 : template<class TYPE> inline
232 : Vector<TYPE>::Vector(const Vector<TYPE>& rhs)
233 : : VectorImpl(rhs) {
234 : }
235 :
236 : template<class TYPE> inline
237 : Vector<TYPE>::Vector(const SortedVector<TYPE>& rhs)
238 : : VectorImpl(static_cast<const VectorImpl&>(rhs)) {
239 : }
240 :
241 : template<class TYPE> inline
242 0 : Vector<TYPE>::~Vector() {
243 0 : finish_vector();
244 0 : }
245 :
246 : template<class TYPE> inline
247 : Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) {
248 : VectorImpl::operator = (rhs);
249 : return *this;
250 : }
251 :
252 : template<class TYPE> inline
253 : Vector<TYPE>& Vector<TYPE>::operator = (const SortedVector<TYPE>& rhs) {
254 : VectorImpl::operator = (static_cast<const VectorImpl&>(rhs));
255 : return *this;
256 : }
257 :
258 : template<class TYPE> inline
259 0 : const TYPE* Vector<TYPE>::array() const {
260 0 : return static_cast<const TYPE *>(arrayImpl());
261 : }
262 :
263 : template<class TYPE> inline
264 : TYPE* Vector<TYPE>::editArray() {
265 : return static_cast<TYPE *>(editArrayImpl());
266 : }
267 :
268 :
269 : template<class TYPE> inline
270 0 : const TYPE& Vector<TYPE>::operator[](size_t index) const {
271 : LOG_FATAL_IF(index>=size(),
272 : "%s: index=%u out of range (%u)", __PRETTY_FUNCTION__,
273 : int(index), int(size()));
274 0 : return *(array() + index);
275 : }
276 :
277 : template<class TYPE> inline
278 : const TYPE& Vector<TYPE>::itemAt(size_t index) const {
279 : return operator[](index);
280 : }
281 :
282 : template<class TYPE> inline
283 : const TYPE& Vector<TYPE>::top() const {
284 : return *(array() + size() - 1);
285 : }
286 :
287 : template<class TYPE> inline
288 0 : TYPE& Vector<TYPE>::editItemAt(size_t index) {
289 0 : return *( static_cast<TYPE *>(editItemLocation(index)) );
290 : }
291 :
292 : template<class TYPE> inline
293 : TYPE& Vector<TYPE>::editTop() {
294 : return *( static_cast<TYPE *>(editItemLocation(size()-1)) );
295 : }
296 :
297 : template<class TYPE> inline
298 : ssize_t Vector<TYPE>::insertVectorAt(const Vector<TYPE>& vector, size_t index) {
299 : return VectorImpl::insertVectorAt(reinterpret_cast<const VectorImpl&>(vector), index);
300 : }
301 :
302 : template<class TYPE> inline
303 : ssize_t Vector<TYPE>::appendVector(const Vector<TYPE>& vector) {
304 : return VectorImpl::appendVector(reinterpret_cast<const VectorImpl&>(vector));
305 : }
306 :
307 : template<class TYPE> inline
308 : ssize_t Vector<TYPE>::insertArrayAt(const TYPE* array, size_t index, size_t length) {
309 : return VectorImpl::insertArrayAt(array, index, length);
310 : }
311 :
312 : template<class TYPE> inline
313 : ssize_t Vector<TYPE>::appendArray(const TYPE* array, size_t length) {
314 : return VectorImpl::appendArray(array, length);
315 : }
316 :
317 : template<class TYPE> inline
318 : ssize_t Vector<TYPE>::insertAt(const TYPE& item, size_t index, size_t numItems) {
319 : return VectorImpl::insertAt(&item, index, numItems);
320 : }
321 :
322 : template<class TYPE> inline
323 384 : void Vector<TYPE>::push(const TYPE& item) {
324 384 : return VectorImpl::push(&item);
325 : }
326 :
327 : template<class TYPE> inline
328 : ssize_t Vector<TYPE>::add(const TYPE& item) {
329 : return VectorImpl::add(&item);
330 : }
331 :
332 : template<class TYPE> inline
333 : ssize_t Vector<TYPE>::replaceAt(const TYPE& item, size_t index) {
334 : return VectorImpl::replaceAt(&item, index);
335 : }
336 :
337 : template<class TYPE> inline
338 : ssize_t Vector<TYPE>::insertAt(size_t index, size_t numItems) {
339 : return VectorImpl::insertAt(index, numItems);
340 : }
341 :
342 : template<class TYPE> inline
343 : void Vector<TYPE>::pop() {
344 : VectorImpl::pop();
345 : }
346 :
347 : template<class TYPE> inline
348 : void Vector<TYPE>::push() {
349 : VectorImpl::push();
350 : }
351 :
352 : template<class TYPE> inline
353 : ssize_t Vector<TYPE>::add() {
354 : return VectorImpl::add();
355 : }
356 :
357 : template<class TYPE> inline
358 : ssize_t Vector<TYPE>::replaceAt(size_t index) {
359 : return VectorImpl::replaceAt(index);
360 : }
361 :
362 : template<class TYPE> inline
363 : ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
364 : return VectorImpl::removeItemsAt(index, count);
365 : }
366 :
367 : // ---------------------------------------------------------------------------
368 :
369 : template<class TYPE>
370 0 : void Vector<TYPE>::do_construct(void* storage, size_t num) const {
371 0 : construct_type( reinterpret_cast<TYPE*>(storage), num );
372 0 : }
373 :
374 : template<class TYPE>
375 21 : void Vector<TYPE>::do_destroy(void* storage, size_t num) const {
376 21 : destroy_type( reinterpret_cast<TYPE*>(storage), num );
377 21 : }
378 :
379 : template<class TYPE>
380 21 : void Vector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
381 21 : copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
382 21 : }
383 :
384 : template<class TYPE>
385 384 : void Vector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
386 384 : splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
387 384 : }
388 :
389 : template<class TYPE>
390 0 : void Vector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
391 0 : move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
392 0 : }
393 :
394 : template<class TYPE>
395 0 : void Vector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
396 0 : move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
397 0 : }
398 :
399 : }; // namespace stagefright
400 :
401 :
402 : // ---------------------------------------------------------------------------
403 :
404 : #endif // ANDROID_VECTOR_H
|
