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

   1 /*
   2  * Acess2 C++ Library
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * string (header)
   6  * - C++'s String type
   7  */
   8 #ifndef _LIBCXX_VECTOR_
   9 #define _LIBCXX_VECTOR_
  10
  11 #include <allocator>
  12 #include <stdexcept>
  13
  14 extern "C" void _SysDebug(const char *, ...);
  15
  16 namespace std {
  17
  18 namespace _bits {
  19 template <class T, typename size_type>
  20 class vector_iterator//:
  21         //public random_acess_iterator_tag
  22 {
  23         T*      m_array;
  24         size_type       m_pos;
  25         size_type       m_max;
  26 public:
  27         vector_iterator():
  28                 vector_iterator(0,0,0)
  29         {
  30         }
  31         vector_iterator(const vector_iterator& x):
  32                 vector_iterator()
  33         {
  34                 *this = x;
  35         }
  36         vector_iterator(T* array, size_type start, size_type max):
  37                 m_array(array),
  38                 m_pos(start),
  39                 m_max(max)
  40         {
  41         }
  42         vector_iterator& operator=(const vector_iterator& x)
  43         {
  44                 m_array = x.m_array;
  45                 m_pos = x.m_pos;
  46                 m_max = x.m_max;
  47                 return *this;
  48         }
  49         bool operator==(const vector_iterator& other) const {
  50                 return m_pos == other.m_pos;
  51         }
  52         bool operator!=(const vector_iterator& other) const {
  53                 return !(*this == other);
  54         }
  55         T& operator*() const {
  56                 return m_array[m_pos];
  57         }
  58         T& operator->() const {
  59                 return m_array[m_pos];
  60         }
  61         vector_iterator& operator++() {
  62                 if(m_pos < m_max) {
  63                         m_pos ++;
  64                 }
  65                 return *this;
  66         }
  67         vector_iterator& operator--() {
  68                 if(m_pos > 0) {
  69                         m_pos --;
  70                 }
  71                 return *this;
  72         }
  73 };
  74 }
  75
  76 template <class T, class Alloc = allocator<T> >
  77 class vector
  78 {
  79 public:
  80         typedef T       value_type;
  81         typedef Alloc   allocator_type;
  82         typedef typename allocator_type::reference      reference;
  83         typedef typename allocator_type::const_reference        const_reference;
  84         typedef typename allocator_type::pointer        pointer;
  85         typedef typename allocator_type::const_pointer  const_pointer;
  86         typedef int     difference_type;
  87         typedef size_t  size_type;
  88         typedef ::std::_bits::vector_iterator<T,size_type>      iterator;
  89         typedef ::std::_bits::vector_iterator<const T,size_type>        const_iterator;
  90
  91 private:
  92         allocator_type  m_alloc;
  93         size_type       m_size;
  94         size_type       m_capacity;
  95         value_type*     m_data;
  96
  97 public:
  98         vector(const allocator_type& alloc = allocator_type()):
  99                 m_alloc(alloc),
 100                 m_size(0),
 101                 m_capacity(0),
 102                 m_data(0)
 103         {
 104         }
 105         vector(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()):
 106                 vector(alloc)
 107         {
 108                 resize(n, val);
 109         }
 110         vector(const vector& x):
 111                 vector(x.m_alloc)
 112         {
 113                 *this = x;
 114         }
 115
 116         ~vector()
 117         {
 118                 clear();
 119                 m_alloc.deallocate(m_data, m_capacity);
 120         }
 121
 122         // Iterators
 123         iterator begin() {
 124                 return iterator(m_data, 0, m_size);
 125         }
 126         const_iterator begin() const {
 127                 return const_iterator(m_data, 0, m_size);
 128         }
 129         iterator end() {
 130                 return iterator(m_data, m_size, m_size);
 131         }
 132         const_iterator end() const {
 133                 return const_iterator(m_data, m_size, m_size);
 134         }
 135
 136         // Capacity
 137         size_type size() const {
 138                 return m_size;
 139         }
 140         size_type max_size() const {
 141                 return -1 / sizeof(value_type);
 142         }
 143         void resize(size_type new_cap, value_type val = value_type()) {
 144                 reserve(new_cap);
 145                 if( new_cap > m_size )
 146                 {
 147                         for( size_type i = m_size; i < new_cap; i ++ ) {
 148                                 m_alloc.construct( &m_data[i], val );
 149                         }
 150                 }
 151                 else
 152                 {
 153                         for( size_type i = new_cap; i < m_size; i ++ )
 154                                 m_alloc.destroy( &m_data[i] );
 155                 }
 156                 m_size = new_cap;
 157         }
 158         size_type capacity() const {
 159                 return m_capacity;
 160         }
 161         bool empty() const {
 162                 return m_size == 0;
 163         }
 164         void reserve(size_type n) {
 165                 if( n > max_size() )
 166                         throw ::std::length_error("::std::vector::reserve");
 167                 if( n > m_capacity )
 168                 {
 169                         size_type size = (n + 0x1F) & ~0x1F;
 170                         auto new_area = m_alloc.allocate(size);
 171                         for( size_type i = 0; i < m_size; i ++ )
 172                                 new_area[i] = m_data[i];
 173                         m_alloc.deallocate(m_data, m_capacity);
 174                         m_data = new_area;
 175                         m_capacity = size;
 176                         //::_SysDebug("::std::vector::resize - m_capacity=%i for n=%i", m_capacity, n);
 177                 }
 178         }
 179         void shrink_to_fit() {
 180         }
 181
 182         // Element access
 183         reference operator[] (size_type n) {
 184                 return m_data[n];
 185         }
 186         const_reference operator[] (size_type n) const {
 187                 return m_data[n];
 188         }
 189         reference at(size_type n) {
 190                 if(n > size())
 191                         _throw_out_of_range("::std::vector - at");
 192                 return m_data[n];
 193         }
 194         const_reference at(size_type n) const {
 195                 if(n > size())
 196                         _throw_out_of_range("::std::vector - at");
 197                 return m_data[n];
 198         }
 199         reference front() {
 200                 return m_data[0];
 201         }
 202         const_reference front() const {
 203                 return m_data[0];
 204         }
 205         reference back() {
 206                 return m_data[size()-1];
 207         }
 208         const_reference back() const {
 209                 return m_data[size()-1];
 210         }
 211         pointer data() noexcept {
 212                 return m_data;
 213         }
 214         const_pointer data() const noexcept {
 215                 return m_data;
 216         }
 217
 218         // Modifiers
 219         void assign(size_type n, const value_type& val) {
 220                 clear();
 221                 resize(n, val);
 222         }
 223         void push_back(const value_type& val) {
 224                 resize(size()+1, val);
 225         }
 226         void pop_back() {
 227                 if( !empty() ) {
 228                         resize(size()-1);
 229                 }
 230         }
 231         iterator insert(iterator position, const value_type& val) {
 232                 inesert(position, 1, val);
 233                 return position;
 234         }
 235         void insert(iterator position, size_type n, const value_type& val);
 236         iterator erase(iterator position);
 237         iterator erase(iterator first, iterator last);
 238         //void swap(vector& x) {
 239         //      ::std::swap(m_size, x.m_size);
 240         //      ::std::swap(m_capacity, x.m_capacity);
 241         //      ::std::swap(m_data, x.m_data);
 242         //}
 243         void clear() {
 244                 for( size_type i = 0; i < m_size; i ++ ) {
 245                         m_alloc.destroy( &m_data[i] );
 246                 }
 247                 m_size = 0;
 248         }
 249 };
 250
 251 };      // namespace std
 252
 253 #endif
 254 // vim: ft=cpp
 255