1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/media/omx-plugin/include/gb/utils/Vector.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,374 @@
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 + //! insert an array at a given index
1.121 + ssize_t insertArrayAt(const TYPE* array, size_t index, size_t length);
1.122 +
1.123 + //! append an array at the end of this vector
1.124 + ssize_t appendArray(const TYPE* array, size_t length);
1.125 +
1.126 + /*!
1.127 + * add/insert/replace items
1.128 + */
1.129 +
1.130 + //! insert one or several items initialized with their default constructor
1.131 + inline ssize_t insertAt(size_t index, size_t numItems = 1);
1.132 + //! insert one or several items initialized from a prototype item
1.133 + ssize_t insertAt(const TYPE& prototype_item, size_t index, size_t numItems = 1);
1.134 + //! pop the top of the stack (removes the last element). No-op if the stack's empty
1.135 + inline void pop();
1.136 + //! pushes an item initialized with its default constructor
1.137 + inline void push();
1.138 + //! pushes an item on the top of the stack
1.139 + void push(const TYPE& item);
1.140 + //! same as push() but returns the index the item was added at (or an error)
1.141 + inline ssize_t add();
1.142 + //! same as push() but returns the index the item was added at (or an error)
1.143 + ssize_t add(const TYPE& item);
1.144 + //! replace an item with a new one initialized with its default constructor
1.145 + inline ssize_t replaceAt(size_t index);
1.146 + //! replace an item with a new one
1.147 + ssize_t replaceAt(const TYPE& item, size_t index);
1.148 +
1.149 + /*!
1.150 + * remove items
1.151 + */
1.152 +
1.153 + //! remove several items
1.154 + inline ssize_t removeItemsAt(size_t index, size_t count = 1);
1.155 + //! remove one item
1.156 + inline ssize_t removeAt(size_t index) { return removeItemsAt(index); }
1.157 +
1.158 + /*!
1.159 + * sort (stable) the array
1.160 + */
1.161 +
1.162 + typedef int (*compar_t)(const TYPE* lhs, const TYPE* rhs);
1.163 + typedef int (*compar_r_t)(const TYPE* lhs, const TYPE* rhs, void* state);
1.164 +
1.165 + inline status_t sort(compar_t cmp);
1.166 + inline status_t sort(compar_r_t cmp, void* state);
1.167 +
1.168 +protected:
1.169 + virtual void do_construct(void* storage, size_t num) const;
1.170 + virtual void do_destroy(void* storage, size_t num) const;
1.171 + virtual void do_copy(void* dest, const void* from, size_t num) const;
1.172 + virtual void do_splat(void* dest, const void* item, size_t num) const;
1.173 + virtual void do_move_forward(void* dest, const void* from, size_t num) const;
1.174 + virtual void do_move_backward(void* dest, const void* from, size_t num) const;
1.175 +};
1.176 +
1.177 +
1.178 +// ---------------------------------------------------------------------------
1.179 +// No user serviceable parts from here...
1.180 +// ---------------------------------------------------------------------------
1.181 +
1.182 +template<class TYPE> inline
1.183 +Vector<TYPE>::Vector()
1.184 + : VectorImpl(sizeof(TYPE),
1.185 + ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
1.186 + |(traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
1.187 + |(traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))
1.188 + )
1.189 +{
1.190 +}
1.191 +
1.192 +template<class TYPE> inline
1.193 +Vector<TYPE>::Vector(const Vector<TYPE>& rhs)
1.194 + : VectorImpl(rhs) {
1.195 +}
1.196 +
1.197 +template<class TYPE> inline
1.198 +Vector<TYPE>::~Vector() {
1.199 + finish_vector();
1.200 +}
1.201 +
1.202 +template<class TYPE> inline
1.203 +Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) {
1.204 + VectorImpl::operator = (rhs);
1.205 + return *this;
1.206 +}
1.207 +
1.208 +template<class TYPE> inline
1.209 +const Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) const {
1.210 + VectorImpl::operator = (rhs);
1.211 + return *this;
1.212 +}
1.213 +
1.214 +template<class TYPE> inline
1.215 +const TYPE* Vector<TYPE>::array() const {
1.216 + return static_cast<const TYPE *>(arrayImpl());
1.217 +}
1.218 +
1.219 +template<class TYPE> inline
1.220 +TYPE* Vector<TYPE>::editArray() {
1.221 + return static_cast<TYPE *>(editArrayImpl());
1.222 +}
1.223 +
1.224 +
1.225 +template<class TYPE> inline
1.226 +const TYPE& Vector<TYPE>::operator[](size_t index) const {
1.227 + LOG_FATAL_IF( index>=size(),
1.228 + "itemAt: index %d is past size %d", (int)index, (int)size() );
1.229 + return *(array() + index);
1.230 +}
1.231 +
1.232 +template<class TYPE> inline
1.233 +const TYPE& Vector<TYPE>::itemAt(size_t index) const {
1.234 + return operator[](index);
1.235 +}
1.236 +
1.237 +template<class TYPE> inline
1.238 +const TYPE& Vector<TYPE>::mirrorItemAt(ssize_t index) const {
1.239 + LOG_FATAL_IF( (index>0 ? index : -index)>=size(),
1.240 + "mirrorItemAt: index %d is past size %d",
1.241 + (int)index, (int)size() );
1.242 + return *(array() + ((index<0) ? (size()-index) : index));
1.243 +}
1.244 +
1.245 +template<class TYPE> inline
1.246 +const TYPE& Vector<TYPE>::top() const {
1.247 + return *(array() + size() - 1);
1.248 +}
1.249 +
1.250 +template<class TYPE> inline
1.251 +TYPE& Vector<TYPE>::editItemAt(size_t index) {
1.252 + return *( static_cast<TYPE *>(editItemLocation(index)) );
1.253 +}
1.254 +
1.255 +template<class TYPE> inline
1.256 +TYPE& Vector<TYPE>::editTop() {
1.257 + return *( static_cast<TYPE *>(editItemLocation(size()-1)) );
1.258 +}
1.259 +
1.260 +template<class TYPE> inline
1.261 +ssize_t Vector<TYPE>::insertVectorAt(const Vector<TYPE>& vector, size_t index) {
1.262 + return VectorImpl::insertVectorAt(reinterpret_cast<const VectorImpl&>(vector), index);
1.263 +}
1.264 +
1.265 +template<class TYPE> inline
1.266 +ssize_t Vector<TYPE>::appendVector(const Vector<TYPE>& vector) {
1.267 + return VectorImpl::appendVector(reinterpret_cast<const VectorImpl&>(vector));
1.268 +}
1.269 +
1.270 +template<class TYPE> inline
1.271 +ssize_t Vector<TYPE>::insertArrayAt(const TYPE* array, size_t index, size_t length) {
1.272 + return VectorImpl::insertArrayAt(array, index, length);
1.273 +}
1.274 +
1.275 +template<class TYPE> inline
1.276 +ssize_t Vector<TYPE>::appendArray(const TYPE* array, size_t length) {
1.277 + return VectorImpl::appendArray(array, length);
1.278 +}
1.279 +
1.280 +template<class TYPE> inline
1.281 +ssize_t Vector<TYPE>::insertAt(const TYPE& item, size_t index, size_t numItems) {
1.282 + return VectorImpl::insertAt(&item, index, numItems);
1.283 +}
1.284 +
1.285 +template<class TYPE> inline
1.286 +void Vector<TYPE>::push(const TYPE& item) {
1.287 + return VectorImpl::push(&item);
1.288 +}
1.289 +
1.290 +template<class TYPE> inline
1.291 +ssize_t Vector<TYPE>::add(const TYPE& item) {
1.292 + return VectorImpl::add(&item);
1.293 +}
1.294 +
1.295 +template<class TYPE> inline
1.296 +ssize_t Vector<TYPE>::replaceAt(const TYPE& item, size_t index) {
1.297 + return VectorImpl::replaceAt(&item, index);
1.298 +}
1.299 +
1.300 +template<class TYPE> inline
1.301 +ssize_t Vector<TYPE>::insertAt(size_t index, size_t numItems) {
1.302 + return VectorImpl::insertAt(index, numItems);
1.303 +}
1.304 +
1.305 +template<class TYPE> inline
1.306 +void Vector<TYPE>::pop() {
1.307 + VectorImpl::pop();
1.308 +}
1.309 +
1.310 +template<class TYPE> inline
1.311 +void Vector<TYPE>::push() {
1.312 + VectorImpl::push();
1.313 +}
1.314 +
1.315 +template<class TYPE> inline
1.316 +ssize_t Vector<TYPE>::add() {
1.317 + return VectorImpl::add();
1.318 +}
1.319 +
1.320 +template<class TYPE> inline
1.321 +ssize_t Vector<TYPE>::replaceAt(size_t index) {
1.322 + return VectorImpl::replaceAt(index);
1.323 +}
1.324 +
1.325 +template<class TYPE> inline
1.326 +ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
1.327 + return VectorImpl::removeItemsAt(index, count);
1.328 +}
1.329 +
1.330 +template<class TYPE> inline
1.331 +status_t Vector<TYPE>::sort(Vector<TYPE>::compar_t cmp) {
1.332 + return VectorImpl::sort((VectorImpl::compar_t)cmp);
1.333 +}
1.334 +
1.335 +template<class TYPE> inline
1.336 +status_t Vector<TYPE>::sort(Vector<TYPE>::compar_r_t cmp, void* state) {
1.337 + return VectorImpl::sort((VectorImpl::compar_r_t)cmp, state);
1.338 +}
1.339 +
1.340 +// ---------------------------------------------------------------------------
1.341 +
1.342 +template<class TYPE>
1.343 +void Vector<TYPE>::do_construct(void* storage, size_t num) const {
1.344 + construct_type( reinterpret_cast<TYPE*>(storage), num );
1.345 +}
1.346 +
1.347 +template<class TYPE>
1.348 +void Vector<TYPE>::do_destroy(void* storage, size_t num) const {
1.349 + destroy_type( reinterpret_cast<TYPE*>(storage), num );
1.350 +}
1.351 +
1.352 +template<class TYPE>
1.353 +void Vector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
1.354 + copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.355 +}
1.356 +
1.357 +template<class TYPE>
1.358 +void Vector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
1.359 + splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
1.360 +}
1.361 +
1.362 +template<class TYPE>
1.363 +void Vector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
1.364 + move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.365 +}
1.366 +
1.367 +template<class TYPE>
1.368 +void Vector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
1.369 + move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.370 +}
1.371 +
1.372 +}; // namespace android
1.373 +
1.374 +
1.375 +// ---------------------------------------------------------------------------
1.376 +
1.377 +#endif // ANDROID_VECTOR_H
