1#ifndef _SIM_VECTOR
2#define _SIM_VECTOR
3
4#pragma clang system_header
5
6#include "sim_iterator_base"
7
8namespace std {
9
10template <typename T, typename Ptr, typename Ref> struct __vector_iterator {
11  typedef __vector_iterator<T, T *, T &> iterator;
12  typedef __vector_iterator<T, const T *, const T &> const_iterator;
13
14  typedef ptrdiff_t difference_type;
15  typedef T value_type;
16  typedef Ptr pointer;
17  typedef Ref reference;
18  typedef std::random_access_iterator_tag iterator_category;
19
20  __vector_iterator(const Ptr p = 0) : ptr(p) {}
21  __vector_iterator(const iterator &rhs): ptr(rhs.base()) {}
22  __vector_iterator<T, Ptr, Ref>& operator++() { ++ ptr; return *this; }
23  __vector_iterator<T, Ptr, Ref> operator++(int) {
24    auto tmp = *this;
25    ++ ptr;
26    return tmp;
27  }
28  __vector_iterator<T, Ptr, Ref> operator--() { -- ptr; return *this; }
29  __vector_iterator<T, Ptr, Ref> operator--(int) {
30    auto tmp = *this; -- ptr;
31    return tmp;
32  }
33  __vector_iterator<T, Ptr, Ref> operator+(difference_type n) {
34    return ptr + n;
35  }
36  friend __vector_iterator<T, Ptr, Ref> operator+(
37      difference_type n,
38      const __vector_iterator<T, Ptr, Ref> &iter) {
39    return n + iter.ptr;
40  }
41  __vector_iterator<T, Ptr, Ref> operator-(difference_type n) {
42    return ptr - n;
43  }
44  __vector_iterator<T, Ptr, Ref> operator+=(difference_type n) {
45    return ptr += n;
46  }
47  __vector_iterator<T, Ptr, Ref> operator-=(difference_type n) {
48    return ptr -= n;
49  }
50
51  template<typename U, typename Ptr2, typename Ref2>
52  difference_type operator-(const __vector_iterator<U, Ptr2, Ref2> &rhs);
53
54  Ref operator*() const { return *ptr; }
55  Ptr operator->() const { return ptr; }
56
57  Ref operator[](difference_type n) {
58    return *(ptr+n);
59  }
60
61  bool operator==(const iterator &rhs) const { return ptr == rhs.ptr; }
62  bool operator==(const const_iterator &rhs) const { return ptr == rhs.ptr; }
63
64  bool operator!=(const iterator &rhs) const { return ptr != rhs.ptr; }
65  bool operator!=(const const_iterator &rhs) const { return ptr != rhs.ptr; }
66
67  const Ptr& base() const { return ptr; }
68
69private:
70  Ptr ptr;
71};
72
73template<typename T>
74class vector {
75  T *_start;
76  T *_finish;
77  T *_end_of_storage;
78
79public:
80  typedef T value_type;
81  typedef size_t size_type;
82  typedef __vector_iterator<T, T *, T &> iterator;
83  typedef __vector_iterator<T, const T *, const T &> const_iterator;
84
85  vector() : _start(0), _finish(0), _end_of_storage(0) {}
86  template <typename InputIterator>
87  vector(InputIterator first, InputIterator last);
88  vector(const vector &other);
89  vector(vector &&other);
90  ~vector();
91
92  size_t size() const {
93    return size_t(_finish - _start);
94  }
95
96  vector& operator=(const vector &other);
97  vector& operator=(vector &&other);
98  vector& operator=(std::initializer_list<T> ilist);
99
100  void assign(size_type count, const T &value);
101  template <typename InputIterator >
102  void assign(InputIterator first, InputIterator last);
103  void assign(std::initializer_list<T> ilist);
104
105  void clear();
106
107  void push_back(const T &value);
108  void push_back(T &&value);
109  template<class... Args>
110  void emplace_back(Args&&... args);
111  void pop_back();
112
113  iterator insert(const_iterator position, const value_type &val);
114  iterator insert(const_iterator position, size_type n,
115                  const value_type &val);
116  template <typename InputIterator>
117  iterator insert(const_iterator position, InputIterator first,
118                  InputIterator last);
119  iterator insert(const_iterator position, value_type &&val);
120  iterator insert(const_iterator position, initializer_list<value_type> il);
121
122  template <class... Args>
123  iterator emplace(const_iterator position, Args&&... args);
124
125  iterator erase(const_iterator position);
126  iterator erase(const_iterator first, const_iterator last);
127
128  T &operator[](size_t n) {
129    return _start[n];
130  }
131
132  const T &operator[](size_t n) const {
133    return _start[n];
134  }
135
136  iterator begin() { return iterator(_start); }
137  const_iterator begin() const { return const_iterator(_start); }
138  const_iterator cbegin() const { return const_iterator(_start); }
139  iterator end() { return iterator(_finish); }
140  const_iterator end() const { return const_iterator(_finish); }
141  const_iterator cend() const { return const_iterator(_finish); }
142  T& front() { return *begin(); }
143  const T& front() const { return *begin(); }
144  T& back() { return *(end() - 1); }
145  const T& back() const { return *(end() - 1); }
146};
147
148} // namespace std
149
150#endif // _SIM_VECTOR
151