1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/media/omx-plugin/include/ics/utils/Vector.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,424 @@
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 <cutils/log.h>
1.28 +
1.29 +#include <utils/VectorImpl.h>
1.30 +#include <utils/TypeHelpers.h>
1.31 +
1.32 +// ---------------------------------------------------------------------------
1.33 +
1.34 +namespace android {
1.35 +
1.36 +template <typename TYPE>
1.37 +class SortedVector;
1.38 +
1.39 +/*!
1.40 + * The main templated vector class ensuring type safety
1.41 + * while making use of VectorImpl.
1.42 + * This is the class users want to use.
1.43 + */
1.44 +
1.45 +template <class TYPE>
1.46 +class Vector : private VectorImpl
1.47 +{
1.48 +public:
1.49 + typedef TYPE value_type;
1.50 +
1.51 + /*!
1.52 + * Constructors and destructors
1.53 + */
1.54 +
1.55 + Vector();
1.56 + Vector(const Vector<TYPE>& rhs);
1.57 + explicit Vector(const SortedVector<TYPE>& rhs);
1.58 + virtual ~Vector();
1.59 +
1.60 + /*! copy operator */
1.61 + const Vector<TYPE>& operator = (const Vector<TYPE>& rhs) const;
1.62 + Vector<TYPE>& operator = (const Vector<TYPE>& rhs);
1.63 +
1.64 + const Vector<TYPE>& operator = (const SortedVector<TYPE>& rhs) const;
1.65 + Vector<TYPE>& operator = (const SortedVector<TYPE>& rhs);
1.66 +
1.67 + /*
1.68 + * empty the vector
1.69 + */
1.70 +
1.71 + inline void clear() { VectorImpl::clear(); }
1.72 +
1.73 + /*!
1.74 + * vector stats
1.75 + */
1.76 +
1.77 + //! returns number of items in the vector
1.78 + inline size_t size() const { return VectorImpl::size(); }
1.79 + //! returns whether or not the vector is empty
1.80 + inline bool isEmpty() const { return VectorImpl::isEmpty(); }
1.81 + //! returns how many items can be stored without reallocating the backing store
1.82 + inline size_t capacity() const { return VectorImpl::capacity(); }
1.83 + //! sets the capacity. capacity can never be reduced less than size()
1.84 + inline ssize_t setCapacity(size_t size) { return VectorImpl::setCapacity(size); }
1.85 +
1.86 + /*!
1.87 + * set the size of the vector. items are appended with the default
1.88 + * constructor, or removed from the end as needed.
1.89 + */
1.90 + inline ssize_t resize(size_t size) { return VectorImpl::resize(size); }
1.91 +
1.92 + /*!
1.93 + * C-style array access
1.94 + */
1.95 +
1.96 + //! read-only C-style access
1.97 + inline const TYPE* array() const;
1.98 + //! read-write C-style access
1.99 + TYPE* editArray();
1.100 +
1.101 + /*!
1.102 + * accessors
1.103 + */
1.104 +
1.105 + //! read-only access to an item at a given index
1.106 + inline const TYPE& operator [] (size_t index) const;
1.107 + //! alternate name for operator []
1.108 + inline const TYPE& itemAt(size_t index) const;
1.109 + //! stack-usage of the vector. returns the top of the stack (last element)
1.110 + const TYPE& top() const;
1.111 +
1.112 + /*!
1.113 + * modifying the array
1.114 + */
1.115 +
1.116 + //! copy-on write support, grants write access to an item
1.117 + TYPE& editItemAt(size_t index);
1.118 + //! grants right access to the top of the stack (last element)
1.119 + TYPE& editTop();
1.120 +
1.121 + /*!
1.122 + * append/insert another vector
1.123 + */
1.124 +
1.125 + //! insert another vector at a given index
1.126 + ssize_t insertVectorAt(const Vector<TYPE>& vector, size_t index);
1.127 +
1.128 + //! append another vector at the end of this one
1.129 + ssize_t appendVector(const Vector<TYPE>& vector);
1.130 +
1.131 +
1.132 + //! insert an array at a given index
1.133 + ssize_t insertArrayAt(const TYPE* array, size_t index, size_t length);
1.134 +
1.135 + //! append an array at the end of this vector
1.136 + ssize_t appendArray(const TYPE* array, size_t length);
1.137 +
1.138 + /*!
1.139 + * add/insert/replace items
1.140 + */
1.141 +
1.142 + //! insert one or several items initialized with their default constructor
1.143 + inline ssize_t insertAt(size_t index, size_t numItems = 1);
1.144 + //! insert one or several items initialized from a prototype item
1.145 + ssize_t insertAt(const TYPE& prototype_item, size_t index, size_t numItems = 1);
1.146 + //! pop the top of the stack (removes the last element). No-op if the stack's empty
1.147 + inline void pop();
1.148 + //! pushes an item initialized with its default constructor
1.149 + inline void push();
1.150 + //! pushes an item on the top of the stack
1.151 + void push(const TYPE& item);
1.152 + //! same as push() but returns the index the item was added at (or an error)
1.153 + inline ssize_t add();
1.154 + //! same as push() but returns the index the item was added at (or an error)
1.155 + ssize_t add(const TYPE& item);
1.156 + //! replace an item with a new one initialized with its default constructor
1.157 + inline ssize_t replaceAt(size_t index);
1.158 + //! replace an item with a new one
1.159 + ssize_t replaceAt(const TYPE& item, size_t index);
1.160 +
1.161 + /*!
1.162 + * remove items
1.163 + */
1.164 +
1.165 + //! remove several items
1.166 + inline ssize_t removeItemsAt(size_t index, size_t count = 1);
1.167 + //! remove one item
1.168 + inline ssize_t removeAt(size_t index) { return removeItemsAt(index); }
1.169 +
1.170 + /*!
1.171 + * sort (stable) the array
1.172 + */
1.173 +
1.174 + typedef int (*compar_t)(const TYPE* lhs, const TYPE* rhs);
1.175 + typedef int (*compar_r_t)(const TYPE* lhs, const TYPE* rhs, void* state);
1.176 +
1.177 + inline status_t sort(compar_t cmp);
1.178 + inline status_t sort(compar_r_t cmp, void* state);
1.179 +
1.180 + // for debugging only
1.181 + inline size_t getItemSize() const { return itemSize(); }
1.182 +
1.183 +
1.184 + /*
1.185 + * these inlines add some level of compatibility with STL. eventually
1.186 + * we should probably turn things around.
1.187 + */
1.188 + typedef TYPE* iterator;
1.189 + typedef TYPE const* const_iterator;
1.190 +
1.191 + inline iterator begin() { return editArray(); }
1.192 + inline iterator end() { return editArray() + size(); }
1.193 + inline const_iterator begin() const { return array(); }
1.194 + inline const_iterator end() const { return array() + size(); }
1.195 + inline void reserve(size_t n) { setCapacity(n); }
1.196 + inline bool empty() const{ return isEmpty(); }
1.197 + inline void push_back(const TYPE& item) { insertAt(item, size(), 1); }
1.198 + inline void push_front(const TYPE& item) { insertAt(item, 0, 1); }
1.199 + inline iterator erase(iterator pos) {
1.200 + ssize_t index = removeItemsAt(pos-array());
1.201 + return begin() + index;
1.202 + }
1.203 +
1.204 +protected:
1.205 + virtual void do_construct(void* storage, size_t num) const;
1.206 + virtual void do_destroy(void* storage, size_t num) const;
1.207 + virtual void do_copy(void* dest, const void* from, size_t num) const;
1.208 + virtual void do_splat(void* dest, const void* item, size_t num) const;
1.209 + virtual void do_move_forward(void* dest, const void* from, size_t num) const;
1.210 + virtual void do_move_backward(void* dest, const void* from, size_t num) const;
1.211 +};
1.212 +
1.213 +// Vector<T> can be trivially moved using memcpy() because moving does not
1.214 +// require any change to the underlying SharedBuffer contents or reference count.
1.215 +template<typename T> struct trait_trivial_move<Vector<T> > { enum { value = true }; };
1.216 +
1.217 +// ---------------------------------------------------------------------------
1.218 +// No user serviceable parts from here...
1.219 +// ---------------------------------------------------------------------------
1.220 +
1.221 +template<class TYPE> inline
1.222 +Vector<TYPE>::Vector()
1.223 + : VectorImpl(sizeof(TYPE),
1.224 + ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
1.225 + |(traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
1.226 + |(traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))
1.227 + )
1.228 +{
1.229 +}
1.230 +
1.231 +template<class TYPE> inline
1.232 +Vector<TYPE>::Vector(const Vector<TYPE>& rhs)
1.233 + : VectorImpl(rhs) {
1.234 +}
1.235 +
1.236 +template<class TYPE> inline
1.237 +Vector<TYPE>::Vector(const SortedVector<TYPE>& rhs)
1.238 + : VectorImpl(static_cast<const VectorImpl&>(rhs)) {
1.239 +}
1.240 +
1.241 +template<class TYPE> inline
1.242 +Vector<TYPE>::~Vector() {
1.243 + finish_vector();
1.244 +}
1.245 +
1.246 +template<class TYPE> inline
1.247 +Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) {
1.248 + VectorImpl::operator = (rhs);
1.249 + return *this;
1.250 +}
1.251 +
1.252 +template<class TYPE> inline
1.253 +const Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) const {
1.254 + VectorImpl::operator = (static_cast<const VectorImpl&>(rhs));
1.255 + return *this;
1.256 +}
1.257 +
1.258 +template<class TYPE> inline
1.259 +Vector<TYPE>& Vector<TYPE>::operator = (const SortedVector<TYPE>& rhs) {
1.260 + VectorImpl::operator = (static_cast<const VectorImpl&>(rhs));
1.261 + return *this;
1.262 +}
1.263 +
1.264 +template<class TYPE> inline
1.265 +const Vector<TYPE>& Vector<TYPE>::operator = (const SortedVector<TYPE>& rhs) const {
1.266 + VectorImpl::operator = (rhs);
1.267 + return *this;
1.268 +}
1.269 +
1.270 +template<class TYPE> inline
1.271 +const TYPE* Vector<TYPE>::array() const {
1.272 + return static_cast<const TYPE *>(arrayImpl());
1.273 +}
1.274 +
1.275 +template<class TYPE> inline
1.276 +TYPE* Vector<TYPE>::editArray() {
1.277 + return static_cast<TYPE *>(editArrayImpl());
1.278 +}
1.279 +
1.280 +
1.281 +template<class TYPE> inline
1.282 +const TYPE& Vector<TYPE>::operator[](size_t index) const {
1.283 + LOG_FATAL_IF(index>=size(),
1.284 + "%s: index=%u out of range (%u)", __PRETTY_FUNCTION__,
1.285 + int(index), int(size()));
1.286 + return *(array() + index);
1.287 +}
1.288 +
1.289 +template<class TYPE> inline
1.290 +const TYPE& Vector<TYPE>::itemAt(size_t index) const {
1.291 + return operator[](index);
1.292 +}
1.293 +
1.294 +template<class TYPE> inline
1.295 +const TYPE& Vector<TYPE>::top() const {
1.296 + return *(array() + size() - 1);
1.297 +}
1.298 +
1.299 +template<class TYPE> inline
1.300 +TYPE& Vector<TYPE>::editItemAt(size_t index) {
1.301 + return *( static_cast<TYPE *>(editItemLocation(index)) );
1.302 +}
1.303 +
1.304 +template<class TYPE> inline
1.305 +TYPE& Vector<TYPE>::editTop() {
1.306 + return *( static_cast<TYPE *>(editItemLocation(size()-1)) );
1.307 +}
1.308 +
1.309 +template<class TYPE> inline
1.310 +ssize_t Vector<TYPE>::insertVectorAt(const Vector<TYPE>& vector, size_t index) {
1.311 + return VectorImpl::insertVectorAt(reinterpret_cast<const VectorImpl&>(vector), index);
1.312 +}
1.313 +
1.314 +template<class TYPE> inline
1.315 +ssize_t Vector<TYPE>::appendVector(const Vector<TYPE>& vector) {
1.316 + return VectorImpl::appendVector(reinterpret_cast<const VectorImpl&>(vector));
1.317 +}
1.318 +
1.319 +template<class TYPE> inline
1.320 +ssize_t Vector<TYPE>::insertArrayAt(const TYPE* array, size_t index, size_t length) {
1.321 + return VectorImpl::insertArrayAt(array, index, length);
1.322 +}
1.323 +
1.324 +template<class TYPE> inline
1.325 +ssize_t Vector<TYPE>::appendArray(const TYPE* array, size_t length) {
1.326 + return VectorImpl::appendArray(array, length);
1.327 +}
1.328 +
1.329 +template<class TYPE> inline
1.330 +ssize_t Vector<TYPE>::insertAt(const TYPE& item, size_t index, size_t numItems) {
1.331 + return VectorImpl::insertAt(&item, index, numItems);
1.332 +}
1.333 +
1.334 +template<class TYPE> inline
1.335 +void Vector<TYPE>::push(const TYPE& item) {
1.336 + return VectorImpl::push(&item);
1.337 +}
1.338 +
1.339 +template<class TYPE> inline
1.340 +ssize_t Vector<TYPE>::add(const TYPE& item) {
1.341 + return VectorImpl::add(&item);
1.342 +}
1.343 +
1.344 +template<class TYPE> inline
1.345 +ssize_t Vector<TYPE>::replaceAt(const TYPE& item, size_t index) {
1.346 + return VectorImpl::replaceAt(&item, index);
1.347 +}
1.348 +
1.349 +template<class TYPE> inline
1.350 +ssize_t Vector<TYPE>::insertAt(size_t index, size_t numItems) {
1.351 + return VectorImpl::insertAt(index, numItems);
1.352 +}
1.353 +
1.354 +template<class TYPE> inline
1.355 +void Vector<TYPE>::pop() {
1.356 + VectorImpl::pop();
1.357 +}
1.358 +
1.359 +template<class TYPE> inline
1.360 +void Vector<TYPE>::push() {
1.361 + VectorImpl::push();
1.362 +}
1.363 +
1.364 +template<class TYPE> inline
1.365 +ssize_t Vector<TYPE>::add() {
1.366 + return VectorImpl::add();
1.367 +}
1.368 +
1.369 +template<class TYPE> inline
1.370 +ssize_t Vector<TYPE>::replaceAt(size_t index) {
1.371 + return VectorImpl::replaceAt(index);
1.372 +}
1.373 +
1.374 +template<class TYPE> inline
1.375 +ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
1.376 + return VectorImpl::removeItemsAt(index, count);
1.377 +}
1.378 +
1.379 +template<class TYPE> inline
1.380 +status_t Vector<TYPE>::sort(Vector<TYPE>::compar_t cmp) {
1.381 + return VectorImpl::sort((VectorImpl::compar_t)cmp);
1.382 +}
1.383 +
1.384 +template<class TYPE> inline
1.385 +status_t Vector<TYPE>::sort(Vector<TYPE>::compar_r_t cmp, void* state) {
1.386 + return VectorImpl::sort((VectorImpl::compar_r_t)cmp, state);
1.387 +}
1.388 +
1.389 +// ---------------------------------------------------------------------------
1.390 +
1.391 +template<class TYPE>
1.392 +void Vector<TYPE>::do_construct(void* storage, size_t num) const {
1.393 + construct_type( reinterpret_cast<TYPE*>(storage), num );
1.394 +}
1.395 +
1.396 +template<class TYPE>
1.397 +void Vector<TYPE>::do_destroy(void* storage, size_t num) const {
1.398 + destroy_type( reinterpret_cast<TYPE*>(storage), num );
1.399 +}
1.400 +
1.401 +template<class TYPE>
1.402 +void Vector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
1.403 + copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.404 +}
1.405 +
1.406 +template<class TYPE>
1.407 +void Vector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
1.408 + splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
1.409 +}
1.410 +
1.411 +template<class TYPE>
1.412 +void Vector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
1.413 + move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.414 +}
1.415 +
1.416 +template<class TYPE>
1.417 +void Vector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
1.418 + move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
1.419 +}
1.420 +
1.421 +}; // namespace android
1.422 +
1.423 +
1.424 +// ---------------------------------------------------------------------------
1.425 +
1.426 +#endif // ANDROID_VECTOR_H
1.427 +
