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