array.inl - Engine C API Reference

array.inl
  1. #include "assert.h"
  3. namespace stingray_plugin_foundation {
  5. template <class T> Array<T>::Array(Allocator &allocator) : _size(0), _capacity(0), _data(0), _allocator(&allocator)
  6. {
  7. }
  9. template <class T> Array<T>::Array(unsigned size, Allocator &allocator) : _size(0), _capacity(0), _data(0), _allocator(&allocator)
  10. {
  11.     resize(size);
  12. }
  14. template <class T> Array<T>::Array(const NoAllocator &) : _size(0), _capacity(0), _data(0), _allocator(0)
  15. {
  16. }
  18. template <class T> void Array<T>::set_allocator(Allocator &allocator)
  19. {
  20.     _allocator = &allocator;
  21. }
  23. template <class T> Array<T>::Array( const Array<T> &o ) : _size(0), _capacity(0), _data(0), _allocator(o._allocator)
  24. {
  25.     set_capacity(o.size());
  26.     copy(_data, o._data, o.size());
  27.     _size = o.size();
  28. }
  30. template <class T> void Array<T>::operator=(const Array<T> &o)
  31. {
  32.     resize(o.size());
  33.     copy(_data, o._data, o.size());
  34. }
  36. template <class T> typename Array<T>::reference Array<T>::operator[](unsigned i) {
  37.     XENSURE(i < _size);
  38.     return _data[i];
  39. }
  40. template <class T> typename Array<T>::const_reference Array<T>::operator[](unsigned i) const {
  41.     XENSURE(i < _size);
  42.     return _data[i];
  43. }
  45. template <class T> void Array<T>::reserve(unsigned capacity)
  46. {
  47.     if (capacity > _capacity)
  48.         grow(capacity);
  49. }
  51. template <class T> template <class ASSIGNABLE>
  52. void Array<T>::push_back(const ASSIGNABLE &item)
  53. {
  54.     if (_size + 1 > _capacity)
  55.         grow();
  56.     _data[_size++] = item;
  57. }
  59. template <class T> void Array<T>::pop_back()
  60. {
  61.     _size--;
  62. }
  64. template <class T> void Array<T>::swap(Array<T> &o)
  65. {
  66.     XENSURE(_allocator == o._allocator);
  67.     std::swap(_size, o._size);
  68.     std::swap(_capacity, o._capacity);
  69.     std::swap(_data, o._data);
  70.     std::swap(_allocator, o._allocator);
  71. }
  73. template <class T> template <class ASSIGNABLE>
  74. typename Array<T>::iterator Array<T>::insert(iterator pos, const ASSIGNABLE& x)
  75. {
  76.     if (_size + 1 > _capacity) {
  77.         unsigned i = (unsigned)(pos - _data);
  78.         grow();
  79.         pos = _data + i;
  80.     }
  81.     move(pos + 1, pos, (unsigned)((_data + _size) - pos));
  82.     *pos = x;
  83.     ++_size;
  84.     return pos;
  85. }
  87. template <class T> typename Array<T>::iterator Array<T>::insert(iterator pos)
  88. {
  89.     if (_size + 1 > _capacity) {
  90.         unsigned i = pos - _data;
  91.         grow();
  92.         pos = _data + i;
  93.     }
  94.     move(pos + 1, pos, (_data + _size) - pos);
  95.     ++_size;
  96.     return pos;
  97. }
  99. template <class T> void Array<T>::insert(iterator pos, const_iterator from, const_iterator to)
  100. {
  101.     unsigned add = (unsigned)(to - from);
  102.     if (_size + add > _capacity) {
  103.         size_t i = pos - _data;
  104.         grow(_size + add);
  105.         pos = _data + i;
  106.     }
  107.     move(pos + add, pos, (unsigned)((_data + _size) - pos));
  108.     copy(pos, from, add);
  109.     _size += add;
  110. }
  112. template <class T> typename Array<T>::iterator Array<T>::erase(iterator pos)
  113. {
  114.     XASSERT(pos >= begin() && pos < end(), "Trying to remove outside array.");
  115.     move(pos, pos + 1, (unsigned)((_data + _size) - pos - 1));
  116.     --_size;
  117.     return pos;
  118. }
  120. template <class T> typename Array<T>::iterator Array<T>::erase(iterator first, iterator last)
  121. {
  122.     move(first, last, (unsigned)((_data + _size) - last));
  123.     _size -= (unsigned)(last - first);
  124.     return first;
  125. }
  127. template <class T> template <typename EQUATABLE> void Array<T>::erase(const EQUATABLE &item)
  128. {
  129.     iterator it = find(item);
  130.     XENSURE(it != end());
  131.     erase(it);
  132. }
  134. template <class T> void Array<T>::resize(unsigned size)
  135. {
  136.     if (size > _capacity)
  137.         grow(size);
  139.     _size = size;
  140. }
  142. template <class T> void Array<T>::set_capacity(unsigned capacity)
  143. {
  144.     if (capacity == _capacity)
  145.         return;
  147.     if (capacity < _size)
  148.         resize(capacity);
  150.     pointer new_data = 0;
  152.     if (capacity > 0) {
  153.         unsigned align = alignof(value_type) > 4 ? alignof(value_type) : 4;
  154.         new_data = (pointer)_allocator->allocate(sizeof(value_type)*capacity, align);
  155.         copy(new_data, _data, _size);
  156.     }
  157.     _allocator->deallocate(_data);
  159.     _data = new_data;
  160.     _capacity = capacity;
  161. }
  163. template <class T> void Array<T>::move(pointer to, pointer from, unsigned n)
  164. {
  165.     memmove((void *)to, (void *)from, sizeof(T) * n);
  166. }
  168. template <class T> void Array<T>::copy(pointer to, const_pointer from, unsigned n)
  169. {
  170.     memcpy((void *)to, (void *)from, sizeof(T) * n);
  171. }
  173. template <class T>
  174. template <class STREAM> void Array<T>::serialize(STREAM &stream)
  175. {
  176.     unsigned sz = size();
  177.     stream & sz;
  178.     resize(sz);
  179.     for (unsigned i=0; i<sz; ++i)
  180.         stream & (*this)[i];
  181. }
  183. template <class STREAM, class T>
  184. void raw_array_serialize(STREAM &s, Array<T> &data)
  185. {
  186.     unsigned n = data.size();
  187.     s & n;
  188.     data.resize(n);
  190.     if (n > 0) {
  191.         if (s.is_output())
  192.             s.write(data.begin(), n * sizeof(T));
  193.         else
  194.             s.read(data.begin(), n * sizeof(T));
  195.     }
  196. }
  198. template <>
  199. template <class STREAM> void Array<char>::serialize(STREAM &stream) {
  200.     raw_array_serialize(stream, *this);
  201. }
  203. template <>
  204. template <class STREAM> void Array<uint8_t>::serialize(STREAM &stream) {
  205.     raw_array_serialize(stream, *this);
  206. }
  208. template <>
  209. template <class STREAM> void Array<int8_t>::serialize(STREAM &stream) {
  210.     raw_array_serialize(stream, *this);
  211. }
  213. template <>
  214. template <class STREAM> void Array<uint16_t>::serialize(STREAM &stream) {
  215.     raw_array_serialize(stream, *this);
  216. }
  218. template <>
  219. template <class STREAM> void Array<int16_t>::serialize(STREAM &stream) {
  220.     raw_array_serialize(stream, *this);
  221. }
  223. template <>
  224. template <class STREAM> void Array<uint32_t>::serialize(STREAM &stream) {
  225.     raw_array_serialize(stream, *this);
  226. }
  228. template <>
  229. template <class STREAM> void Array<int32_t>::serialize(STREAM &stream) {
  230.     raw_array_serialize(stream, *this);
  231. }
  233. template <>
  234. template <class STREAM> void Array<int64_t>::serialize(STREAM &stream) {
  235.     raw_array_serialize(stream, *this);
  236. }
  238. template <>
  239. template <class STREAM> void Array<uint64_t>::serialize(STREAM &stream) {
  240.     raw_array_serialize(stream, *this);
  241. }
  243. template<class T> bool Array<T>::operator==(const Array<T> &o) const
  244. {
  245.     if (size() != o.size())
  246.         return false;
  247.     return memcmp(_data, o._data, sizeof(T)*size()) == 0;
  248. }
  250. template<class T> bool Array<T>::operator<(const Array<T> &o) const
  251. {
  252.     if (size() != o.size())
  253.         return size() < o.size();
  254.     return memcmp(_data, o._data, sizeof(T)*size()) < 0;
  255. }
  257. template <class T> void Array<T>::grow(unsigned min_capacity)
  258. {
  259.     uint64_t new_capacity = (uint64_t)_capacity*2 + 10;
  260.     if (new_capacity < min_capacity)
  261.         new_capacity = min_capacity;
  262.     else if (new_capacity > UINT32_MAX)
  263.         new_capacity = UINT32_MAX;
  264.     set_capacity((unsigned)new_capacity);
  265. }
  267. template <class T> typename Array<T>::pointer Array<T>::steal()
  268. {
  269.     pointer return_value = _data;
  270.     _data = 0;
  271.     _capacity = 0;
  272.     _size = 0;
  273.     return return_value;
  274. }
  276. } // namespace stingray_plugin_foundation
Please send us your comment about this page