Embedded Template Library  1.0
ivectorpointer.h
Go to the documentation of this file.
1 
3 /******************************************************************************
4 The MIT License(MIT)
5 
6 Embedded Template Library.
7 https://github.com/ETLCPP/etl
8 https://www.etlcpp.com
9 
10 Copyright(c) 2016 jwellbelove
11 
12 Permission is hereby granted, free of charge, to any person obtaining a copy
13 of this software and associated documentation files(the "Software"), to deal
14 in the Software without restriction, including without limitation the rights
15 to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16 copies of the Software, and to permit persons to whom the Software is
17 furnished to do so, subject to the following conditions :
18 
19 The above copyright notice and this permission notice shall be included in all
20 copies or substantial portions of the Software.
21 
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 SOFTWARE.
29 ******************************************************************************/
30 
31 #ifndef ETL_IVECTOR_POINTER_INCLUDED
32 #define ETL_IVECTOR_POINTER_INCLUDED
33 
34 #ifndef ETL_IN_VECTOR_H
35 #error This header is a private element of etl::ivector
36 #endif
37 
38 #include "pvoidvector.h"
39 
40 namespace etl
41 {
42  //***************************************************************************
46  //***************************************************************************
47  template <typename T>
48  class ivector<T*> : public pvoidvector
49  {
50  public:
51 
52  typedef T* value_type;
53  typedef value_type& reference;
54  typedef const value_type& const_reference;
55  typedef value_type* pointer;
56  typedef const value_type* const_pointer;
57  typedef value_type* iterator;
58  typedef const value_type* const_iterator;
59  typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
60  typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
61  typedef size_t size_type;
62  typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
63 
64  protected:
65 
66  typedef value_type parameter_t;
67 
68  private:
69 
70  typedef pvoidvector base_t;
71 
72  public:
73 
74  //*********************************************************************
77  //*********************************************************************
78  iterator begin()
79  {
80  return iterator(base_t::begin());
81  }
82 
83  //*********************************************************************
86  //*********************************************************************
87  const_iterator begin() const
88  {
89  return const_iterator(base_t::begin());
90  }
91 
92  //*********************************************************************
95  //*********************************************************************
96  iterator end()
97  {
98  return iterator(base_t::end());
99  }
100 
101  //*********************************************************************
104  //*********************************************************************
105  const_iterator end() const
106  {
107  return const_iterator(base_t::end());
108  }
109 
110  //*********************************************************************
113  //*********************************************************************
114  const_iterator cbegin() const
115  {
116  return const_iterator(base_t::cbegin());
117  }
118 
119  //*********************************************************************
122  //*********************************************************************
123  const_iterator cend() const
124  {
125  return const_iterator(base_t::cend());
126  }
127 
128  //*********************************************************************
131  //*********************************************************************
132  reverse_iterator rbegin()
133  {
134  return reverse_iterator(iterator(base_t::end()));
135  }
136 
137  //*********************************************************************
140  //*********************************************************************
141  const_reverse_iterator rbegin() const
142  {
143  return const_reverse_iterator(const_iterator(base_t::end()));
144  }
145 
146  //*********************************************************************
149  //*********************************************************************
150  reverse_iterator rend()
151  {
152  return reverse_iterator(iterator(base_t::begin()));
153  }
154 
155  //*********************************************************************
158  //*********************************************************************
159  const_reverse_iterator rend() const
160  {
161  return const_reverse_iterator(const_iterator(base_t::begin()));
162  }
163 
164  //*********************************************************************
167  //*********************************************************************
168  const_reverse_iterator crbegin() const
169  {
170  return const_reverse_iterator(const_iterator(base_t::cend()));
171  }
172 
173  //*********************************************************************
176  //*********************************************************************
177  const_reverse_iterator crend() const
178  {
179  return const_reverse_iterator(const_iterator(base_t::cbegin()));
180  }
181 
182  //*********************************************************************
187  //*********************************************************************
188  void resize(size_t new_size)
189  {
190  base_t::resize(new_size);
191  }
192 
193  //*********************************************************************
199  //*********************************************************************
200  void resize(size_t new_size, value_type value)
201  {
202  base_t::resize(new_size, value);
203  }
204 
205  //*********************************************************************
209  //*********************************************************************
210  reference operator [](size_t i)
211  {
212  return reference(base_t::operator[](i));
213  }
214 
215  //*********************************************************************
219  //*********************************************************************
220  const_reference operator [](size_t i) const
221  {
222  return const_reference(base_t::operator[](i));
223  }
224 
225  //*********************************************************************
230  //*********************************************************************
231  reference at(size_t i)
232  {
233  return reference(base_t::at(i));
234  }
235 
236  //*********************************************************************
241  //*********************************************************************
242  const_reference at(size_t i) const
243  {
244  return const_reference(base_t::at(i));
245  }
246 
247  //*********************************************************************
250  //*********************************************************************
251  reference front()
252  {
253  return reference(base_t::front());
254  }
255 
256  //*********************************************************************
259  //*********************************************************************
260  const_reference front() const
261  {
262  return const_reference(base_t::front());
263  }
264 
265  //*********************************************************************
268  //*********************************************************************
269  reference back()
270  {
271  return reference(base_t::back());
272  }
273 
274  //*********************************************************************
277  //*********************************************************************
278  const_reference back() const
279  {
280  return const_reference(base_t::back());
281  }
282 
283  //*********************************************************************
286  //*********************************************************************
287  pointer data()
288  {
289  return pointer(base_t::data());
290  }
291 
292  //*********************************************************************
295  //*********************************************************************
296  const_pointer data() const
297  {
298  return const_pointer(base_t::data());
299  }
300 
301  //*********************************************************************
307  //*********************************************************************
308  template <typename TIterator>
309  void assign(TIterator first, TIterator last)
310  {
311  base_t::assign(first, last);
312  }
313 
314  //*********************************************************************
319  //*********************************************************************
320  void assign(size_t n, parameter_t value)
321  {
322  base_t::assign(n, value);
323  }
324 
325  //*************************************************************************
327  //*************************************************************************
328  void clear()
329  {
330  base_t::clear();
331  }
332 
333  //*********************************************************************
337  //*********************************************************************
338  void push_back(parameter_t value)
339  {
340  base_t::push_back(value);
341  }
342 
343  //*********************************************************************
347  //*********************************************************************
348  void emplace_back(parameter_t value)
349  {
350  base_t::emplace_back(value);
351  }
352 
353  //*************************************************************************
356  //*************************************************************************
357  void pop_back()
358  {
359  base_t::pop_back();
360  }
361 
362  //*********************************************************************
367  //*********************************************************************
368  iterator insert(iterator position, parameter_t value)
369  {
370  return iterator(base_t::insert(base_t::iterator(position), value));
371  }
372 
373  //*************************************************************************
375  //*************************************************************************
376  iterator emplace(iterator position, parameter_t value)
377  {
378  return iterator(base_t::emplace(base_t::iterator(position), value));
379  }
380 
381  //*********************************************************************
387  //*********************************************************************
388  void insert(iterator position, size_t n, parameter_t value)
389  {
390  base_t::insert(base_t::iterator(position), n, value);
391  }
392 
393  //*********************************************************************
399  //*********************************************************************
400  template <class TIterator>
401  void insert(iterator position, TIterator first, TIterator last)
402  {
403  base_t::insert(base_t::iterator(position), first, last);
404  }
405 
406  //*********************************************************************
410  //*********************************************************************
411  iterator erase(iterator i_element)
412  {
413  return iterator(base_t::erase(base_t::iterator(i_element)));
414  }
415 
416  //*********************************************************************
423  //*********************************************************************
424  iterator erase(iterator first, iterator last)
425  {
426  return iterator(base_t::erase(base_t::iterator(first), base_t::iterator(last)));
427  }
428 
429  //*************************************************************************
431  //*************************************************************************
432  ivector& operator = (const ivector& rhs)
433  {
434  base_t::operator = (rhs);
435 
436  return *this;
437  }
438 
439 #if ETL_CPP11_SUPPORTED
440  //*************************************************************************
442  //*************************************************************************
443  ivector& operator = (ivector&& rhs)
444  {
445  (void)base_t::operator = (etl::move(rhs));
446 
447  return *this;
448  }
449 #endif
450 
451 #ifdef ETL_IVECTOR_REPAIR_ENABLE
452  //*************************************************************************
454  //*************************************************************************
455  virtual void repair() = 0;
456 #endif
457 
458  protected:
459 
460  //*********************************************************************
462  //*********************************************************************
463  ivector(T** p_buffer_, size_t MAX_SIZE_)
464  : pvoidvector(reinterpret_cast<void**>(p_buffer_), MAX_SIZE_)
465  {
466  }
467  };
468 
469  template <typename T>
470  class ivector<const T*> : public pvoidvector
471  {
472  public:
473 
474  typedef const T* value_type;
475  typedef value_type& reference;
476  typedef const value_type& const_reference;
477  typedef value_type* pointer;
478  typedef const value_type* const_pointer;
479  typedef value_type* iterator;
480  typedef const value_type* const_iterator;
481  typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
482  typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
483  typedef size_t size_type;
484  typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
485 
486  protected:
487 
488  typedef value_type parameter_t;
489 
490  private:
491 
492  typedef pvoidvector base_t;
493 
494  public:
495 
496  //*********************************************************************
499  //*********************************************************************
500  iterator begin()
501  {
502  return iterator(base_t::begin());
503  }
504 
505  //*********************************************************************
508  //*********************************************************************
509  const_iterator begin() const
510  {
511  return const_iterator(base_t::begin());
512  }
513 
514  //*********************************************************************
517  //*********************************************************************
518  iterator end()
519  {
520  return iterator(base_t::end());
521  }
522 
523  //*********************************************************************
526  //*********************************************************************
527  const_iterator end() const
528  {
529  return const_iterator(base_t::end());
530  }
531 
532  //*********************************************************************
535  //*********************************************************************
536  const_iterator cbegin() const
537  {
538  return const_iterator(base_t::cbegin());
539  }
540 
541  //*********************************************************************
544  //*********************************************************************
545  const_iterator cend() const
546  {
547  return const_iterator(base_t::cend());
548  }
549 
550  //*********************************************************************
553  //*********************************************************************
554  reverse_iterator rbegin()
555  {
556  return reverse_iterator(iterator(base_t::end()));
557  }
558 
559  //*********************************************************************
562  //*********************************************************************
563  const_reverse_iterator rbegin() const
564  {
565  return const_reverse_iterator(const_iterator(base_t::end()));
566  }
567 
568  //*********************************************************************
571  //*********************************************************************
572  reverse_iterator rend()
573  {
574  return reverse_iterator(iterator(base_t::begin()));
575  }
576 
577  //*********************************************************************
580  //*********************************************************************
581  const_reverse_iterator rend() const
582  {
583  return const_reverse_iterator(const_iterator(base_t::begin()));
584  }
585 
586  //*********************************************************************
589  //*********************************************************************
590  const_reverse_iterator crbegin() const
591  {
592  return const_reverse_iterator(const_iterator(base_t::cend()));
593  }
594 
595  //*********************************************************************
598  //*********************************************************************
599  const_reverse_iterator crend() const
600  {
601  return const_reverse_iterator(const_iterator(base_t::cbegin()));
602  }
603 
604  //*********************************************************************
609  //*********************************************************************
610  void resize(size_t new_size)
611  {
612  base_t::resize(new_size);
613  }
614 
615  //*********************************************************************
621  //*********************************************************************
622  void resize(size_t new_size, value_type value)
623  {
624  base_t::resize(new_size, const_cast<T*>(value));
625  }
626 
627  //*********************************************************************
631  //*********************************************************************
632  reference operator [](size_t i)
633  {
634  return reference(base_t::operator[](i));
635  }
636 
637  //*********************************************************************
641  //*********************************************************************
642  const_reference operator [](size_t i) const
643  {
644  return const_reference(base_t::operator[](i));
645  }
646 
647  //*********************************************************************
652  //*********************************************************************
653  reference at(size_t i)
654  {
655  return reference(base_t::at(i));
656  }
657 
658  //*********************************************************************
663  //*********************************************************************
664  const_reference at(size_t i) const
665  {
666  return const_reference(base_t::at(i));
667  }
668 
669  //*********************************************************************
672  //*********************************************************************
673  reference front()
674  {
675  return reference(base_t::front());
676  }
677 
678  //*********************************************************************
681  //*********************************************************************
682  const_reference front() const
683  {
684  return const_reference(base_t::front());
685  }
686 
687  //*********************************************************************
690  //*********************************************************************
691  reference back()
692  {
693  return reference(base_t::back());
694  }
695 
696  //*********************************************************************
699  //*********************************************************************
700  const_reference back() const
701  {
702  return const_reference(base_t::back());
703  }
704 
705  //*********************************************************************
708  //*********************************************************************
709  pointer data()
710  {
711  return pointer(base_t::data());
712  }
713 
714  //*********************************************************************
717  //*********************************************************************
718  const_pointer data() const
719  {
720  return const_pointer(base_t::data());
721  }
722 
723  //*********************************************************************
729  //*********************************************************************
730  template <typename TIterator>
731  void assign(TIterator first, TIterator last)
732  {
733  base_t::assign(first, last);
734  }
735 
736  //*********************************************************************
741  //*********************************************************************
742  void assign(size_t n, parameter_t value)
743  {
744  base_t::assign(n, const_cast<T*>(value));
745  }
746 
747  //*************************************************************************
749  //*************************************************************************
750  void clear()
751  {
752  base_t::clear();
753  }
754 
755  //*********************************************************************
759  //*********************************************************************
760  void push_back(parameter_t value)
761  {
762  base_t::push_back(const_cast<T*>(value));
763  }
764 
765  //*************************************************************************
768  //*************************************************************************
769  void pop_back()
770  {
771  base_t::pop_back();
772  }
773 
774  //*********************************************************************
779  //*********************************************************************
780  iterator insert(iterator position, parameter_t value)
781  {
782  return iterator(base_t::insert(base_t::iterator(position), const_cast<T*>(value)));
783  }
784 
785  //*********************************************************************
791  //*********************************************************************
792  void insert(iterator position, size_t n, parameter_t value)
793  {
794  base_t::insert(base_t::iterator(position), n, const_cast<T*>(value));
795  }
796 
797  //*********************************************************************
803  //*********************************************************************
804  template <class TIterator>
805  void insert(iterator position, TIterator first, TIterator last)
806  {
807  base_t::insert(base_t::iterator(position), first, last);
808  }
809 
810  //*********************************************************************
814  //*********************************************************************
815  iterator erase(iterator i_element)
816  {
817  return iterator(base_t::erase(base_t::iterator(i_element)));
818  }
819 
820  //*********************************************************************
827  //*********************************************************************
828  iterator erase(iterator first, iterator last)
829  {
830  return iterator(base_t::erase(base_t::iterator(first), base_t::iterator(last)));
831  }
832 
833  //*************************************************************************
835  //*************************************************************************
836  ivector& operator = (const ivector& rhs)
837  {
838  base_t::operator = (rhs);
839 
840  return *this;
841  }
842 
843 #if ETL_CPP11_SUPPORTED
844  //*************************************************************************
846  //*************************************************************************
847  ivector& operator = (ivector&& rhs)
848  {
849  (void)base_t::operator = (etl::move(rhs));
850 
851  return *this;
852  }
853 #endif
854 
855 #ifdef ETL_IVECTOR_REPAIR_ENABLE
856  //*************************************************************************
858  //*************************************************************************
859  virtual void repair() = 0;
860 #endif
861 
862  protected:
863 
864  //*********************************************************************
866  //*********************************************************************
867  ivector(const T** p_buffer_, size_t MAX_SIZE_)
868  : pvoidvector(reinterpret_cast<void**>(const_cast<T**>(p_buffer_)), MAX_SIZE_)
869  {
870  }
871  };
872 
873  //***************************************************************************
879  //***************************************************************************
880  template <typename T>
881  bool operator ==(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
882  {
883  return pvoidvector_equal(lhs, rhs);
884  }
885 
886  //***************************************************************************
892  //***************************************************************************
893  template <typename T>
894  bool operator !=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
895  {
896  return pvoidvector_not_equal(lhs, rhs);
897  }
898 
899  //***************************************************************************
905  //***************************************************************************
906  template <typename T>
907  bool operator <(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
908  {
909  return pvoidvector_less_than(lhs, rhs);
910  }
911 
912  //***************************************************************************
918  //***************************************************************************
919  template <typename T>
920  bool operator >(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
921  {
922  return pvoidvector_greater_than(lhs, rhs);
923  }
924 
925  //***************************************************************************
931  //***************************************************************************
932  template <typename T>
933  bool operator <=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
934  {
935  return pvoidvector_less_than_equal(lhs, rhs);
936  }
937 
938  //***************************************************************************
944  //***************************************************************************
945  template <typename T>
946  bool operator >=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
947  {
948  return pvoidvector_greater_than_equal(lhs, rhs);
949  }
950 
951  //***************************************************************************
952  // Helper functions
953  //***************************************************************************
954  inline bool pvoidvector_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
955  {
956  return operator ==(lhs, rhs);
957  }
958 
959  inline bool pvoidvector_not_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
960  {
961  return operator !=(lhs, rhs);
962  }
963 
964  inline bool pvoidvector_less_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
965  {
966  return operator <(lhs, rhs);
967  }
968 
969  inline bool pvoidvector_greater_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
970  {
971  return operator >(lhs, rhs);
972  }
973 
974  inline bool pvoidvector_less_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
975  {
976  return operator <=(lhs, rhs);
977  }
978 
979  inline bool pvoidvector_greater_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
980  {
981  return operator >=(lhs, rhs);
982  }
983 }
984 
985 #endif
const_reference front() const
Definition: ivectorpointer.h:682
const_reverse_iterator rbegin() const
Definition: ivectorpointer.h:563
void resize(size_t new_size, value_type value)
Definition: ivectorpointer.h:622
reference front()
Definition: ivectorpointer.h:673
void resize(size_t new_size)
Definition: ivectorpointer.h:610
const_reference back() const
Definition: ivectorpointer.h:700
void insert(iterator position, size_t n, parameter_t value)
Definition: ivectorpointer.h:792
iterator erase(iterator i_element)
Definition: ivectorpointer.h:815
reverse_iterator rbegin()
Definition: ivectorpointer.h:554
ivector(const T **p_buffer_, size_t MAX_SIZE_)
Constructor.
Definition: ivectorpointer.h:867
iterator insert(iterator position, parameter_t value)
Definition: ivectorpointer.h:780
const_iterator cbegin() const
Definition: ivectorpointer.h:536
void insert(iterator position, TIterator first, TIterator last)
Definition: ivectorpointer.h:805
pointer data()
Definition: ivectorpointer.h:709
void push_back(parameter_t value)
Definition: ivectorpointer.h:760
reference at(size_t i)
Definition: ivectorpointer.h:653
const_iterator cend() const
Definition: ivectorpointer.h:545
iterator erase(iterator first, iterator last)
Definition: ivectorpointer.h:828
const_pointer data() const
Definition: ivectorpointer.h:718
iterator end()
Definition: ivectorpointer.h:518
reference back()
Definition: ivectorpointer.h:691
const_reverse_iterator crbegin() const
Definition: ivectorpointer.h:590
const_reverse_iterator crend() const
Definition: ivectorpointer.h:599
const_reference at(size_t i) const
Definition: ivectorpointer.h:664
void pop_back()
Definition: ivectorpointer.h:769
void assign(TIterator first, TIterator last)
Definition: ivectorpointer.h:731
void clear()
Clears the vector.
Definition: ivectorpointer.h:750
const_iterator end() const
Definition: ivectorpointer.h:527
const_reverse_iterator rend() const
Definition: ivectorpointer.h:581
void assign(size_t n, parameter_t value)
Definition: ivectorpointer.h:742
reverse_iterator rend()
Definition: ivectorpointer.h:572
const_iterator begin() const
Definition: ivectorpointer.h:509
iterator begin()
Definition: ivectorpointer.h:500
ETL_CONSTEXPR TContainer::const_iterator cbegin(const TContainer &container)
Definition: container.h:69
ETL_CONSTEXPR TContainer::iterator begin(TContainer &container)
Definition: container.h:49
ETL_CONSTEXPR TContainer::const_iterator cend(const TContainer &container)
Definition: container.h:119
ETL_CONSTEXPR TContainer::iterator end(TContainer &container)
Definition: container.h:99
reference front()
Definition: ivectorpointer.h:251
reverse_iterator rend()
Definition: ivectorpointer.h:150
const_reverse_iterator rbegin() const
Definition: ivectorpointer.h:141
void assign(TIterator first, TIterator last)
Definition: ivectorpointer.h:309
void push_back(parameter_t value)
Definition: ivectorpointer.h:338
const_iterator begin() const
Definition: ivectorpointer.h:87
const_iterator cbegin() const
Definition: ivectorpointer.h:114
iterator emplace(iterator position, parameter_t value)
Emplaces a value to the vector at the specified position.
Definition: ivectorpointer.h:376
void pop_back()
Definition: ivectorpointer.h:357
const_reference front() const
Definition: ivectorpointer.h:260
void assign(size_t n, parameter_t value)
Definition: ivectorpointer.h:320
void insert(iterator position, TIterator first, TIterator last)
Definition: ivectorpointer.h:401
reference back()
Definition: ivectorpointer.h:269
const_reference at(size_t i) const
Definition: ivectorpointer.h:242
const_reverse_iterator crend() const
Definition: ivectorpointer.h:177
const_reference back() const
Definition: ivectorpointer.h:278
void emplace_back(parameter_t value)
Definition: ivectorpointer.h:348
void resize(size_t new_size, value_type value)
Definition: ivectorpointer.h:200
const_reverse_iterator rend() const
Definition: ivectorpointer.h:159
const_iterator end() const
Definition: ivectorpointer.h:105
iterator insert(iterator position, parameter_t value)
Definition: ivectorpointer.h:368
const_iterator cend() const
Definition: ivectorpointer.h:123
reverse_iterator rbegin()
Definition: ivectorpointer.h:132
reference at(size_t i)
Definition: ivectorpointer.h:231
iterator erase(iterator first, iterator last)
Definition: ivectorpointer.h:424
iterator erase(iterator i_element)
Definition: ivectorpointer.h:411
iterator end()
Definition: ivectorpointer.h:96
ivector(T **p_buffer_, size_t MAX_SIZE_)
Constructor.
Definition: ivectorpointer.h:463
void insert(iterator position, size_t n, parameter_t value)
Definition: ivectorpointer.h:388
const_reverse_iterator crbegin() const
Definition: ivectorpointer.h:168
iterator begin()
Definition: ivectorpointer.h:78
pointer data()
Definition: ivectorpointer.h:287
const_pointer data() const
Definition: ivectorpointer.h:296
void clear()
Clears the vector.
Definition: ivectorpointer.h:328
void resize(size_t new_size)
Definition: ivectorpointer.h:188
Definition: vector.h:80
Definition: ivectorpointer.h:49
Definition: pvoidvector.h:60
Definition: absolute.h:37
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:645
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:594
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:582
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:606
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:621