Vector.h revision dd7bc3319deb2b77c5d07a51b7d6cd7e11b5beb0 
1/*
2 *  vector.h
3 *  Android
4 *
5 *  Copyright 2005 The Android Open Source Project
6 *
7 */
8
9#ifndef ANDROID_VECTOR_H
10#define ANDROID_VECTOR_H
11
12#include <new>
13#include <stdint.h>
14#include <sys/types.h>
15
16#include <cutils/log.h>
17
18#include "tinyutils/VectorImpl.h"
19#include "tinyutils/TypeHelpers.h"
20
21// ---------------------------------------------------------------------------
22
23namespace android {
24
25/*!
26 * The main templated vector class ensuring type safety
27 * while making use of VectorImpl.
28 * This is the class users want to use.
29 */
30
31template <class TYPE>
32class Vector : private VectorImpl
33{
34public:
35            typedef TYPE    value_type;
36
37    /*!
38     * Constructors and destructors
39     */
40
41                            Vector();
42                            Vector(const Vector<TYPE>& rhs);
43    virtual                 ~Vector();
44
45    /*! copy operator */
46            const Vector<TYPE>&     operator = (const Vector<TYPE>& rhs) const;
47            Vector<TYPE>&           operator = (const Vector<TYPE>& rhs);
48
49    /*
50     * empty the vector
51     */
52
53    inline  void            clear()             { VectorImpl::clear(); }
54
55    /*!
56     * vector stats
57     */
58
59    //! returns number of items in the vector
60    inline  size_t          size() const                { return VectorImpl::size(); }
61    //! returns wether or not the vector is empty
62    inline  bool            isEmpty() const             { return VectorImpl::isEmpty(); }
63    //! returns how many items can be stored without reallocating the backing store
64    inline  size_t          capacity() const            { return VectorImpl::capacity(); }
65    //! setst the capacity. capacity can never be reduced less than size()
66    inline  ssize_t         setCapacity(size_t size)    { return VectorImpl::setCapacity(size); }
67
68    /*!
69     * C-style array access
70     */
71
72    //! read-only C-style access
73    inline  const TYPE*     array() const;
74    //! read-write C-style access
75            TYPE*           editArray();
76
77    /*!
78     * accessors
79     */
80
81    //! read-only access to an item at a given index
82    inline  const TYPE&     operator [] (size_t index) const;
83    //! alternate name for operator []
84    inline  const TYPE&     itemAt(size_t index) const;
85    //! stack-usage of the vector. returns the top of the stack (last element)
86            const TYPE&     top() const;
87    //! same as operator [], but allows to access the vector backward (from the end) with a negative index
88            const TYPE&     mirrorItemAt(ssize_t index) const;
89
90    /*!
91     * modifing the array
92     */
93
94    //! copy-on write support, grants write access to an item
95            TYPE&           editItemAt(size_t index);
96    //! grants right acces to the top of the stack (last element)
97            TYPE&           editTop();
98
99            /*!
100             * append/insert another vector
101             */
102
103    //! insert another vector at a given index
104            ssize_t         insertVectorAt(const Vector<TYPE>& vector, size_t index);
105
106    //! append another vector at the end of this one
107            ssize_t         appendVector(const Vector<TYPE>& vector);
108
109
110            /*!
111             * add/insert/replace items
112             */
113
114    //! insert one or several items initialized with their default constructor
115    inline  ssize_t         insertAt(size_t index, size_t numItems = 1);
116    //! insert on onr several items initialized from a prototype item
117            ssize_t         insertAt(const TYPE& prototype_item, size_t index, size_t numItems = 1);
118    //! pop the top of the stack (removes the last element). No-op if the stack's empty
119    inline  void            pop();
120    //! pushes an item initialized with its default constructor
121    inline  void            push();
122    //! pushes an item on the top of the stack
123            void            push(const TYPE& item);
124    //! same as push() but returns the index the item was added at (or an error)
125    inline  ssize_t         add();
126    //! same as push() but returns the index the item was added at (or an error)
127            ssize_t         add(const TYPE& item);
128    //! replace an item with a new one initialized with its default constructor
129    inline  ssize_t         replaceAt(size_t index);
130    //! replace an item with a new one
131            ssize_t         replaceAt(const TYPE& item, size_t index);
132
133    /*!
134     * remove items
135     */
136
137    //! remove several items
138    inline  ssize_t         removeItemsAt(size_t index, size_t count = 1);
139    //! remove one item
140    inline  ssize_t         removeAt(size_t index)  { return removeItemsAt(index); }
141
142    /*!
143     * sort (stable) the array
144     */
145
146     typedef int (*compar_t)(const TYPE* lhs, const TYPE* rhs);
147     typedef int (*compar_r_t)(const TYPE* lhs, const TYPE* rhs, void* state);
148
149     inline status_t        sort(compar_t cmp);
150     inline status_t        sort(compar_r_t cmp, void* state);
151
152protected:
153    virtual void    do_construct(void* storage, size_t num) const;
154    virtual void    do_destroy(void* storage, size_t num) const;
155    virtual void    do_copy(void* dest, const void* from, size_t num) const;
156    virtual void    do_splat(void* dest, const void* item, size_t num) const;
157    virtual void    do_move_forward(void* dest, const void* from, size_t num) const;
158    virtual void    do_move_backward(void* dest, const void* from, size_t num) const;
159};
160
161
162// ---------------------------------------------------------------------------
163// No user serviceable parts from here...
164// ---------------------------------------------------------------------------
165
166template<class TYPE> inline
167Vector<TYPE>::Vector()
168    : VectorImpl(sizeof(TYPE),
169                ((traits<TYPE>::has_trivial_ctor   ? HAS_TRIVIAL_CTOR   : 0)
170                |(traits<TYPE>::has_trivial_dtor   ? HAS_TRIVIAL_DTOR   : 0)
171                |(traits<TYPE>::has_trivial_copy   ? HAS_TRIVIAL_COPY   : 0)
172                |(traits<TYPE>::has_trivial_assign ? HAS_TRIVIAL_ASSIGN : 0))
173                )
174{
175}
176
177template<class TYPE> inline
178Vector<TYPE>::Vector(const Vector<TYPE>& rhs)
179    : VectorImpl(rhs) {
180}
181
182template<class TYPE> inline
183Vector<TYPE>::~Vector() {
184    finish_vector();
185}
186
187template<class TYPE> inline
188Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) {
189    VectorImpl::operator = (rhs);
190    return *this;
191}
192
193template<class TYPE> inline
194const Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) const {
195    VectorImpl::operator = (rhs);
196    return *this;
197}
198
199template<class TYPE> inline
200const TYPE* Vector<TYPE>::array() const {
201    return static_cast<const TYPE *>(arrayImpl());
202}
203
204template<class TYPE> inline
205TYPE* Vector<TYPE>::editArray() {
206    return static_cast<TYPE *>(editArrayImpl());
207}
208
209
210template<class TYPE> inline
211const TYPE& Vector<TYPE>::operator[](size_t index) const {
212    LOG_FATAL_IF( index>=size(),
213                  "itemAt: index %d is past size %d", (int)index, (int)size() );
214    return *(array() + index);
215}
216
217template<class TYPE> inline
218const TYPE& Vector<TYPE>::itemAt(size_t index) const {
219    return operator[](index);
220}
221
222template<class TYPE> inline
223const TYPE& Vector<TYPE>::mirrorItemAt(ssize_t index) const {
224    LOG_FATAL_IF( (index>0 ? index : -index)>=size(),
225                  "mirrorItemAt: index %d is past size %d",
226                  (int)index, (int)size() );
227    return *(array() + ((index<0) ? (size()-index) : index));
228}
229
230template<class TYPE> inline
231const TYPE& Vector<TYPE>::top() const {
232    return *(array() + size() - 1);
233}
234
235template<class TYPE> inline
236TYPE& Vector<TYPE>::editItemAt(size_t index) {
237    return *( static_cast<TYPE *>(editItemLocation(index)) );
238}
239
240template<class TYPE> inline
241TYPE& Vector<TYPE>::editTop() {
242    return *( static_cast<TYPE *>(editItemLocation(size()-1)) );
243}
244
245template<class TYPE> inline
246ssize_t Vector<TYPE>::insertVectorAt(const Vector<TYPE>& vector, size_t index) {
247    return VectorImpl::insertVectorAt(reinterpret_cast<const VectorImpl&>(vector), index);
248}
249
250template<class TYPE> inline
251ssize_t Vector<TYPE>::appendVector(const Vector<TYPE>& vector) {
252    return VectorImpl::appendVector(reinterpret_cast<const VectorImpl&>(vector));
253}
254
255template<class TYPE> inline
256ssize_t Vector<TYPE>::insertAt(const TYPE& item, size_t index, size_t numItems) {
257    return VectorImpl::insertAt(&item, index, numItems);
258}
259
260template<class TYPE> inline
261void Vector<TYPE>::push(const TYPE& item) {
262    return VectorImpl::push(&item);
263}
264
265template<class TYPE> inline
266ssize_t Vector<TYPE>::add(const TYPE& item) {
267    return VectorImpl::add(&item);
268}
269
270template<class TYPE> inline
271ssize_t Vector<TYPE>::replaceAt(const TYPE& item, size_t index) {
272    return VectorImpl::replaceAt(&item, index);
273}
274
275template<class TYPE> inline
276ssize_t Vector<TYPE>::insertAt(size_t index, size_t numItems) {
277    return VectorImpl::insertAt(index, numItems);
278}
279
280template<class TYPE> inline
281void Vector<TYPE>::pop() {
282    VectorImpl::pop();
283}
284
285template<class TYPE> inline
286void Vector<TYPE>::push() {
287    VectorImpl::push();
288}
289
290template<class TYPE> inline
291ssize_t Vector<TYPE>::add() {
292    return VectorImpl::add();
293}
294
295template<class TYPE> inline
296ssize_t Vector<TYPE>::replaceAt(size_t index) {
297    return VectorImpl::replaceAt(index);
298}
299
300template<class TYPE> inline
301ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
302    return VectorImpl::removeItemsAt(index, count);
303}
304
305template<class TYPE> inline
306status_t Vector<TYPE>::sort(Vector<TYPE>::compar_t cmp) {
307    return VectorImpl::sort((VectorImpl::compar_t)cmp);
308}
309
310template<class TYPE> inline
311status_t Vector<TYPE>::sort(Vector<TYPE>::compar_r_t cmp, void* state) {
312    return VectorImpl::sort((VectorImpl::compar_r_t)cmp, state);
313}
314
315// ---------------------------------------------------------------------------
316
317template<class TYPE>
318void Vector<TYPE>::do_construct(void* storage, size_t num) const {
319    construct_type( reinterpret_cast<TYPE*>(storage), num );
320}
321
322template<class TYPE>
323void Vector<TYPE>::do_destroy(void* storage, size_t num) const {
324    destroy_type( reinterpret_cast<TYPE*>(storage), num );
325}
326
327template<class TYPE>
328void Vector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
329    copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
330}
331
332template<class TYPE>
333void Vector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
334    splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
335}
336
337template<class TYPE>
338void Vector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
339    move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
340}
341
342template<class TYPE>
343void Vector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
344    move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
345}
346
347}; // namespace android
348
349
350// ---------------------------------------------------------------------------
351
352#endif // ANDROID_VECTOR_H
353