17 #ifndef BT_OBJECT_ARRAY__    18 #define BT_OBJECT_ARRAY__    29 #define BT_USE_PLACEMENT_NEW 1    31 #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful    36 #endif //BT_USE_MEMCPY    38 #ifdef BT_USE_PLACEMENT_NEW    40 #endif //BT_USE_PLACEMENT_NEW    43 #if __cplusplus > 199711L    46 #define BT_REGISTER register    63 #ifdef BT_ALLOW_ARRAY_COPY_OPERATOR    70 #else//BT_ALLOW_ARRAY_COPY_OPERATOR    73 #endif//BT_ALLOW_ARRAY_COPY_OPERATOR    78                         return (size ? size*2 : 1);
    83                         for (i=start;i<end;++i)
    85                                 new (&dest[i]) T(m_data[i]);
    88 #endif //BT_USE_PLACEMENT_NEW   102                         for (i=first; i<last;i++)
   147                         int otherSize = otherArray.
size();
   149                         otherArray.
copy(0, otherSize, m_data);
   211                         if (newsize > 
size())
   222                         if (newsize < curSize)
   224                                 for(
int i = newsize; i < curSize; i++)
   230                                 if (newsize > curSize)
   234 #ifdef BT_USE_PLACEMENT_NEW   235                                 for (
int i=curSize;i<newsize;i++)
   237                                         new ( &m_data[i]) T(fillData);
   239 #endif //BT_USE_PLACEMENT_NEW   266 #ifdef BT_USE_PLACEMENT_NEW   267                         new (&m_data[sz]) T(fillValue); 
   282 #ifdef BT_USE_PLACEMENT_NEW   283                         new ( &m_data[
m_size] ) T(_Val);
   285                         m_data[
size()] = _Val;                  
   286 #endif //BT_USE_PLACEMENT_NEW   332                 template <
typename L>
   338                         T x=m_data[(lo+hi)/2];
   343                                 while (CompareFunc(m_data[i],x)) 
   345                                 while (CompareFunc(x,m_data[j])) 
   362                 template <
typename L>
   374                 template <
typename L>
   375                 void downHeap(T *pArr, 
int k, 
int n, 
const L& CompareFunc)
   380                         T temp = pArr[k - 1];
   386                                 if ((child < n) && CompareFunc(pArr[child - 1] , pArr[child]))
   391                                 if (CompareFunc(temp , pArr[child - 1]))
   394                                         pArr[k - 1] = pArr[child - 1];
   405                 void    swap(
int index0,
int index1)
   408                         char    temp[
sizeof(T)];
   409                         memcpy(temp,&m_data[index0],
sizeof(T));
   410                         memcpy(&m_data[index0],&m_data[index1],
sizeof(T));
   411                         memcpy(&m_data[index1],temp,
sizeof(T));
   413                         T temp = m_data[index0];
   414                         m_data[index0] = m_data[index1];
   415                         m_data[index1] = temp;
   416 #endif //BT_USE_PLACEMENT_NEW   420         template <
typename L>
   426                 for (k = n/2; k > 0; k--) 
   428                         downHeap(m_data, k, n, CompareFunc);
   439                         downHeap(m_data, 1, n, CompareFunc);
   450                 while (first <= last) {
   451                         int mid = (first + last) / 2;  
   452                         if (key > m_data[mid]) 
   454                         else if (key < m_data[mid]) 
   468                 for (i=0;i<
size();i++)
   470                         if (m_data[i] == key)
   479         void    remove(
const T& key)
   483                 if (findIndex<
size())
   494                 m_ownsMemory = 
false;
   502                 int otherSize = otherArray.
size();
   504                 otherArray.
copy(0, otherSize, m_data);
   509 #endif //BT_OBJECT_ARRAY__ 
void copy(int start, int end, T *dest) const 
void push_back(const T &_Val)
void deallocate(pointer ptr)
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
const T & at(int n) const 
void * allocate(int size)
const T & operator[](int n) const 
void resizeNoInitialize(int newsize)
resize changes the number of elements in the array. 
void destroy(int first, int last)
#define SIMD_FORCE_INLINE
void copyFromArray(const btAlignedObjectArray &otherArray)
void downHeap(T *pArr, int k, int n, const L &CompareFunc)
heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ 
void swap(int index0, int index1)
void heapSort(const L &CompareFunc)
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. 
int size() const 
return the number of elements in the array 
#define BT_USE_PLACEMENT_NEW
If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW then the btAligne...
void initializeFromBuffer(void *buffer, int size, int capacity)
int capacity() const 
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
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. 
void resize(int newsize, const T &fillData=T())
int findLinearSearch(const T &key) const 
btAlignedObjectArray< T > & operator=(const btAlignedObjectArray< T > &other)
T & expand(const T &fillValue=T())
pointer allocate(size_type n, const_pointer *hint=0)
T & expandNonInitializing()
int findBinarySearch(const T &key) const 
non-recursive binary search, assumes sorted array 
btAlignedAllocator< T, 16 > m_allocator
void quickSortInternal(const L &CompareFunc, int lo, int hi)
bool operator()(const T &a, const T &b)
void quickSort(const L &CompareFunc)