Pico-Arduino
Vector.h
1 #pragma once
2 
12 template <class T>
13 class Vector {
14  public:
21  class iterator {
22  protected:
23  T *ptr;
24  size_t pos_;
25  public:
26  inline iterator(){
27  }
28  inline iterator(T* parPtr, size_t pos){
29  this->ptr = parPtr;
30  this->pos_ = pos;
31  }
32  // copy constructor
33  inline iterator(const iterator &copyFrom){
34  ptr = copyFrom.ptr;
35  pos_ = copyFrom.pos_;
36  }
37  inline iterator operator++(int n) {
38  ptr++;
39  pos_++;
40  return *this;
41  }
42  inline iterator operator++() {
43  ptr++;
44  pos_++;
45  return *this;
46  }
47  inline iterator operator--(int n) {
48  ptr--;
49  pos_--;
50  return *this;
51  }
52  inline iterator operator--() {
53  ptr--;
54  pos_--;
55  return *this;
56  }
57  inline iterator operator+(int offset) {
58  pos_ += offset;
59  return iterator(ptr+offset, offset);
60  }
61  inline bool operator==(iterator it) {
62  return ptr == it.getPtr();
63  }
64  inline bool operator<(iterator it) {
65  return ptr < it.getPtr();
66  }
67  inline bool operator<=(iterator it) {
68  return ptr <= it.getPtr();
69  }
70  inline bool operator>(iterator it) {
71  return ptr > it.getPtr();
72  }
73  inline bool operator>=(iterator it) {
74  return ptr >= it.getPtr();
75  }
76  inline bool operator!=(iterator it) {
77  return ptr != it.getPtr();
78  }
79  inline T &operator*() {
80  return *ptr;
81  }
82  inline T *getPtr() {
83  return ptr;
84  }
85  inline size_t pos() {
86  return pos_;
87  }
88  inline size_t operator-(iterator it) {
89  return (ptr - it.getPtr());
90  }
91 
92  };
93 
94  // default constructor
95  inline Vector(int len = 20) {
96  resize_internal(len, false);
97  }
98 
99  // allocate size and initialize array
100  inline Vector(int size, T value) {
101  resize(size);
102  for (int j=0;j< size;j++){
103  data[j] = value;
104  }
105  }
106 
107  // copy constructor
108  inline Vector( Vector<T> &copyFrom) {
109  resize_internal(copyFrom.size(), false);
110  for (int j=0;j<copyFrom.size();j++){
111  data[j] = copyFrom[j];
112  }
113  this->len = copyFrom.size();
114  }
115 
116  // legacy constructor with pointer range
117  inline Vector(T *from, T *to) {
118  this->len = to - from;
119  resize_internal(this->len, false);
120  for (size_t j=0;j<this->len;j++){
121  data[j] = from[j];
122  }
123  }
124 
125  inline ~Vector() {
126  clear();
127  shrink_to_fit();
128  delete [] this->data;
129  }
130 
131  inline void clear() {
132  len = 0;
133  }
134 
135  inline int size() {
136  return len;
137  }
138 
139  inline bool empty() {
140  return size()==0;
141  }
142 
143  inline void push_back(T value){
144  resize_internal(len+1, true);
145  data[len] = value;
146  len++;
147  }
148 
149  inline void pop_back(){
150  if (len>0) {
151  len--;
152  }
153  }
154 
155  inline void assign(iterator v1, iterator v2) {
156  size_t newLen = v2 - v1;
157  resize_internal(newLen, false);
158  this->len = newLen;
159  int pos = 0;
160  for (auto ptr = v1; ptr != v2; ptr++) {
161  data[pos++] = *ptr;
162  }
163  }
164 
165  inline void assign(size_t number, T value) {
166  resize_internal(number, false);
167  this->len = number;
168  for (int j=0;j<number;j++){
169  data[j]=value;
170  }
171  }
172 
173  inline void swap(Vector<T> &in){
174  // save data
175  T *dataCpy = data;
176  int bufferLenCpy = bufferLen;
177  int lenCpy = len;
178  // swap this
179  data = in.data;
180  len = in.len;
181  bufferLen = in.bufferLen;
182  // swp in
183  in.data = dataCpy;
184  in.len = lenCpy;
185  in.bufferLen = bufferLenCpy;
186  }
187 
188  inline T &operator[](int index) {
189  return data[index];
190  }
191 
192  inline Vector<T> &operator=(Vector<T> &copyFrom) {
193  resize_internal(copyFrom.size(), false);
194  for (int j=0;j<copyFrom.size();j++){
195  data[j] = copyFrom[j];
196  }
197  this->len = copyFrom.size();
198  }
199 
200  inline T &operator[] (const int index) const {
201  return data[index];
202  }
203 
204  inline bool resize(int newSize, T value){
205  if (resize(newSize)){
206  for (int j=0;j<newSize;j++){
207  data[j]=value;
208  }
209  return true;
210  }
211  return false;
212  }
213 
214  inline void shrink_to_fit() {
215  resize_internal(this->len, true, true);
216  }
217 
218  int capacity(){
219  return this->bufferLen;
220  }
221 
222  inline bool resize(int newSize){
223  int oldSize = this->len;
224  resize_internal(newSize, true);
225  this->len = newSize;
226  return this->len!=oldSize;
227  }
228 
229  inline iterator begin(){
230  return iterator(data, 0);
231  }
232 
233  inline T& back(){
234  return *iterator(data+(len-1), len-1);
235  }
236 
237  inline iterator end(){
238  return iterator(data+len, len);
239  }
240 
241  // removes a single element
242  inline void erase(iterator it) {
243  int pos = it.pos();
244  if (pos<len){
245  int lenToEnd = len - pos - 1;
246  // call destructor on data to be erased
247  data[pos].~T();
248  // shift values by 1 position
249  memmove((void*) &data[pos],(void*)(&data[pos+1]),lenToEnd*sizeof(T));
250  // make sure that we have a valid object at the end
251  data[len-1] = T();
252  len--;
253  }
254  }
255 
256  protected:
257  int bufferLen;
258  int len = 0;
259  T *data = nullptr;
260 
261  inline void resize_internal(int newSize, bool copy, bool shrink=false) {
262  bool withNewSize = false;
263  if (newSize>bufferLen || this->data==nullptr ||shrink){
264  withNewSize = true;
265  T* oldData = data;
266  int oldBufferLen = this->bufferLen;
267  this->data = new T[newSize+1];
268  this->bufferLen = newSize;
269  if (oldData != nullptr) {
270  if(copy && this->len > 0){
271  memcpy((void*)data,(void*) oldData, this->len*sizeof(T));
272  }
273  if (shrink){
274  cleanup(oldData, newSize, oldBufferLen);
275  }
276  delete [] oldData;
277  }
278  }
279  }
280 
281  void cleanup(T*data, int from, int to){
282  for (int j=from;j<to;j++){
283  data[j].~T();
284  }
285  }
286 
287 
288 };
Iterator for the Vector class.
Definition: Vector.h:21
Vector implementation which provides the most important methods as defined by std::vector....
Definition: Vector.h:13