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