am 8b48cf61: Merge change 2897 into donut (f6243df7) · Commits · e / os / android_system_core

libpixelflinger/codeflinger/ARMAssembler.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -21,8 +21,9 @@
		#include <stdint.h>
		#include <sys/types.h>

		#include <utils/Vector.h>
		#include <utils/KeyedVector.h>
		#include "tinyutils/Vector.h"
		#include "tinyutils/KeyedVector.h"
		#include "tinyutils/smartpointer.h"

		#include "tinyutils/smartpointer.h"
		#include "codeflinger/ARMAssemblerInterface.h"

libpixelflinger/codeflinger/CodeCache.h

+1 −2

Original line number	Diff line number	Diff line
		@@ -23,8 +23,7 @@
		#include <pthread.h>
		#include <sys/types.h>

		#include <utils/KeyedVector.h>

		#include "tinyutils/KeyedVector.h"
		#include "tinyutils/smartpointer.h"

		namespace android {

libpixelflinger/tinyutils/Errors.h

0 → 100644

+62 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_ERRORS_H
		#define ANDROID_ERRORS_H

		#include <sys/types.h>
		#include <errno.h>

		namespace android {

		// use this type to return error codes
		typedef int32_t status_t;

		/*
		* Error codes.
		* All error codes are negative values.
		*/

		enum {
		OK = 0, // Everything's swell.
		NO_ERROR = 0, // No errors.

		UNKNOWN_ERROR = 0x80000000,

		NO_MEMORY = -ENOMEM,
		INVALID_OPERATION = -ENOSYS,
		BAD_VALUE = -EINVAL,
		BAD_TYPE = 0x80000001,
		NAME_NOT_FOUND = -ENOENT,
		PERMISSION_DENIED = -EPERM,
		NO_INIT = -ENODEV,
		ALREADY_EXISTS = -EEXIST,
		DEAD_OBJECT = -EPIPE,
		FAILED_TRANSACTION = 0x80000002,
		JPARKS_BROKE_IT = -EPIPE,
		BAD_INDEX = -EOVERFLOW,
		NOT_ENOUGH_DATA = -ENODATA,
		WOULD_BLOCK = -EWOULDBLOCK,
		TIMED_OUT = -ETIME,
		UNKNOWN_TRANSACTION = -EBADMSG,
		};


		}; // namespace android

		// ---------------------------------------------------------------------------

		#endif // ANDROID_ERRORS_H

libpixelflinger/tinyutils/SortedVector.h

0 → 100644

+282 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2005 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_SORTED_VECTOR_H
		#define ANDROID_SORTED_VECTOR_H

		#include <assert.h>
		#include <stdint.h>
		#include <sys/types.h>

		#include "tinyutils/Vector.h"
		#include "tinyutils/VectorImpl.h"
		#include "tinyutils/TypeHelpers.h"

		// ---------------------------------------------------------------------------

		namespace android {

		template <class TYPE>
		class SortedVector : private SortedVectorImpl
		{
		public:
		typedef TYPE value_type;

		/*!
		* Constructors and destructors
		*/

		SortedVector();
		SortedVector(const SortedVector<TYPE>& rhs);
		virtual ~SortedVector();

		/! copy operator /
		const SortedVector<TYPE>& operator = (const SortedVector<TYPE>& rhs) const;
		SortedVector<TYPE>& operator = (const SortedVector<TYPE>& rhs);

		/*
		* empty the vector
		*/

		inline void clear() { VectorImpl::clear(); }

		/*!
		* vector stats
		*/

		//! returns number of items in the vector
		inline size_t size() const { return VectorImpl::size(); }
		//! returns wether or not the vector is empty
		inline bool isEmpty() const { return VectorImpl::isEmpty(); }
		//! returns how many items can be stored without reallocating the backing store
		inline size_t capacity() const { return VectorImpl::capacity(); }
		//! setst the capacity. capacity can never be reduced less than size()
		inline ssize_t setCapacity(size_t size) { return VectorImpl::setCapacity(size); }

		/*!
		* C-style array access
		*/

		//! read-only C-style access
		inline const TYPE* array() const;

		//! read-write C-style access. BE VERY CAREFUL when modifying the array
		//! you ust keep it sorted! You usually don't use this function.
		TYPE* editArray();

		//! finds the index of an item
		ssize_t indexOf(const TYPE& item) const;

		//! finds where this item should be inserted
		size_t orderOf(const TYPE& item) const;


		/*!
		* accessors
		*/

		//! read-only access to an item at a given index
		inline const TYPE& operator [] (size_t index) const;
		//! alternate name for operator []
		inline const TYPE& itemAt(size_t index) const;
		//! stack-usage of the vector. returns the top of the stack (last element)
		const TYPE& top() const;
		//! same as operator [], but allows to access the vector backward (from the end) with a negative index
		const TYPE& mirrorItemAt(ssize_t index) const;

		/*!
		* modifing the array
		*/

		//! add an item in the right place (and replace the one that is there)
		ssize_t add(const TYPE& item);

		//! editItemAt() MUST NOT change the order of this item
		TYPE& editItemAt(size_t index) {
		return ( static_cast<TYPE >(VectorImpl::editItemLocation(index)) );
		}

		//! merges a vector into this one
		ssize_t merge(const Vector<TYPE>& vector);
		ssize_t merge(const SortedVector<TYPE>& vector);

		//! removes an item
		ssize_t remove(const TYPE&);

		//! remove several items
		inline ssize_t removeItemsAt(size_t index, size_t count = 1);
		//! remove one item
		inline ssize_t removeAt(size_t index) { return removeItemsAt(index); }

		protected:
		virtual void do_construct(void* storage, size_t num) const;
		virtual void do_destroy(void* storage, size_t num) const;
		virtual void do_copy(void* dest, const void* from, size_t num) const;
		virtual void do_splat(void* dest, const void* item, size_t num) const;
		virtual void do_move_forward(void* dest, const void* from, size_t num) const;
		virtual void do_move_backward(void* dest, const void* from, size_t num) const;
		virtual int do_compare(const void* lhs, const void* rhs) const;
		};


		// ---------------------------------------------------------------------------
		// No user serviceable parts from here...
		// ---------------------------------------------------------------------------

		template<class TYPE> inline
		SortedVector<TYPE>::SortedVector()
		: SortedVectorImpl(sizeof(TYPE),
		((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
		\|(traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
		\|(traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0)
		\|(traits<TYPE>::has_trivial_assign ? HAS_TRIVIAL_ASSIGN : 0))
		)
		{
		}

		template<class TYPE> inline
		SortedVector<TYPE>::SortedVector(const SortedVector<TYPE>& rhs)
		: SortedVectorImpl(rhs) {
		}

		template<class TYPE> inline
		SortedVector<TYPE>::~SortedVector() {
		finish_vector();
		}

		template<class TYPE> inline
		SortedVector<TYPE>& SortedVector<TYPE>::operator = (const SortedVector<TYPE>& rhs) {
		SortedVectorImpl::operator = (rhs);
		return *this;
		}

		template<class TYPE> inline
		const SortedVector<TYPE>& SortedVector<TYPE>::operator = (const SortedVector<TYPE>& rhs) const {
		SortedVectorImpl::operator = (rhs);
		return *this;
		}

		template<class TYPE> inline
		const TYPE* SortedVector<TYPE>::array() const {
		return static_cast<const TYPE *>(arrayImpl());
		}

		template<class TYPE> inline
		TYPE* SortedVector<TYPE>::editArray() {
		return static_cast<TYPE *>(editArrayImpl());
		}


		template<class TYPE> inline
		const TYPE& SortedVector<TYPE>::operator[](size_t index) const {
		assert( index<size() );
		return *(array() + index);
		}

		template<class TYPE> inline
		const TYPE& SortedVector<TYPE>::itemAt(size_t index) const {
		return operator[](index);
		}

		template<class TYPE> inline
		const TYPE& SortedVector<TYPE>::mirrorItemAt(ssize_t index) const {
		assert( (index>0 ? index : -index)<size() );
		return *(array() + ((index<0) ? (size()-index) : index));
		}

		template<class TYPE> inline
		const TYPE& SortedVector<TYPE>::top() const {
		return *(array() + size() - 1);
		}

		template<class TYPE> inline
		ssize_t SortedVector<TYPE>::add(const TYPE& item) {
		return SortedVectorImpl::add(&item);
		}

		template<class TYPE> inline
		ssize_t SortedVector<TYPE>::indexOf(const TYPE& item) const {
		return SortedVectorImpl::indexOf(&item);
		}

		template<class TYPE> inline
		size_t SortedVector<TYPE>::orderOf(const TYPE& item) const {
		return SortedVectorImpl::orderOf(&item);
		}

		template<class TYPE> inline
		ssize_t SortedVector<TYPE>::merge(const Vector<TYPE>& vector) {
		return SortedVectorImpl::merge(reinterpret_cast<const VectorImpl&>(vector));
		}

		template<class TYPE> inline
		ssize_t SortedVector<TYPE>::merge(const SortedVector<TYPE>& vector) {
		return SortedVectorImpl::merge(reinterpret_cast<const SortedVectorImpl&>(vector));
		}

		template<class TYPE> inline
		ssize_t SortedVector<TYPE>::remove(const TYPE& item) {
		return SortedVectorImpl::remove(&item);
		}

		template<class TYPE> inline
		ssize_t SortedVector<TYPE>::removeItemsAt(size_t index, size_t count) {
		return VectorImpl::removeItemsAt(index, count);
		}

		// ---------------------------------------------------------------------------

		template<class TYPE>
		void SortedVector<TYPE>::do_construct(void* storage, size_t num) const {
		construct_type( reinterpret_cast<TYPE*>(storage), num );
		}

		template<class TYPE>
		void SortedVector<TYPE>::do_destroy(void* storage, size_t num) const {
		destroy_type( reinterpret_cast<TYPE*>(storage), num );
		}

		template<class TYPE>
		void SortedVector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
		copy_type( reinterpret_cast<TYPE>(dest), reinterpret_cast<const TYPE>(from), num );
		}

		template<class TYPE>
		void SortedVector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
		splat_type( reinterpret_cast<TYPE>(dest), reinterpret_cast<const TYPE>(item), num );
		}

		template<class TYPE>
		void SortedVector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
		move_forward_type( reinterpret_cast<TYPE>(dest), reinterpret_cast<const TYPE>(from), num );
		}

		template<class TYPE>
		void SortedVector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
		move_backward_type( reinterpret_cast<TYPE>(dest), reinterpret_cast<const TYPE>(from), num );
		}

		template<class TYPE>
		int SortedVector<TYPE>::do_compare(const void* lhs, const void* rhs) const {
		return compare_type( reinterpret_cast<const TYPE>(lhs), reinterpret_cast<const TYPE>(rhs) );
		}

		}; // namespace android


		// ---------------------------------------------------------------------------

		#endif // ANDROID_SORTED_VECTOR_H

libpixelflinger/tinyutils/Vector.h

+1 −10

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@

		#include <cutils/log.h>

		#include "tinyutils/Errors.h"
		#include "tinyutils/VectorImpl.h"
		#include "tinyutils/TypeHelpers.h"

		@@ -302,16 +303,6 @@ ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
		return VectorImpl::removeItemsAt(index, count);
		}

		template<class TYPE> inline
		status_t Vector<TYPE>::sort(Vector<TYPE>::compar_t cmp) {
		return VectorImpl::sort((VectorImpl::compar_t)cmp);
		}

		template<class TYPE> inline
		status_t Vector<TYPE>::sort(Vector<TYPE>::compar_r_t cmp, void* state) {
		return VectorImpl::sort((VectorImpl::compar_r_t)cmp, state);
		}

		// ---------------------------------------------------------------------------

		template<class TYPE>