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)
486 for (i=0;i<
size();i++)
488 if (m_data[i] == key)
505 void remove(
const T& key)
515 m_ownsMemory =
false;
523 int otherSize = otherArray.
size();
525 otherArray.
copy(0, otherSize, m_data);
530 #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)
bool operator()(const T &a, const T &b) const
#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.
void removeAtIndex(int index)
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)
void quickSort(const L &CompareFunc)
int findLinearSearch2(const T &key) const