btAlignedObjectArray< T > Class Template Reference

#include <btAlignedObjectArray.h>

List of all members.

Classes
class	less
Public Member Functions
SIMD_FORCE_INLINE T &	at (int32_t n)
SIMD_FORCE_INLINE const T &	at (int32_t n) const
	btAlignedObjectArray (const btAlignedObjectArray &otherArray)
	Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead.
	btAlignedObjectArray ()
SIMD_FORCE_INLINE int32_t	capacity () const
	return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve()
SIMD_FORCE_INLINE void	clear ()
	clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.
void	copyFromArray (const btAlignedObjectArray &otherArray)
template<typename L >
void	downHeap (T *pArr, int32_t k, int32_t n, const L &CompareFunc)
	heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/
SIMD_FORCE_INLINE T &	expand (const T &fillValue=T())
SIMD_FORCE_INLINE T &	expandNonInitializing ()
int32_t	findBinarySearch (const T &key) const
	non-recursive binary search, assumes sorted array
int32_t	findLinearSearch (const T &key) const
template<typename L >
void	heapSort (const L &CompareFunc)
void	initializeFromBuffer (void *buffer, int32_t size, int32_t capacity)
SIMD_FORCE_INLINE btAlignedObjectArray< T > &	operator= (const btAlignedObjectArray< T > &other)
SIMD_FORCE_INLINE T &	operator[] (int32_t n)
SIMD_FORCE_INLINE const T &	operator[] (int32_t n) const
SIMD_FORCE_INLINE void	pop_back ()
SIMD_FORCE_INLINE void	push_back (const T &_Val)
template<typename L >
void	quickSort (const L &CompareFunc)
template<typename L >
void	quickSortInternal (const L &CompareFunc, int32_t lo, int32_t hi)
void	remove (const T &key)
SIMD_FORCE_INLINE void	reserve (int32_t _Count)
SIMD_FORCE_INLINE void	resize (int32_t newsize, const T &fillData=T())
SIMD_FORCE_INLINE int32_t	size () const
	return the number of elements in the array
void	swap (int32_t index0, int32_t index1)
	~btAlignedObjectArray ()
Protected Member Functions
SIMD_FORCE_INLINE void *	allocate (int32_t size)
SIMD_FORCE_INLINE int32_t	allocSize (int32_t size)
SIMD_FORCE_INLINE void	copy (int32_t start, int32_t end, T *dest) const
SIMD_FORCE_INLINE void	deallocate ()
SIMD_FORCE_INLINE void	destroy (int32_t first, int32_t last)
SIMD_FORCE_INLINE void	init ()

---

Detailed Description

template<typename T>
class btAlignedObjectArray< T >

The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data

---

Constructor & Destructor Documentation

template<typename T>

btAlignedObjectArray< T >::btAlignedObjectArray

(

)

[inline]

template<typename T>

btAlignedObjectArray< T >::~btAlignedObjectArray

(

)

[inline]

template<typename T>

btAlignedObjectArray< T >::btAlignedObjectArray

(

const btAlignedObjectArray< T > &

otherArray

)

[inline]

Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead.

---

Member Function Documentation

template<typename T>

SIMD_FORCE_INLINE void* btAlignedObjectArray< T >::allocate

(

int32_t

size

)

[inline, protected]

template<typename T>

SIMD_FORCE_INLINE int32_t btAlignedObjectArray< T >::allocSize

(

int32_t

size

)

[inline, protected]

template<typename T>

SIMD_FORCE_INLINE T& btAlignedObjectArray< T >::at

(

int32_t

n

)

[inline]

template<typename T>

SIMD_FORCE_INLINE const T& btAlignedObjectArray< T >::at

(

int32_t

n

)

const [inline]

template<typename T>

SIMD_FORCE_INLINE int32_t btAlignedObjectArray< T >::capacity

(

)

const [inline]

return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve()

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::clear

(

)

[inline]

clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::copy	(	int32_t	start,
		int32_t	end,
		T *	dest
	)			const [inline, protected]

template<typename T>

void btAlignedObjectArray< T >::copyFromArray

(

const btAlignedObjectArray< T > &

otherArray

)

[inline]

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::deallocate

(

)

[inline, protected]

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::destroy	(	int32_t	first,
		int32_t	last
	)			[inline, protected]

template<typename T>

template<typename L >

void btAlignedObjectArray< T >::downHeap	(	T *	pArr,
		int32_t	k,
		int32_t	n,
		const L &	CompareFunc
	)			[inline]

heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/

template<typename T>

SIMD_FORCE_INLINE T& btAlignedObjectArray< T >::expand

(

const T &

fillValue = T()

)

[inline]

template<typename T>

SIMD_FORCE_INLINE T& btAlignedObjectArray< T >::expandNonInitializing

(

)

[inline]

template<typename T>

int32_t btAlignedObjectArray< T >::findBinarySearch

(

const T &

key

)

const [inline]

non-recursive binary search, assumes sorted array

template<typename T>

int32_t btAlignedObjectArray< T >::findLinearSearch

(

const T &

key

)

const [inline]

template<typename T>

template<typename L >

void btAlignedObjectArray< T >::heapSort

(

const L &

CompareFunc

)

[inline]

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::init

(

void

)

[inline, protected]

template<typename T>

void btAlignedObjectArray< T >::initializeFromBuffer	(	void *	buffer,
		int32_t	size,
		int32_t	capacity
	)			[inline]

template<typename T>

SIMD_FORCE_INLINE btAlignedObjectArray<T>& btAlignedObjectArray< T >::operator=

(

const btAlignedObjectArray< T > &

other

)

[inline]

template<typename T>

SIMD_FORCE_INLINE T& btAlignedObjectArray< T >::operator[]

(

int32_t

n

)

[inline]

template<typename T>

SIMD_FORCE_INLINE const T& btAlignedObjectArray< T >::operator[]

(

int32_t

n

)

const [inline]

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::pop_back

(

)

[inline]

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::push_back

(

const T &

_Val

)

[inline]

template<typename T>

template<typename L >

void btAlignedObjectArray< T >::quickSort

(

const L &

CompareFunc

)

[inline]

template<typename T>

template<typename L >

void btAlignedObjectArray< T >::quickSortInternal	(	const L &	CompareFunc,
		int32_t	lo,
		int32_t	hi
	)			[inline]

template<typename T>

void btAlignedObjectArray< T >::remove

(

const T &

key

)

[inline]

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::reserve

(

int32_t

_Count

)

[inline]

template<typename T>

SIMD_FORCE_INLINE void btAlignedObjectArray< T >::resize	(	int32_t	newsize,
		const T &	fillData = T()
	)			[inline]

resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations.

template<typename T>

SIMD_FORCE_INLINE int32_t btAlignedObjectArray< T >::size

(

)

const [inline]

return the number of elements in the array

template<typename T>

void btAlignedObjectArray< T >::swap	(	int32_t	index0,
		int32_t	index1
	)			[inline]

---

The documentation for this class was generated from the following file:

• sdk/extensions/authoring/source/VHACD/inc/btAlignedObjectArray.h