Main Page Class List Class Members

# 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