1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/media/omx-plugin/include/froyo/utils/SortedVector.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,281 @@
1.4 +/*
1.5 + * Copyright (C) 2005 The Android Open Source Project
1.6 + *
1.7 + * Licensed under the Apache License, Version 2.0 (the "License");
1.8 + * you may not use this file except in compliance with the License.
1.9 + * You may obtain a copy of the License at
1.10 + *
1.11 + * http://www.apache.org/licenses/LICENSE-2.0
1.12 + *
1.13 + * Unless required by applicable law or agreed to in writing, software
1.14 + * distributed under the License is distributed on an "AS IS" BASIS,
1.15 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1.16 + * See the License for the specific language governing permissions and
1.17 + * limitations under the License.
1.18 + */
1.19 +
1.20 +#ifndef ANDROID_SORTED_VECTOR_H
1.21 +#define ANDROID_SORTED_VECTOR_H
1.22 +
1.23 +#include <assert.h>
1.24 +#include <stdint.h>
1.25 +#include <sys/types.h>
1.26 +
1.27 +#include <utils/Vector.h>
1.28 +#include <utils/VectorImpl.h>
1.29 +#include <utils/TypeHelpers.h>
1.30 +
1.31 +// ---------------------------------------------------------------------------
1.32 +
1.33 +namespace android {
1.34 +
1.35 +template <class TYPE>
1.36 +class SortedVector : private SortedVectorImpl
1.37 +{
1.38 +public:
1.39 + typedef TYPE value_type;
1.40 +
1.41 + /*!
1.42 + * Constructors and destructors
1.43 + */
1.44 +
1.45 + SortedVector();
1.46 + SortedVector(const SortedVector<TYPE>& rhs);
1.47 + virtual ~SortedVector();
1.48 +
1.49 + /*! copy operator */
1.50 + const SortedVector<TYPE>& operator = (const SortedVector<TYPE>& rhs) const;
1.51 + SortedVector<TYPE>& operator = (const SortedVector<TYPE>& rhs);
1.52 +
1.53 + /*
1.54 + * empty the vector
1.55 + */
1.56 +
1.57 + inline void clear() { VectorImpl::clear(); }
1.58 +
1.59 + /*!
1.60 + * vector stats
1.61 + */
1.62 +
1.63 + //! returns number of items in the vector
1.64 + inline size_t size() const { return VectorImpl::size(); }
1.65 + //! returns wether or not the vector is empty
1.66 + inline bool isEmpty() const { return VectorImpl::isEmpty(); }
1.67 + //! returns how many items can be stored without reallocating the backing store
1.68 + inline size_t capacity() const { return VectorImpl::capacity(); }
1.69 + //! setst the capacity. capacity can never be reduced less than size()
1.70 + inline ssize_t setCapacity(size_t size) { return VectorImpl::setCapacity(size); }
1.71 +
1.72 + /*!
1.73 + * C-style array access
1.74 + */
1.75 +
1.76 + //! read-only C-style access
1.77 + inline const TYPE* array() const;
1.78 +
1.79 + //! read-write C-style access. BE VERY CAREFUL when modifying the array
1.80 + //! you ust keep it sorted! You usually don't use this function.
1.81 + TYPE* editArray();
1.82 +
1.83 + //! finds the index of an item
1.84 + ssize_t indexOf(const TYPE& item) const;
1.85 +
1.86 + //! finds where this item should be inserted
1.87 + size_t orderOf(const TYPE& item) const;
1.88 +
1.89 +
1.90 + /*!
1.91 + * accessors
1.92 + */
1.93 +
1.94 + //! read-only access to an item at a given index
1.95 + inline const TYPE& operator [] (size_t index) const;
1.96 + //! alternate name for operator []
1.97 + inline const TYPE& itemAt(size_t index) const;
1.98 + //! stack-usage of the vector. returns the top of the stack (last element)
1.99 + const TYPE& top() const;
1.100 + //! same as operator [], but allows to access the vector backward (from the end) with a negative index
1.101 + const TYPE& mirrorItemAt(ssize_t index) const;
1.102 +
1.103 + /*!
1.104 + * modifing the array
1.105 + */
1.106 +
1.107 + //! add an item in the right place (and replace the one that is there)
1.108 + ssize_t add(const TYPE& item);
1.109 +
1.110 + //! editItemAt() MUST NOT change the order of this item
1.111 + TYPE& editItemAt(size_t index) {
1.112 + return *( static_cast<TYPE *>(VectorImpl::editItemLocation(index)) );
1.113 + }
1.114 +
1.115 + //! merges a vector into this one
1.116 + ssize_t merge(const Vector<TYPE>& vector);
1.117 + ssize_t merge(const SortedVector<TYPE>& vector);
1.118 +
1.119 + //! removes an item
1.120 + ssize_t remove(const TYPE&);
1.121 +
1.122 + //! remove several items
1.123 + inline ssize_t removeItemsAt(size_t index, size_t count = 1);
1.124 + //! remove one item
1.125 + inline ssize_t removeAt(size_t index) { return removeItemsAt(index); }
1.126 +
1.127 +protected:
1.128 + virtual void do_construct(void* storage, size_t num) const;
1.129 + virtual void do_destroy(void* storage, size_t num) const;
1.130 + virtual void do_copy(void* dest, const void* from, size_t num) const;
1.131 + virtual void do_splat(void* dest, const void* item, size_t num) const;
1.132 + virtual void do_move_forward(void* dest, const void* from, size_t num) const;
1.133 + virtual void do_move_backward(void* dest, const void* from, size_t num) const;
1.134 + virtual int do_compare(const void* lhs, const void* rhs) const;
1.135 +};
1.136 +
1.137 +
1.138 +// ---------------------------------------------------------------------------
1.139 +// No user serviceable parts from here...
1.140 +// ---------------------------------------------------------------------------
1.141 +
1.142 +template<class TYPE> inline
1.143 +SortedVector<TYPE>::SortedVector()
1.144 + : SortedVectorImpl(sizeof(TYPE),
1.145 + ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
1.146 + |(traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
1.147 + |(traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))
1.148 + )
1.149 +{
1.150 +}
1.151 +
1.152 +template<class TYPE> inline
1.153 +SortedVector<TYPE>::SortedVector(const SortedVector<TYPE>& rhs)
1.154 + : SortedVectorImpl(rhs) {
1.155 +}
1.156 +
1.157 +template<class TYPE> inline
1.158 +SortedVector<TYPE>::~SortedVector() {
1.159 + finish_vector();
1.160 +}
1.161 +
1.162 +template<class TYPE> inline
1.163 +SortedVector<TYPE>& SortedVector<TYPE>::operator = (const SortedVector<TYPE>& rhs) {
1.164 + SortedVectorImpl::operator = (rhs);
1.165 + return *this;
1.166 +}
1.167 +
1.168 +template<class TYPE> inline
1.169 +const SortedVector<TYPE>& SortedVector<TYPE>::operator = (const SortedVector<TYPE>& rhs) const {
1.170 + SortedVectorImpl::operator = (rhs);
1.171 + return *this;
1.172 +}
1.173 +
1.174 +template<class TYPE> inline
1.175 +const TYPE* SortedVector<TYPE>::array() const {
1.176 + return static_cast<const TYPE *>(arrayImpl());
1.177 +}
1.178 +
1.179 +template<class TYPE> inline
1.180 +TYPE* SortedVector<TYPE>::editArray() {
1.181 + return static_cast<TYPE *>(editArrayImpl());
1.182 +}
1.183 +
1.184 +
1.185 +template<class TYPE> inline
1.186 +const TYPE& SortedVector<TYPE>::operator[](size_t index) const {
1.187 + assert( index<size() );
1.188 + return *(array() + index);
1.189 +}
1.190 +
1.191 +template<class TYPE> inline
1.192 +const TYPE& SortedVector<TYPE>::itemAt(size_t index) const {
1.193 + return operator[](index);
1.194 +}
1.195 +
1.196 +template<class TYPE> inline
1.197 +const TYPE& SortedVector<TYPE>::mirrorItemAt(ssize_t index) const {
1.198 + assert( (index>0 ? index : -index)<size() );
1.199 + return *(array() + ((index<0) ? (size()-index) : index));
1.200 +}
1.201 +
1.202 +template<class TYPE> inline
1.203 +const TYPE& SortedVector<TYPE>::top() const {
1.204 + return *(array() + size() - 1);
1.205 +}
1.206 +
1.207 +template<class TYPE> inline
1.208 +ssize_t SortedVector<TYPE>::add(const TYPE& item) {
1.209 + return SortedVectorImpl::add(&item);
1.210 +}
1.211 +
1.212 +template<class TYPE> inline
1.213 +ssize_t SortedVector<TYPE>::indexOf(const TYPE& item) const {
1.214 + return SortedVectorImpl::indexOf(&item);
1.215 +}
1.216 +
1.217 +template<class TYPE> inline
1.218 +size_t SortedVector<TYPE>::orderOf(const TYPE& item) const {
1.219 + return SortedVectorImpl::orderOf(&item);
1.220 +}
1.221 +
1.222 +template<class TYPE> inline
1.223 +ssize_t SortedVector<TYPE>::merge(const Vector<TYPE>& vector) {
1.224 + return SortedVectorImpl::merge(reinterpret_cast<const VectorImpl&>(vector));
1.225 +}
1.226 +
1.227 +template<class TYPE> inline
1.228 +ssize_t SortedVector<TYPE>::merge(const SortedVector<TYPE>& vector) {
1.229 + return SortedVectorImpl::merge(reinterpret_cast<const SortedVectorImpl&>(vector));
1.230 +}
1.231 +
1.232 +template<class TYPE> inline
1.233 +ssize_t SortedVector<TYPE>::remove(const TYPE& item) {
1.234 + return SortedVectorImpl::remove(&item);
1.235 +}
1.236 +
1.237 +template<class TYPE> inline
1.238 +ssize_t SortedVector<TYPE>::removeItemsAt(size_t index, size_t count) {
1.239 + return VectorImpl::removeItemsAt(index, count);
1.240 +}
1.241 +
1.242 +// ---------------------------------------------------------------------------
1.243 +
1.244 +template<class TYPE>
1.245 +void SortedVector<TYPE>::do_construct(void* storage, size_t num) const {
1.246 + construct_type( reinterpret_cast<TYPE*>(storage), num );
1.247 +}
1.248 +
1.249 +template<class TYPE>
1.250 +void SortedVector<TYPE>::do_destroy(void* storage, size_t num) const {
1.251 + destroy_type( reinterpret_cast<TYPE*>(storage), num );
1.252 +}
1.253 +
1.254 +template<class TYPE>
1.255 +void SortedVector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
1.256 + copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.257 +}
1.258 +
1.259 +template<class TYPE>
1.260 +void SortedVector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
1.261 + splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
1.262 +}
1.263 +
1.264 +template<class TYPE>
1.265 +void SortedVector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
1.266 + move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.267 +}
1.268 +
1.269 +template<class TYPE>
1.270 +void SortedVector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
1.271 + move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.272 +}
1.273 +
1.274 +template<class TYPE>
1.275 +int SortedVector<TYPE>::do_compare(const void* lhs, const void* rhs) const {
1.276 + return compare_type( *reinterpret_cast<const TYPE*>(lhs), *reinterpret_cast<const TYPE*>(rhs) );
1.277 +}
1.278 +
1.279 +}; // namespace android
1.280 +
1.281 +
1.282 +// ---------------------------------------------------------------------------
1.283 +
1.284 +#endif // ANDROID_SORTED_VECTOR_H
