Changeset 2882 for code/trunk/src/bullet/LinearMath/btAlignedObjectArray.h

Timestamp:

Mar 31, 2009, 8:05:51 PM (15 years ago)

Author:

rgrieder

Message:

Update from Bullet 2.73 to 2.74.

File:

• code/trunk/src/bullet/LinearMath/btAlignedObjectArray.h (modified) (5 diffs)

code/trunk/src/bullet/LinearMath/btAlignedObjectArray.h

@@ -59 +59 @@
                         return (size ? size*2 : 1);
                 }
-                SIMD_FORCE_INLINE       void    copy(int start,int end, T* dest)
+                SIMD_FORCE_INLINE       void    copy(int start,int end, T* dest) const
                 {
                         int i;
@@ -121 +121 @@
                 }
 
-                SIMD_FORCE_INLINE       int capacity() const
-                {       // return current length of allocated storage
-                        return m_capacity;
-                }
-                
+                ///Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead.
+                btAlignedObjectArray(const btAlignedObjectArray& otherArray)
+                {
+                        init();
+
+                        int otherSize = otherArray.size();
+                        resize (otherSize);
+                        otherArray.copy(0, otherSize, m_data);
+                }
+
+                
+                
+                /// return the number of elements in the array
                 SIMD_FORCE_INLINE       int size() const
-                {       // return length of sequence
+                {       
                         return m_size;
                 }
@@ -142 +150 @@
                 
 
+                ///clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.
                 SIMD_FORCE_INLINE       void    clear()
                 {
@@ -157 +166 @@
                 }
 
+                ///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.
                 SIMD_FORCE_INLINE       void    resize(int newsize, const T& fillData=T())
                 {
@@ -220 +231 @@
 
         
+                /// 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       int capacity() const
+                {       
+                        return m_capacity;
+                }
                 
                 SIMD_FORCE_INLINE       void reserve(int _Count)