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