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