hkObjectArray.inl
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:8k
源码类别:

其他游戏

开发平台:

Visual C++

  1. /* 
  2.  * 
  3.  * Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
  4.  * prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
  5.  * Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
  6.  * 
  7.  */
  8. template <typename T>
  9. HK_FORCE_INLINE void hkObjectArray<T>::construct(T* t, int n)
  10. {
  11. for(int i = 0; i < n; ++i)
  12. {
  13. new (t+i) T;
  14. }
  15. }
  16. template <typename T>
  17. HK_FORCE_INLINE void hkObjectArray<T>::construct(T* t, int n, const T& tcopy)
  18. {
  19. for(int i = 0; i < n; ++i)
  20. {
  21. new (t+i) T(tcopy);
  22. }
  23. }
  24. template <typename T>
  25. HK_FORCE_INLINE void hkObjectArray<T>::destruct(T* t, int n)
  26. {
  27. for(int i = 0; i < n; ++i)
  28. {
  29. t[i].~T();
  30. }
  31. }
  32. template <typename T>
  33. HK_FORCE_INLINE hkObjectArray<T>::hkObjectArray()
  34. {
  35. }
  36. template <typename T>
  37. HK_FORCE_INLINE hkObjectArray<T>::hkObjectArray( int initialSize )
  38. : m_array(initialSize)
  39. {
  40. construct( m_array.begin(), initialSize);
  41. }
  42. template <typename T>
  43. HK_FORCE_INLINE hkObjectArray<T>::hkObjectArray( int initialSize, const T& tinit )
  44. : m_array( initialSize )
  45. {
  46. construct( m_array.begin(), initialSize, tinit);
  47. }
  48. template <typename T>
  49. HK_FORCE_INLINE hkObjectArray<T>::hkObjectArray( const hkObjectArray& a )
  50. : m_array( a.getSize() )
  51. {
  52. T* t = m_array.begin();
  53. for(int i = 0; i < a.getSize(); ++i)
  54. {
  55. new (t+i) T(a[i]);
  56. }
  57. }
  58. template <typename T>
  59. HK_FORCE_INLINE hkObjectArray<T>& hkObjectArray<T>::operator= ( const hkObjectArray<T>& a )
  60. {
  61. if( a.getSize() > m_array.getCapacity() )
  62. {
  63. // need to reallocate, destroy the entire array
  64. // and start from scratch
  65. destruct( m_array.begin(), m_array.getSize() );
  66. m_array.setSize(a.getSize());
  67. T* t = m_array.begin();
  68. for( int i = 0; i < a.getSize(); i++ )
  69. {
  70. new (t + i) T( a[i]);
  71. }
  72. }
  73. else if( a.getSize() > m_array.getSize() )
  74. {
  75. // have the capacity, other is bigger
  76. // copy as many as possible, construct the end ones.
  77. int i;
  78. for(i = 0; i < m_array.getSize(); ++i)
  79. {
  80. m_array[i] = a[i];
  81. }
  82. T* t = m_array.begin();
  83. for( ; i < a.getSize(); ++i)
  84. {
  85. new (t + i) T( a[i]);
  86. }
  87. m_array.setSizeUnchecked( a.getSize() );
  88. }
  89. else //( a.getSize() < m_array.getSize() )
  90. {
  91. // have the capacity, i am bigger
  92. // copy as many as possible, destroy the end ones.
  93. int i;
  94. for(i = 0; i < a.getSize(); ++i)
  95. {
  96. m_array[i] = a[i];
  97. }
  98. for( ; i < m_array.getSize(); ++i)
  99. {
  100. m_array[i].~T();
  101. }
  102. m_array.setSizeUnchecked( a.getSize() );
  103. }
  104. return *this;
  105. }
  106. template <typename T>
  107. HK_FORCE_INLINE hkObjectArray<T>::~hkObjectArray()
  108. {
  109. int size = m_array.getSize();
  110. for( int i = 0; i < size; ++i)
  111. {
  112. T& del = m_array[i];
  113. del.~T();
  114. }
  115. }
  116. template <typename T>
  117. HK_FORCE_INLINE T& hkObjectArray<T>::operator[] (int i)
  118. {
  119. HK_ASSERT(0x61001bf9, i<m_array.getSize());
  120. return m_array[i];
  121. }
  122. template <typename T>
  123. HK_FORCE_INLINE const T& hkObjectArray<T>::operator[] (int i) const
  124. {
  125. HK_ASSERT(0x4e99fe23, i<m_array.getSize());
  126. return m_array[i];
  127. }
  128. template <typename T>
  129. HK_FORCE_INLINE T& hkObjectArray<T>::back()
  130. {
  131. return m_array.back();
  132. }
  133. template <typename T>
  134. HK_FORCE_INLINE const T& hkObjectArray<T>::back() const
  135. {
  136. return m_array.back();
  137. }
  138. template <typename T>
  139. HK_FORCE_INLINE int hkObjectArray<T>::getSize() const
  140. {
  141. return m_array.getSize();
  142. }
  143. template <typename T>
  144. HK_FORCE_INLINE int hkObjectArray<T>::getCapacity() const
  145. {
  146. return m_array.getCapacity();
  147. }
  148. template <typename T>
  149. HK_FORCE_INLINE hkBool hkObjectArray<T>::isEmpty() const
  150. {
  151. return 0 == getSize();
  152. }
  153. template <typename T>
  154. HK_FORCE_INLINE void hkObjectArray<T>::clear()
  155. {
  156. destruct( m_array.begin(), m_array.getSize() );
  157. m_array.clear();
  158. }
  159. template <typename T>
  160. HK_FORCE_INLINE void hkObjectArray<T>::clearAndDeallocate()
  161. {
  162. destruct( m_array.begin(), m_array.getSize() );
  163. m_array.clearAndDeallocate();
  164. }
  165. template <typename T>
  166. HK_FORCE_INLINE void hkObjectArray<T>::removeAt(int i)
  167. {
  168. int s = m_array.getSize() - 1;
  169. m_array[i] = m_array[s];
  170. m_array[s].~T();
  171. m_array.popBack();
  172. }
  173. template <typename T>
  174. HK_FORCE_INLINE void hkObjectArray<T>::removeAtAndCopy(int index)
  175. {
  176. int s = m_array.getSize() - 1;
  177. for( int i = index; i < s; i++ )
  178. {
  179. m_array[i] = m_array[i+1];
  180. }
  181. m_array[s].~T();
  182. m_array.setSizeUnchecked(s);
  183. }
  184. template <typename T>
  185. HK_FORCE_INLINE int hkObjectArray<T>::indexOf(const T& t) const
  186. {
  187. return m_array.indexOf(t);
  188. }
  189. template <typename T>
  190. HK_FORCE_INLINE int hkObjectArray<T>::lastIndexOf(const T& t) const
  191. {
  192. return m_array.lastIndexOf(t);
  193. }
  194. template <typename T>
  195. HK_FORCE_INLINE void hkObjectArray<T>::popBack()
  196. {
  197. m_array[m_array.getSize()-1].~T();
  198. m_array.popBack();
  199. }
  200. template <typename T>
  201. HK_FORCE_INLINE void hkObjectArray<T>::reserve( int minCapacity )
  202. {
  203. if( minCapacity > m_array.getCapacity() )
  204. {
  205. int cap2 = 2 * m_array.getCapacity();
  206. int newCap = (minCapacity < cap2) ? cap2 : minCapacity;
  207. int oldSize = m_array.getSize();
  208. hkObjectArray old;
  209. old.swap(*this);
  210. m_array.reserve(newCap);
  211. T* p = m_array.begin();
  212. for( int i = 0; i < oldSize; ++i )
  213. {
  214. // place variable req'd for broken sn compilers
  215. T *place = p + i;
  216. new (place) T( old[i] );
  217. }
  218. m_array.setSizeUnchecked(oldSize);
  219. }
  220. }
  221. template <typename T>
  222. HK_FORCE_INLINE void hkObjectArray<T>::pushBack( const T& t )
  223. {
  224. int size = m_array.getSize();
  225. if( size == m_array.getCapacity() )
  226. {
  227. reserve( size ? size*2 : 1 );
  228. }
  229. m_array.setSizeUnchecked(size+1);
  230. new (&m_array[size]) T(t);
  231. }
  232. template <typename T>
  233. HK_FORCE_INLINE void hkObjectArray<T>::setSize( int n )
  234. {
  235. int mysize = m_array.getSize();
  236. if( n < mysize )
  237. {
  238. for( int i = n; i < mysize; i++ )
  239. {
  240. m_array[i].~T();
  241. }
  242. }
  243. else
  244. {
  245. reserve( n );
  246. T* p = m_array.begin();
  247. for( int i = mysize; i < n; ++i )
  248. {
  249. // place variable req'd for broken sn compilers
  250. T *place = p + i;
  251. new (place) T();
  252. }
  253. }
  254. m_array.setSizeUnchecked( n );
  255. }
  256. template <typename T>
  257. HK_FORCE_INLINE T& hkObjectArray<T>::expandOne( )
  258. {
  259. return *expandBy(1);
  260. }
  261. template <typename T>
  262. HK_FORCE_INLINE T* hkObjectArray<T>::expandBy( int n )
  263. {
  264. int oldsize = m_array.getSize();
  265. setSize( oldsize + n );
  266. return m_array.begin() + oldsize;
  267. }
  268. template <typename T>
  269. HK_FORCE_INLINE void hkObjectArray<T>::setSize( int n, const T& fill )
  270. {
  271. int oldsize = m_array.getSize();
  272. setSize( n );
  273. if( oldsize < n )
  274. {
  275. for( int i = oldsize; i < n; i++ )
  276. {
  277. m_array[i] = fill;
  278. }
  279. }
  280. }
  281. template <typename T>
  282. void hkObjectArray<T>::swap(hkObjectArray<T>& a)
  283. {
  284. m_array.swap(a.m_array);
  285. }
  286.  
  287. template <typename T>
  288. typename hkObjectArray<T>::iterator hkObjectArray<T>::begin() 
  289. {
  290. return m_array.begin();
  291. }
  292. template <typename T>
  293. typename hkObjectArray<T>::iterator hkObjectArray<T>::end()
  294. {
  295. return m_array.begin() + m_array.getSize();
  296. }
  297. template <typename T>
  298. typename hkObjectArray<T>::const_iterator hkObjectArray<T>::begin() const
  299. {
  300. return m_array.begin();
  301. }
  302. template <typename T>
  303. typename hkObjectArray<T>::const_iterator hkObjectArray<T>::end() const
  304. {
  305. return m_array.begin() + m_array.getSize();
  306. }
  307. template <typename T>
  308. hkOstream& operator<< (hkOstream& os, const hkObjectArray<T>& a)
  309. {
  310. os << "#[";
  311. for(int i=0; i < a.getSize(); ++i)
  312. {
  313. os << a[i] << ' ';
  314. }
  315. os << "]";
  316. return os;
  317. }
  318. /*
  319. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  320. * Confidential Information of Havok.  (C) Copyright 1999-2009
  321. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  322. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  323. * rights, and intellectual property rights in the Havok software remain in
  324. * Havok and/or its suppliers.
  325. * Use of this software for evaluation purposes is subject to and indicates
  326. * acceptance of the End User licence Agreement for this product. A copy of
  327. * the license is included with this software and is also available at www.havok.com/tryhavok.
  328. */