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