/* * Copyright (C) 2005 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ANDROID_VECTOR_IMPL_H #define ANDROID_VECTOR_IMPL_H #include #include #include #include // --------------------------------------------------------------------------- // No user serviceable parts in here... // --------------------------------------------------------------------------- namespace android { /*! * Implementation of the guts of the vector<> class * this ensures backward binary compatibility and * reduces code size. * For performance reasons, we expose mStorage and mCount * so these fields are set in stone. * */ class VectorImpl { public: enum { // flags passed to the ctor HAS_TRIVIAL_CTOR = 0x00000001, HAS_TRIVIAL_DTOR = 0x00000002, HAS_TRIVIAL_COPY = 0x00000004, }; VectorImpl(size_t itemSize, uint32_t flags); VectorImpl(const VectorImpl& rhs); virtual ~VectorImpl(); /*! must be called from subclasses destructor */ void finish_vector(); VectorImpl& operator = (const VectorImpl& rhs); /*! C-style array access */ inline const void* arrayImpl() const { return mStorage; } void* editArrayImpl(); /*! vector stats */ inline size_t size() const { return mCount; } inline bool isEmpty() const { return mCount == 0; } size_t capacity() const; ssize_t setCapacity(size_t size); ssize_t resize(size_t size); /*! append/insert another vector or array */ ssize_t insertVectorAt(const VectorImpl& vector, size_t index); ssize_t appendVector(const VectorImpl& vector); ssize_t insertArrayAt(const void* array, size_t index, size_t length); ssize_t appendArray(const void* array, size_t length); /*! add/insert/replace items */ ssize_t insertAt(size_t where, size_t numItems = 1); ssize_t insertAt(const void* item, size_t where, size_t numItems = 1); void pop(); void push(); void push(const void* item); ssize_t add(); ssize_t add(const void* item); ssize_t replaceAt(size_t index); ssize_t replaceAt(const void* item, size_t index); /*! remove items */ ssize_t removeItemsAt(size_t index, size_t count = 1); void clear(); const void* itemLocation(size_t index) const; void* editItemLocation(size_t index); typedef int (*compar_t)(const void* lhs, const void* rhs); typedef int (*compar_r_t)(const void* lhs, const void* rhs, void* state); status_t sort(compar_t cmp); status_t sort(compar_r_t cmp, void* state); protected: size_t itemSize() const; void release_storage(); virtual void do_construct(void* storage, size_t num) const = 0; virtual void do_destroy(void* storage, size_t num) const = 0; virtual void do_copy(void* dest, const void* from, size_t num) const = 0; virtual void do_splat(void* dest, const void* item, size_t num) const = 0; virtual void do_move_forward(void* dest, const void* from, size_t num) const = 0; virtual void do_move_backward(void* dest, const void* from, size_t num) const = 0; // take care of FBC... virtual void reservedVectorImpl1(); virtual void reservedVectorImpl2(); virtual void reservedVectorImpl3(); virtual void reservedVectorImpl4(); virtual void reservedVectorImpl5(); virtual void reservedVectorImpl6(); virtual void reservedVectorImpl7(); virtual void reservedVectorImpl8(); private: void* _grow(size_t where, size_t amount); void _shrink(size_t where, size_t amount); inline void _do_construct(void* storage, size_t num) const; inline void _do_destroy(void* storage, size_t num) const; inline void _do_copy(void* dest, const void* from, size_t num) const; inline void _do_splat(void* dest, const void* item, size_t num) const; inline void _do_move_forward(void* dest, const void* from, size_t num) const; inline void _do_move_backward(void* dest, const void* from, size_t num) const; // These 2 fields are exposed in the inlines below, // so they're set in stone. void * mStorage; // base address of the vector size_t mCount; // number of items const uint32_t mFlags; const size_t mItemSize; }; class SortedVectorImpl : public VectorImpl { public: SortedVectorImpl(size_t itemSize, uint32_t flags); SortedVectorImpl(const VectorImpl& rhs); virtual ~SortedVectorImpl(); SortedVectorImpl& operator = (const SortedVectorImpl& rhs); //! finds the index of an item ssize_t indexOf(const void* item) const; //! finds where this item should be inserted size_t orderOf(const void* item) const; //! add an item in the right place (or replaces it if there is one) ssize_t add(const void* item); //! merges a vector into this one ssize_t merge(const VectorImpl& vector); ssize_t merge(const SortedVectorImpl& vector); //! removes an item ssize_t remove(const void* item); protected: virtual int do_compare(const void* lhs, const void* rhs) const = 0; // take care of FBC... virtual void reservedSortedVectorImpl1(); virtual void reservedSortedVectorImpl2(); virtual void reservedSortedVectorImpl3(); virtual void reservedSortedVectorImpl4(); virtual void reservedSortedVectorImpl5(); virtual void reservedSortedVectorImpl6(); virtual void reservedSortedVectorImpl7(); virtual void reservedSortedVectorImpl8(); private: ssize_t _indexOrderOf(const void* item, size_t* order = 0) const; // these are made private, because they can't be used on a SortedVector // (they don't have an implementation either) ssize_t add(); void pop(); void push(); void push(const void* item); ssize_t insertVectorAt(const VectorImpl& vector, size_t index); ssize_t appendVector(const VectorImpl& vector); ssize_t insertArrayAt(const void* array, size_t index, size_t length); ssize_t appendArray(const void* array, size_t length); ssize_t insertAt(size_t where, size_t numItems = 1); ssize_t insertAt(const void* item, size_t where, size_t numItems = 1); ssize_t replaceAt(size_t index); ssize_t replaceAt(const void* item, size_t index); }; }; // namespace android // --------------------------------------------------------------------------- #endif // ANDROID_VECTOR_IMPL_H