Usermode/Libraries/libc++.so_src/include_exp/vector

   1 /*
   2  * Acess2 C++ Library
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * vector (header)
   6  * - C++'s vector (dynamic array) type
   7  */
   8 #ifndef _LIBCXX_VECTOR_
   9 #define _LIBCXX_VECTOR_
  10
  11 #include <allocator>
  12 #include <stdexcept>
  13 #include <initializer_list>
  14
  15 extern "C" void _SysDebug(const char *, ...);
  16
  17 namespace std {
  18
  19 namespace _bits {
  20 template <class VectorType, class T>
  21 class vector_iterator//:
  22         //public random_acess_iterator_tag
  23 {
  24         friend VectorType;
  25
  26         typedef typename VectorType::size_type  size_type;
  27         typedef typename VectorType::difference_type    difference_type;
  28
  29         T*      m_array;
  30         size_type       m_pos;
  31         size_type       m_max;
  32 public:
  33         vector_iterator():
  34                 vector_iterator(0,0,0)
  35         {
  36         }
  37         vector_iterator(const vector_iterator& x):
  38                 vector_iterator()
  39         {
  40                 *this = x;
  41         }
  42         vector_iterator(T* array, size_type start, size_type max):
  43                 m_array(array),
  44                 m_pos(start),
  45                 m_max(max)
  46         {
  47         }
  48         vector_iterator& operator=(const vector_iterator& x)
  49         {
  50                 m_array = x.m_array;
  51                 m_pos = x.m_pos;
  52                 m_max = x.m_max;
  53                 return *this;
  54         }
  55         bool operator==(const vector_iterator& other) const {
  56                 return m_pos == other.m_pos;
  57         }
  58         bool operator!=(const vector_iterator& other) const {
  59                 return !(*this == other);
  60         }
  61         T& operator*() const {
  62                 return m_array[m_pos];
  63         }
  64         T& operator->() const {
  65                 return m_array[m_pos];
  66         }
  67         T& operator[](difference_type n) {
  68                 return *(*this + n);
  69         }
  70         vector_iterator& operator++() {
  71                 if(m_pos < m_max) {
  72                         m_pos ++;
  73                 }
  74                 return *this;
  75         }
  76         const vector_iterator operator++(int) {
  77                 vector_iterator ret(*this);
  78                 ++*this;
  79                 return ret;
  80         }
  81         vector_iterator& operator--() {
  82                 if(m_pos > 0) {
  83                         m_pos --;
  84                 }
  85                 return *this;
  86         }
  87         const vector_iterator operator--(int) {
  88                 vector_iterator ret(*this);
  89                 --*this;
  90                 return ret;
  91         }
  92         vector_iterator& operator+=(difference_type n) {
  93                 if( n < 0 )
  94                         return (*this -= -n);
  95                 if( n > 0 )
  96                         m_pos = (m_pos + n < m_max ? m_pos + n : m_max);
  97                 return *this;
  98         }
  99         vector_iterator& operator-=(difference_type n) {
 100                 if( n < 0 )
 101                         return (*this += -n);
 102                 if( n > 0 )
 103                         m_pos = (m_pos >= n ? m_pos - n : 0);
 104                 return *this;
 105         }
 106         const difference_type operator-(const vector_iterator& it2) const {
 107                 //_libcxx_assert(m_array == it2.m_array);
 108                 return m_pos - it2.m_pos;
 109         }
 110         bool operator<(const vector_iterator& o) const { return m_pos < o.m_pos; }
 111         bool operator>(const vector_iterator& o) const { return m_pos > o.m_pos; }
 112         bool operator<=(const vector_iterator& o) const { return m_pos <= o.m_pos; }
 113         bool operator>=(const vector_iterator& o) const { return m_pos >= o.m_pos; }
 114 };
 115 #define vector_iterator_tpl class VectorType, class T
 116 #define vector_iterator vector_iterator<VectorType, T>
 117 template <vector_iterator_tpl>
 118 const vector_iterator operator+(const vector_iterator& it, typename VectorType::difference_type n) {
 119         return vector_iterator(it) += n;
 120 }
 121 template <vector_iterator_tpl>
 122 const vector_iterator operator+(typename VectorType::difference_type n, const vector_iterator& it) {
 123         return vector_iterator(it) += n;
 124 }
 125 template <vector_iterator_tpl>
 126 const vector_iterator operator-(const vector_iterator& it, typename VectorType::difference_type n) {
 127         return vector_iterator(it) -= n;
 128 }
 129 #undef vector_iterator_tpl
 130 #undef vector_iterator
 131
 132 }
 133
 134 template <class T, class Alloc = allocator<T> >
 135 class vector
 136 {
 137 public:
 138         typedef T       value_type;
 139         typedef Alloc   allocator_type;
 140         typedef typename allocator_type::reference      reference;
 141         typedef typename allocator_type::const_reference        const_reference;
 142         typedef typename allocator_type::pointer        pointer;
 143         typedef typename allocator_type::const_pointer  const_pointer;
 144         typedef int     difference_type;
 145         typedef size_t  size_type;
 146         typedef ::std::_bits::vector_iterator<vector,T> iterator;
 147         typedef ::std::_bits::vector_iterator<vector,const T>   const_iterator;
 148
 149 private:
 150         allocator_type  m_alloc;
 151         size_type       m_size;
 152         size_type       m_capacity;
 153         value_type*     m_data;
 154
 155 public:
 156         vector(const allocator_type& alloc = allocator_type()):
 157                 m_alloc(alloc),
 158                 m_size(0),
 159                 m_capacity(0),
 160                 m_data(0)
 161         {
 162         }
 163         vector(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()):
 164                 vector(alloc)
 165         {
 166                 resize(n, val);
 167         }
 168         template <class InputIterator>
 169         vector(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()):
 170                 vector(alloc)
 171         {
 172                 insert(begin(), first, last);
 173         }
 174         vector(const vector& x):
 175                 vector(x.m_alloc)
 176         {
 177                 *this = x;
 178         }
 179         #if _CXX11_AVAIL
 180         vector(vector&& x):
 181                 m_alloc(x.m_alloc),
 182                 m_size(x.m_size),
 183                 m_capacity(x.m_capacity),
 184                 m_data(x.m_data)
 185         {
 186                 x.m_data = nullptr;
 187                 x.m_capacity = 0;
 188                 x.m_size = 0;
 189         }
 190         vector(vector&& x, const allocator_type& alloc):
 191                 m_alloc(alloc),
 192                 m_size(x.m_size),
 193                 m_capacity(x.m_capacity),
 194                 m_data(x.m_data)
 195         {
 196                 x.m_data = nullptr;
 197                 x.m_capacity = 0;
 198                 x.m_size = 0;
 199         }
 200         vector(std::initializer_list<value_type> il, const allocator_type& alloc = allocator_type()):
 201                 vector(alloc)
 202         {
 203                 reserve(il.size());
 204                 insert(begin(), il.begin(), il.end());
 205         }
 206         #endif
 207         vector& operator=(const vector& x)
 208         {
 209                 clear();
 210                 m_alloc.deallocate(m_data, m_capacity);
 211                 m_capacity = 0;
 212                 m_data = nullptr;
 213
 214                 reserve(x.size());
 215                 for( size_type i = 0; i < x.size(); i ++ )
 216                         push_back( x[i] );
 217
 218                 return *this;
 219         }
 220
 221         ~vector()
 222         {
 223                 clear();
 224                 m_alloc.deallocate(m_data, m_capacity);
 225                 m_capacity = 0;
 226                 m_data = nullptr;
 227         }
 228
 229         // Iterators
 230         iterator       begin()       { return iterator_to(0); }
 231         const_iterator begin() const { return iterator_to(0); }
 232         iterator       end()       { return iterator_to(m_size); }
 233         const_iterator end() const { return iterator_to(m_size); }
 234
 235         // Capacity
 236         size_type size() const {
 237                 return m_size;
 238         }
 239         size_type max_size() const {
 240                 return -1 / sizeof(value_type);
 241         }
 242         void resize(size_type new_cap, value_type val = value_type()) {
 243                 reserve(new_cap);
 244                 if( new_cap > m_size )
 245                 {
 246                         for( size_type i = m_size; i < new_cap; i ++ ) {
 247                                 m_alloc.construct( &m_data[i], val );
 248                         }
 249                 }
 250                 else
 251                 {
 252                         for( size_type i = new_cap; i < m_size; i ++ )
 253                                 m_alloc.destroy( &m_data[i] );
 254                 }
 255                 m_size = new_cap;
 256         }
 257         size_type capacity() const {
 258                 return m_capacity;
 259         }
 260         bool empty() const {
 261                 return m_size == 0;
 262         }
 263         void reserve(size_type n) {
 264                 if( n > max_size() )
 265                         throw ::std::length_error("::std::vector::reserve");
 266                 if( n > m_capacity )
 267                 {
 268                         size_type size = (n + 0x1F) & ~0x1F;
 269                         auto new_area = m_alloc.allocate(size);
 270                         for( size_type i = 0; i < m_size; i ++ )
 271                                 new_area[i] = m_data[i];
 272                         m_alloc.deallocate(m_data, m_capacity);
 273                         m_data = new_area;
 274                         m_capacity = size;
 275                         //::_SysDebug("::std::vector::resize - m_capacity=%i for n=%i", m_capacity, n);
 276                 }
 277         }
 278         void shrink_to_fit() {
 279         }
 280
 281         // Element access
 282         reference operator[] (size_type n) {
 283                 return m_data[n];
 284         }
 285         const_reference operator[] (size_type n) const {
 286                 return m_data[n];
 287         }
 288         reference at(size_type n) {
 289                 if(n > size())
 290                         _throw_out_of_range("::std::vector - at");
 291                 return m_data[n];
 292         }
 293         const_reference at(size_type n) const {
 294                 if(n > size())
 295                         _throw_out_of_range("::std::vector - at");
 296                 return m_data[n];
 297         }
 298         reference front() {
 299                 return m_data[0];
 300         }
 301         const_reference front() const {
 302                 return m_data[0];
 303         }
 304         reference back() {
 305                 return m_data[size()-1];
 306         }
 307         const_reference back() const {
 308                 return m_data[size()-1];
 309         }
 310         pointer data() noexcept {
 311                 return m_data;
 312         }
 313         const_pointer data() const noexcept {
 314                 return m_data;
 315         }
 316
 317         // Modifiers
 318         void assign(size_type n, const value_type& val) {
 319                 clear();
 320                 resize(n, val);
 321         }
 322         void push_back(const value_type& val) {
 323                 resize(size()+1, val);
 324         }
 325         void pop_back() {
 326                 if( !empty() ) {
 327                         resize(size()-1);
 328                 }
 329         }
 330         iterator insert(iterator position, const value_type& val) {
 331                 insert(position, 1, val);
 332                 return iterator_to(position.m_pos);
 333         }
 334         void insert(iterator position, size_type n, const value_type& val) {
 335                 reserve(m_size + n);
 336                 if( position != end() ) {
 337                         ::_sys::debug("TODO: vector::insert within vector (%i!=%i)",
 338                                 position-begin(), end()-begin());
 339                         ::_sys::abort();
 340                 }
 341                 size_type       pos = m_size;
 342                 while( n -- )
 343                 {
 344                         //::_sys::debug("vector::insert - %x at %i", val, pos);
 345                         m_alloc.construct( &m_data[pos], val );
 346                         pos ++;
 347                         m_size ++;
 348                 }
 349         }
 350         template <class InputIterator>
 351         void insert(iterator position, InputIterator first, InputIterator last) {
 352                 InputIterator   it = first;
 353                 size_type       len = 0;
 354                 while(it != last) {
 355                         ++ it;
 356                         len ++;
 357                 }
 358                 reserve(m_size + len);
 359
 360                 it = first;
 361                 while(it != last)
 362                 {
 363                         //::_sys::debug("vector::insert - to %i, from %p:%i",
 364                         //      position.m_pos, it.m_array, it.m_pos);
 365                         position = insert(position, *it) + 1;
 366                         ++it;
 367                 }
 368         }
 369         iterator erase(iterator position);
 370         iterator erase(iterator first, iterator last);
 371         //void swap(vector& x) {
 372         //      ::std::swap(m_size, x.m_size);
 373         //      ::std::swap(m_capacity, x.m_capacity);
 374         //      ::std::swap(m_data, x.m_data);
 375         //}
 376         void clear() {
 377                 for( size_type i = 0; i < m_size; i ++ ) {
 378                         m_alloc.destroy( &m_data[i] );
 379                 }
 380                 m_size = 0;
 381         }
 382 private:
 383         iterator iterator_to(size_type index) {
 384                 _libcxx_assert(index <= m_size);
 385                 return iterator(m_data, index, m_size);
 386         }
 387         const_iterator iterator_to(size_type index) const {
 388                 _libcxx_assert(index <= m_size);
 389                 return const_iterator(m_data, index, m_size);
 390         }
 391 };
 392
 393 };      // namespace std
 394
 395 #endif
 396 // vim: ft=cpp
 397