1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/media/omx-plugin/include/froyo/utils/Vector.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,358 @@
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_VECTOR_H
1.21 +#define ANDROID_VECTOR_H
1.22 +
1.23 +#include <new>
1.24 +#include <stdint.h>
1.25 +#include <sys/types.h>
1.26 +
1.27 +#include <utils/Log.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 +/*!
1.36 + * The main templated vector class ensuring type safety
1.37 + * while making use of VectorImpl.
1.38 + * This is the class users want to use.
1.39 + */
1.40 +
1.41 +template <class TYPE>
1.42 +class Vector : private VectorImpl
1.43 +{
1.44 +public:
1.45 + typedef TYPE value_type;
1.46 +
1.47 + /*!
1.48 + * Constructors and destructors
1.49 + */
1.50 +
1.51 + Vector();
1.52 + Vector(const Vector<TYPE>& rhs);
1.53 + virtual ~Vector();
1.54 +
1.55 + /*! copy operator */
1.56 + const Vector<TYPE>& operator = (const Vector<TYPE>& rhs) const;
1.57 + Vector<TYPE>& operator = (const Vector<TYPE>& rhs);
1.58 +
1.59 + /*
1.60 + * empty the vector
1.61 + */
1.62 +
1.63 + inline void clear() { VectorImpl::clear(); }
1.64 +
1.65 + /*!
1.66 + * vector stats
1.67 + */
1.68 +
1.69 + //! returns number of items in the vector
1.70 + inline size_t size() const { return VectorImpl::size(); }
1.71 + //! returns wether or not the vector is empty
1.72 + inline bool isEmpty() const { return VectorImpl::isEmpty(); }
1.73 + //! returns how many items can be stored without reallocating the backing store
1.74 + inline size_t capacity() const { return VectorImpl::capacity(); }
1.75 + //! setst the capacity. capacity can never be reduced less than size()
1.76 + inline ssize_t setCapacity(size_t size) { return VectorImpl::setCapacity(size); }
1.77 +
1.78 + /*!
1.79 + * C-style array access
1.80 + */
1.81 +
1.82 + //! read-only C-style access
1.83 + inline const TYPE* array() const;
1.84 + //! read-write C-style access
1.85 + TYPE* editArray();
1.86 +
1.87 + /*!
1.88 + * accessors
1.89 + */
1.90 +
1.91 + //! read-only access to an item at a given index
1.92 + inline const TYPE& operator [] (size_t index) const;
1.93 + //! alternate name for operator []
1.94 + inline const TYPE& itemAt(size_t index) const;
1.95 + //! stack-usage of the vector. returns the top of the stack (last element)
1.96 + const TYPE& top() const;
1.97 + //! same as operator [], but allows to access the vector backward (from the end) with a negative index
1.98 + const TYPE& mirrorItemAt(ssize_t index) const;
1.99 +
1.100 + /*!
1.101 + * modifing the array
1.102 + */
1.103 +
1.104 + //! copy-on write support, grants write access to an item
1.105 + TYPE& editItemAt(size_t index);
1.106 + //! grants right acces to the top of the stack (last element)
1.107 + TYPE& editTop();
1.108 +
1.109 + /*!
1.110 + * append/insert another vector
1.111 + */
1.112 +
1.113 + //! insert another vector at a given index
1.114 + ssize_t insertVectorAt(const Vector<TYPE>& vector, size_t index);
1.115 +
1.116 + //! append another vector at the end of this one
1.117 + ssize_t appendVector(const Vector<TYPE>& vector);
1.118 +
1.119 +
1.120 + /*!
1.121 + * add/insert/replace items
1.122 + */
1.123 +
1.124 + //! insert one or several items initialized with their default constructor
1.125 + inline ssize_t insertAt(size_t index, size_t numItems = 1);
1.126 + //! insert on onr several items initialized from a prototype item
1.127 + ssize_t insertAt(const TYPE& prototype_item, size_t index, size_t numItems = 1);
1.128 + //! pop the top of the stack (removes the last element). No-op if the stack's empty
1.129 + inline void pop();
1.130 + //! pushes an item initialized with its default constructor
1.131 + inline void push();
1.132 + //! pushes an item on the top of the stack
1.133 + void push(const TYPE& item);
1.134 + //! same as push() but returns the index the item was added at (or an error)
1.135 + inline ssize_t add();
1.136 + //! same as push() but returns the index the item was added at (or an error)
1.137 + ssize_t add(const TYPE& item);
1.138 + //! replace an item with a new one initialized with its default constructor
1.139 + inline ssize_t replaceAt(size_t index);
1.140 + //! replace an item with a new one
1.141 + ssize_t replaceAt(const TYPE& item, size_t index);
1.142 +
1.143 + /*!
1.144 + * remove items
1.145 + */
1.146 +
1.147 + //! remove several items
1.148 + inline ssize_t removeItemsAt(size_t index, size_t count = 1);
1.149 + //! remove one item
1.150 + inline ssize_t removeAt(size_t index) { return removeItemsAt(index); }
1.151 +
1.152 + /*!
1.153 + * sort (stable) the array
1.154 + */
1.155 +
1.156 + typedef int (*compar_t)(const TYPE* lhs, const TYPE* rhs);
1.157 + typedef int (*compar_r_t)(const TYPE* lhs, const TYPE* rhs, void* state);
1.158 +
1.159 + inline status_t sort(compar_t cmp);
1.160 + inline status_t sort(compar_r_t cmp, void* state);
1.161 +
1.162 +protected:
1.163 + virtual void do_construct(void* storage, size_t num) const;
1.164 + virtual void do_destroy(void* storage, size_t num) const;
1.165 + virtual void do_copy(void* dest, const void* from, size_t num) const;
1.166 + virtual void do_splat(void* dest, const void* item, size_t num) const;
1.167 + virtual void do_move_forward(void* dest, const void* from, size_t num) const;
1.168 + virtual void do_move_backward(void* dest, const void* from, size_t num) const;
1.169 +};
1.170 +
1.171 +
1.172 +// ---------------------------------------------------------------------------
1.173 +// No user serviceable parts from here...
1.174 +// ---------------------------------------------------------------------------
1.175 +
1.176 +template<class TYPE> inline
1.177 +Vector<TYPE>::Vector()
1.178 + : VectorImpl(sizeof(TYPE),
1.179 + ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
1.180 + |(traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
1.181 + |(traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))
1.182 + )
1.183 +{
1.184 +}
1.185 +
1.186 +template<class TYPE> inline
1.187 +Vector<TYPE>::Vector(const Vector<TYPE>& rhs)
1.188 + : VectorImpl(rhs) {
1.189 +}
1.190 +
1.191 +template<class TYPE> inline
1.192 +Vector<TYPE>::~Vector() {
1.193 + finish_vector();
1.194 +}
1.195 +
1.196 +template<class TYPE> inline
1.197 +Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) {
1.198 + VectorImpl::operator = (rhs);
1.199 + return *this;
1.200 +}
1.201 +
1.202 +template<class TYPE> inline
1.203 +const Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) const {
1.204 + VectorImpl::operator = (rhs);
1.205 + return *this;
1.206 +}
1.207 +
1.208 +template<class TYPE> inline
1.209 +const TYPE* Vector<TYPE>::array() const {
1.210 + return static_cast<const TYPE *>(arrayImpl());
1.211 +}
1.212 +
1.213 +template<class TYPE> inline
1.214 +TYPE* Vector<TYPE>::editArray() {
1.215 + return static_cast<TYPE *>(editArrayImpl());
1.216 +}
1.217 +
1.218 +
1.219 +template<class TYPE> inline
1.220 +const TYPE& Vector<TYPE>::operator[](size_t index) const {
1.221 + LOG_FATAL_IF( index>=size(),
1.222 + "itemAt: index %d is past size %d", (int)index, (int)size() );
1.223 + return *(array() + index);
1.224 +}
1.225 +
1.226 +template<class TYPE> inline
1.227 +const TYPE& Vector<TYPE>::itemAt(size_t index) const {
1.228 + return operator[](index);
1.229 +}
1.230 +
1.231 +template<class TYPE> inline
1.232 +const TYPE& Vector<TYPE>::mirrorItemAt(ssize_t index) const {
1.233 + LOG_FATAL_IF( (index>0 ? index : -index)>=size(),
1.234 + "mirrorItemAt: index %d is past size %d",
1.235 + (int)index, (int)size() );
1.236 + return *(array() + ((index<0) ? (size()-index) : index));
1.237 +}
1.238 +
1.239 +template<class TYPE> inline
1.240 +const TYPE& Vector<TYPE>::top() const {
1.241 + return *(array() + size() - 1);
1.242 +}
1.243 +
1.244 +template<class TYPE> inline
1.245 +TYPE& Vector<TYPE>::editItemAt(size_t index) {
1.246 + return *( static_cast<TYPE *>(editItemLocation(index)) );
1.247 +}
1.248 +
1.249 +template<class TYPE> inline
1.250 +TYPE& Vector<TYPE>::editTop() {
1.251 + return *( static_cast<TYPE *>(editItemLocation(size()-1)) );
1.252 +}
1.253 +
1.254 +template<class TYPE> inline
1.255 +ssize_t Vector<TYPE>::insertVectorAt(const Vector<TYPE>& vector, size_t index) {
1.256 + return VectorImpl::insertVectorAt(reinterpret_cast<const VectorImpl&>(vector), index);
1.257 +}
1.258 +
1.259 +template<class TYPE> inline
1.260 +ssize_t Vector<TYPE>::appendVector(const Vector<TYPE>& vector) {
1.261 + return VectorImpl::appendVector(reinterpret_cast<const VectorImpl&>(vector));
1.262 +}
1.263 +
1.264 +template<class TYPE> inline
1.265 +ssize_t Vector<TYPE>::insertAt(const TYPE& item, size_t index, size_t numItems) {
1.266 + return VectorImpl::insertAt(&item, index, numItems);
1.267 +}
1.268 +
1.269 +template<class TYPE> inline
1.270 +void Vector<TYPE>::push(const TYPE& item) {
1.271 + return VectorImpl::push(&item);
1.272 +}
1.273 +
1.274 +template<class TYPE> inline
1.275 +ssize_t Vector<TYPE>::add(const TYPE& item) {
1.276 + return VectorImpl::add(&item);
1.277 +}
1.278 +
1.279 +template<class TYPE> inline
1.280 +ssize_t Vector<TYPE>::replaceAt(const TYPE& item, size_t index) {
1.281 + return VectorImpl::replaceAt(&item, index);
1.282 +}
1.283 +
1.284 +template<class TYPE> inline
1.285 +ssize_t Vector<TYPE>::insertAt(size_t index, size_t numItems) {
1.286 + return VectorImpl::insertAt(index, numItems);
1.287 +}
1.288 +
1.289 +template<class TYPE> inline
1.290 +void Vector<TYPE>::pop() {
1.291 + VectorImpl::pop();
1.292 +}
1.293 +
1.294 +template<class TYPE> inline
1.295 +void Vector<TYPE>::push() {
1.296 + VectorImpl::push();
1.297 +}
1.298 +
1.299 +template<class TYPE> inline
1.300 +ssize_t Vector<TYPE>::add() {
1.301 + return VectorImpl::add();
1.302 +}
1.303 +
1.304 +template<class TYPE> inline
1.305 +ssize_t Vector<TYPE>::replaceAt(size_t index) {
1.306 + return VectorImpl::replaceAt(index);
1.307 +}
1.308 +
1.309 +template<class TYPE> inline
1.310 +ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
1.311 + return VectorImpl::removeItemsAt(index, count);
1.312 +}
1.313 +
1.314 +template<class TYPE> inline
1.315 +status_t Vector<TYPE>::sort(Vector<TYPE>::compar_t cmp) {
1.316 + return VectorImpl::sort((VectorImpl::compar_t)cmp);
1.317 +}
1.318 +
1.319 +template<class TYPE> inline
1.320 +status_t Vector<TYPE>::sort(Vector<TYPE>::compar_r_t cmp, void* state) {
1.321 + return VectorImpl::sort((VectorImpl::compar_r_t)cmp, state);
1.322 +}
1.323 +
1.324 +// ---------------------------------------------------------------------------
1.325 +
1.326 +template<class TYPE>
1.327 +void Vector<TYPE>::do_construct(void* storage, size_t num) const {
1.328 + construct_type( reinterpret_cast<TYPE*>(storage), num );
1.329 +}
1.330 +
1.331 +template<class TYPE>
1.332 +void Vector<TYPE>::do_destroy(void* storage, size_t num) const {
1.333 + destroy_type( reinterpret_cast<TYPE*>(storage), num );
1.334 +}
1.335 +
1.336 +template<class TYPE>
1.337 +void Vector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
1.338 + copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.339 +}
1.340 +
1.341 +template<class TYPE>
1.342 +void Vector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
1.343 + splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
1.344 +}
1.345 +
1.346 +template<class TYPE>
1.347 +void Vector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
1.348 + move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.349 +}
1.350 +
1.351 +template<class TYPE>
1.352 +void Vector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
1.353 + move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.354 +}
1.355 +
1.356 +}; // namespace android
1.357 +
1.358 +
1.359 +// ---------------------------------------------------------------------------
1.360 +
1.361 +#endif // ANDROID_VECTOR_H
