Embedded Template Library 1.0
ivectorpointer.h
Go to the documentation of this file.
1
2
3/******************************************************************************
4The MIT License(MIT)
5
6Embedded Template Library.
7https://github.com/ETLCPP/etl
8https://www.etlcpp.com
9
10Copyright(c) 2016 John Wellbelove
11
12Permission is hereby granted, free of charge, to any person obtaining a copy
13of this software and associated documentation files(the "Software"), to deal
14in the Software without restriction, including without limitation the rights
15to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16copies of the Software, and to permit persons to whom the Software is
17furnished to do so, subject to the following conditions :
18
19The above copyright notice and this permission notice shall be included in all
20copies or substantial portions of the Software.
21
22THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28SOFTWARE.
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
40namespace 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 //*********************************************************************
208 //*********************************************************************
209 void uninitialized_resize(size_t new_size)
210 {
211 base_t::uninitialized_resize(new_size);
212 }
213
214 //*********************************************************************
218 //*********************************************************************
219 reference operator [](size_t i)
220 {
221 return reference(base_t::operator[](i));
222 }
223
224 //*********************************************************************
228 //*********************************************************************
229 const_reference operator [](size_t i) const
230 {
231 return const_reference(base_t::operator[](i));
232 }
233
234 //*********************************************************************
239 //*********************************************************************
240 reference at(size_t i)
241 {
242 return reference(base_t::at(i));
243 }
244
245 //*********************************************************************
250 //*********************************************************************
251 const_reference at(size_t i) const
252 {
253 return const_reference(base_t::at(i));
254 }
255
256 //*********************************************************************
259 //*********************************************************************
260 reference front()
261 {
262 return reference(base_t::front());
263 }
264
265 //*********************************************************************
268 //*********************************************************************
269 const_reference front() const
270 {
271 return const_reference(base_t::front());
272 }
273
274 //*********************************************************************
277 //*********************************************************************
278 reference back()
279 {
280 return reference(base_t::back());
281 }
282
283 //*********************************************************************
286 //*********************************************************************
287 const_reference back() const
288 {
289 return const_reference(base_t::back());
290 }
291
292 //*********************************************************************
295 //*********************************************************************
296 pointer data()
297 {
298 return pointer(base_t::data());
299 }
300
301 //*********************************************************************
304 //*********************************************************************
305 const_pointer data() const
306 {
307 return const_pointer(base_t::data());
308 }
309
310 //*********************************************************************
316 //*********************************************************************
317 template <typename TIterator>
318 void assign(TIterator first, TIterator last)
319 {
320 base_t::assign(first, last);
321 }
322
323 //*********************************************************************
328 //*********************************************************************
329 void assign(size_t n, parameter_t value)
330 {
331 base_t::assign(n, value);
332 }
333
334 //*************************************************************************
336 //*************************************************************************
337 void clear()
338 {
339 base_t::clear();
340 }
341
342 //*********************************************************************
346 //*********************************************************************
347 void push_back(parameter_t value)
348 {
349 base_t::push_back(value);
350 }
351
352 //*********************************************************************
356 //*********************************************************************
357 reference emplace_back(parameter_t value)
358 {
359 base_t::emplace_back(value);
360
361 return back();
362 }
363
364 //*************************************************************************
367 //*************************************************************************
368 void pop_back()
369 {
370 base_t::pop_back();
371 }
372
373 //*********************************************************************
378 //*********************************************************************
379 iterator insert(const_iterator position, parameter_t value)
380 {
381 return iterator(base_t::insert(base_t::iterator(position), value));
382 }
383
384 //*************************************************************************
386 //*************************************************************************
387 iterator emplace(const_iterator position, parameter_t value)
388 {
389 return iterator(base_t::emplace(base_t::iterator(position), value));
390 }
391
392 //*********************************************************************
398 //*********************************************************************
399 void insert(const_iterator position, size_t n, parameter_t value)
400 {
401 base_t::insert(base_t::iterator(position), n, value);
402 }
403
404 //*********************************************************************
410 //*********************************************************************
411 template <class TIterator>
412 void insert(const_iterator position, TIterator first, TIterator last)
413 {
414 base_t::insert(base_t::iterator(position), first, last);
415 }
416
417 //*********************************************************************
421 //*********************************************************************
422 iterator erase(iterator i_element)
423 {
424 return iterator(base_t::erase(base_t::iterator(i_element)));
425 }
426
427 //*********************************************************************
431 //*********************************************************************
432 iterator erase(const_iterator i_element)
433 {
434 return iterator(base_t::erase(base_t::const_iterator(i_element)));
435 }
436
437 //*********************************************************************
444 //*********************************************************************
445 iterator erase(const_iterator first, const_iterator last)
446 {
447 return iterator(base_t::erase(base_t::const_iterator(first), base_t::const_iterator(last)));
448 }
449
450 //*************************************************************************
452 //*************************************************************************
453 ivector& operator = (const ivector& rhs)
454 {
455 base_t::operator = (rhs);
456
457 return *this;
458 }
459
460#if ETL_USING_CPP11
461 //*************************************************************************
463 //*************************************************************************
464 ivector& operator = (ivector&& rhs)
465 {
466 (void)base_t::operator = (etl::move(rhs));
467
468 return *this;
469 }
470#endif
471
472#ifdef ETL_IVECTOR_REPAIR_ENABLE
473 //*************************************************************************
475 //*************************************************************************
476 virtual void repair() = 0;
477#endif
478
479 protected:
480
481 //*********************************************************************
483 //*********************************************************************
484 ivector(T** p_buffer_, size_t MAX_SIZE_)
485 : pvoidvector(reinterpret_cast<void**>(p_buffer_), MAX_SIZE_)
486 {
487 }
488 };
489
490 template <typename T>
491 class ivector<const T*> : public pvoidvector
492 {
493 public:
494
495 typedef const T* value_type;
496 typedef value_type& reference;
497 typedef const value_type& const_reference;
498 typedef value_type* pointer;
499 typedef const value_type* const_pointer;
500 typedef value_type* iterator;
501 typedef const value_type* const_iterator;
502 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
503 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
504 typedef size_t size_type;
505 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
506
507 protected:
508
509 typedef value_type parameter_t;
510
511 private:
512
513 typedef pvoidvector base_t;
514
515 public:
516
517 //*********************************************************************
520 //*********************************************************************
521 iterator begin()
522 {
523 return iterator(base_t::begin());
524 }
525
526 //*********************************************************************
529 //*********************************************************************
530 const_iterator begin() const
531 {
532 return const_iterator(base_t::begin());
533 }
534
535 //*********************************************************************
538 //*********************************************************************
539 iterator end()
540 {
541 return iterator(base_t::end());
542 }
543
544 //*********************************************************************
547 //*********************************************************************
548 const_iterator end() const
549 {
550 return const_iterator(base_t::end());
551 }
552
553 //*********************************************************************
556 //*********************************************************************
557 const_iterator cbegin() const
558 {
559 return const_iterator(base_t::cbegin());
560 }
561
562 //*********************************************************************
565 //*********************************************************************
566 const_iterator cend() const
567 {
568 return const_iterator(base_t::cend());
569 }
570
571 //*********************************************************************
574 //*********************************************************************
575 reverse_iterator rbegin()
576 {
577 return reverse_iterator(iterator(base_t::end()));
578 }
579
580 //*********************************************************************
583 //*********************************************************************
584 const_reverse_iterator rbegin() const
585 {
586 return const_reverse_iterator(const_iterator(base_t::end()));
587 }
588
589 //*********************************************************************
592 //*********************************************************************
593 reverse_iterator rend()
594 {
595 return reverse_iterator(iterator(base_t::begin()));
596 }
597
598 //*********************************************************************
601 //*********************************************************************
602 const_reverse_iterator rend() const
603 {
604 return const_reverse_iterator(const_iterator(base_t::begin()));
605 }
606
607 //*********************************************************************
610 //*********************************************************************
611 const_reverse_iterator crbegin() const
612 {
613 return const_reverse_iterator(const_iterator(base_t::cend()));
614 }
615
616 //*********************************************************************
619 //*********************************************************************
620 const_reverse_iterator crend() const
621 {
622 return const_reverse_iterator(const_iterator(base_t::cbegin()));
623 }
624
625 //*********************************************************************
630 //*********************************************************************
631 void resize(size_t new_size)
632 {
633 base_t::resize(new_size);
634 }
635
636 //*********************************************************************
642 //*********************************************************************
643 void resize(size_t new_size, value_type value)
644 {
645 base_t::resize(new_size, const_cast<T*>(value));
646 }
647
648 //*********************************************************************
651 //*********************************************************************
652 void uninitialized_resize(size_t new_size)
653 {
654 base_t::uninitialized_resize(new_size);
655 }
656
657 //*********************************************************************
661 //*********************************************************************
662 reference operator [](size_t i)
663 {
664 return reference(base_t::operator[](i));
665 }
666
667 //*********************************************************************
671 //*********************************************************************
672 const_reference operator [](size_t i) const
673 {
674 return const_reference(base_t::operator[](i));
675 }
676
677 //*********************************************************************
682 //*********************************************************************
683 reference at(size_t i)
684 {
685 return reference(base_t::at(i));
686 }
687
688 //*********************************************************************
693 //*********************************************************************
694 const_reference at(size_t i) const
695 {
696 return const_reference(base_t::at(i));
697 }
698
699 //*********************************************************************
702 //*********************************************************************
703 reference front()
704 {
705 return reference(base_t::front());
706 }
707
708 //*********************************************************************
711 //*********************************************************************
712 const_reference front() const
713 {
714 return const_reference(base_t::front());
715 }
716
717 //*********************************************************************
720 //*********************************************************************
721 reference back()
722 {
723 return reference(base_t::back());
724 }
725
726 //*********************************************************************
729 //*********************************************************************
730 const_reference back() const
731 {
732 return const_reference(base_t::back());
733 }
734
735 //*********************************************************************
738 //*********************************************************************
739 pointer data()
740 {
741 return pointer(base_t::data());
742 }
743
744 //*********************************************************************
747 //*********************************************************************
748 const_pointer data() const
749 {
750 return const_pointer(base_t::data());
751 }
752
753 //*********************************************************************
759 //*********************************************************************
760 template <typename TIterator>
761 void assign(TIterator first, TIterator last)
762 {
763 base_t::assign(first, last);
764 }
765
766 //*********************************************************************
771 //*********************************************************************
772 void assign(size_t n, parameter_t value)
773 {
774 base_t::assign(n, const_cast<T*>(value));
775 }
776
777 //*************************************************************************
779 //*************************************************************************
780 void clear()
781 {
782 base_t::clear();
783 }
784
785 //*********************************************************************
789 //*********************************************************************
790 void push_back(parameter_t value)
791 {
792 base_t::push_back(const_cast<T*>(value));
793 }
794
795 //*************************************************************************
798 //*************************************************************************
799 void pop_back()
800 {
801 base_t::pop_back();
802 }
803
804 //*********************************************************************
809 //*********************************************************************
810 iterator insert(const_iterator position, parameter_t value)
811 {
812 return iterator(base_t::insert(base_t::iterator(position), const_cast<T*>(value)));
813 }
814
815 //*********************************************************************
821 //*********************************************************************
822 void insert(const_iterator position, size_t n, parameter_t value)
823 {
824 base_t::insert(base_t::iterator(position), n, const_cast<T*>(value));
825 }
826
827 //*********************************************************************
833 //*********************************************************************
834 template <class TIterator>
835 void insert(const_iterator position, TIterator first, TIterator last)
836 {
837 base_t::insert(base_t::iterator(position), first, last);
838 }
839
840 //*********************************************************************
844 //*********************************************************************
845 iterator erase(iterator i_element)
846 {
847 return iterator(base_t::erase(base_t::iterator(i_element)));
848 }
849
850 //*********************************************************************
854 //*********************************************************************
855 iterator erase(const_iterator i_element)
856 {
857 return iterator(base_t::erase(base_t::iterator(i_element)));
858 }
859
860 //*********************************************************************
867 //*********************************************************************
868 iterator erase(const_iterator first, const_iterator last)
869 {
870 return iterator(base_t::erase(base_t::iterator(first), base_t::iterator(last)));
871 }
872
873 //*************************************************************************
875 //*************************************************************************
876 ivector& operator = (const ivector& rhs)
877 {
878 base_t::operator = (rhs);
879
880 return *this;
881 }
882
883#if ETL_USING_CPP11
884 //*************************************************************************
886 //*************************************************************************
887 ivector& operator = (ivector&& rhs)
888 {
889 (void)base_t::operator = (etl::move(rhs));
890
891 return *this;
892 }
893#endif
894
895#ifdef ETL_IVECTOR_REPAIR_ENABLE
896 //*************************************************************************
898 //*************************************************************************
899 virtual void repair() = 0;
900#endif
901
902 protected:
903
904 //*********************************************************************
906 //*********************************************************************
907 ivector(const T** p_buffer_, size_t MAX_SIZE_)
908 : pvoidvector(reinterpret_cast<void**>(const_cast<T**>(p_buffer_)), MAX_SIZE_)
909 {
910 }
911 };
912
913 //***************************************************************************
919 //***************************************************************************
920 template <typename T>
921 bool operator ==(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
922 {
923 return pvoidvector_equal(lhs, rhs);
924 }
925
926 //***************************************************************************
932 //***************************************************************************
933 template <typename T>
934 bool operator !=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
935 {
936 return pvoidvector_not_equal(lhs, rhs);
937 }
938
939 //***************************************************************************
945 //***************************************************************************
946 template <typename T>
947 bool operator <(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
948 {
949 return pvoidvector_less_than(lhs, rhs);
950 }
951
952 //***************************************************************************
958 //***************************************************************************
959 template <typename T>
960 bool operator >(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
961 {
962 return pvoidvector_greater_than(lhs, rhs);
963 }
964
965 //***************************************************************************
971 //***************************************************************************
972 template <typename T>
973 bool operator <=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
974 {
975 return pvoidvector_less_than_equal(lhs, rhs);
976 }
977
978 //***************************************************************************
984 //***************************************************************************
985 template <typename T>
986 bool operator >=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
987 {
988 return pvoidvector_greater_than_equal(lhs, rhs);
989 }
990
991 //***************************************************************************
992 // Helper functions
993 //***************************************************************************
994 inline bool pvoidvector_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
995 {
996 return operator ==(lhs, rhs);
997 }
998
999 inline bool pvoidvector_not_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1000 {
1001 return operator !=(lhs, rhs);
1002 }
1003
1004 inline bool pvoidvector_less_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1005 {
1006 return operator <(lhs, rhs);
1007 }
1008
1009 inline bool pvoidvector_greater_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1010 {
1011 return operator >(lhs, rhs);
1012 }
1013
1014 inline bool pvoidvector_less_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1015 {
1016 return operator <=(lhs, rhs);
1017 }
1018
1019 inline bool pvoidvector_greater_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1020 {
1021 return operator >=(lhs, rhs);
1022 }
1023}
1024
1025#endif
const_reference front() const
Definition: ivectorpointer.h:712
const_reverse_iterator rbegin() const
Definition: ivectorpointer.h:584
void resize(size_t new_size, value_type value)
Definition: ivectorpointer.h:643
reference front()
Definition: ivectorpointer.h:703
void resize(size_t new_size)
Definition: ivectorpointer.h:631
void insert(const_iterator position, TIterator first, TIterator last)
Definition: ivectorpointer.h:835
const_reference back() const
Definition: ivectorpointer.h:730
iterator erase(iterator i_element)
Definition: ivectorpointer.h:845
iterator insert(const_iterator position, parameter_t value)
Definition: ivectorpointer.h:810
reverse_iterator rbegin()
Definition: ivectorpointer.h:575
ivector(const T **p_buffer_, size_t MAX_SIZE_)
Constructor.
Definition: ivectorpointer.h:907
void uninitialized_resize(size_t new_size)
Definition: ivectorpointer.h:652
const_iterator cbegin() const
Definition: ivectorpointer.h:557
iterator erase(const_iterator first, const_iterator last)
Definition: ivectorpointer.h:868
pointer data()
Definition: ivectorpointer.h:739
void push_back(parameter_t value)
Definition: ivectorpointer.h:790
reference at(size_t i)
Definition: ivectorpointer.h:683
iterator erase(const_iterator i_element)
Definition: ivectorpointer.h:855
const_iterator cend() const
Definition: ivectorpointer.h:566
const_pointer data() const
Definition: ivectorpointer.h:748
iterator end()
Definition: ivectorpointer.h:539
reference back()
Definition: ivectorpointer.h:721
void insert(const_iterator position, size_t n, parameter_t value)
Definition: ivectorpointer.h:822
const_reverse_iterator crbegin() const
Definition: ivectorpointer.h:611
const_reverse_iterator crend() const
Definition: ivectorpointer.h:620
const_reference at(size_t i) const
Definition: ivectorpointer.h:694
void pop_back()
Definition: ivectorpointer.h:799
void assign(TIterator first, TIterator last)
Definition: ivectorpointer.h:761
void clear()
Clears the vector.
Definition: ivectorpointer.h:780
const_iterator end() const
Definition: ivectorpointer.h:548
const_reverse_iterator rend() const
Definition: ivectorpointer.h:602
void assign(size_t n, parameter_t value)
Definition: ivectorpointer.h:772
reverse_iterator rend()
Definition: ivectorpointer.h:593
const_iterator begin() const
Definition: ivectorpointer.h:530
iterator begin()
Definition: ivectorpointer.h:521
reference front()
Definition: ivectorpointer.h:260
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:318
void push_back(parameter_t value)
Definition: ivectorpointer.h:347
const_iterator begin() const
Definition: ivectorpointer.h:87
const_iterator cbegin() const
Definition: ivectorpointer.h:114
void insert(const_iterator position, TIterator first, TIterator last)
Definition: ivectorpointer.h:412
void pop_back()
Definition: ivectorpointer.h:368
const_reference front() const
Definition: ivectorpointer.h:269
void assign(size_t n, parameter_t value)
Definition: ivectorpointer.h:329
reference back()
Definition: ivectorpointer.h:278
const_reference at(size_t i) const
Definition: ivectorpointer.h:251
const_reverse_iterator crend() const
Definition: ivectorpointer.h:177
iterator emplace(const_iterator position, parameter_t value)
Emplaces a value to the vector at the specified position.
Definition: ivectorpointer.h:387
const_reference back() const
Definition: ivectorpointer.h:287
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
const_iterator cend() const
Definition: ivectorpointer.h:123
void uninitialized_resize(size_t new_size)
Definition: ivectorpointer.h:209
reverse_iterator rbegin()
Definition: ivectorpointer.h:132
reference at(size_t i)
Definition: ivectorpointer.h:240
void insert(const_iterator position, size_t n, parameter_t value)
Definition: ivectorpointer.h:399
iterator erase(iterator i_element)
Definition: ivectorpointer.h:422
iterator erase(const_iterator i_element)
Definition: ivectorpointer.h:432
iterator end()
Definition: ivectorpointer.h:96
ivector(T **p_buffer_, size_t MAX_SIZE_)
Constructor.
Definition: ivectorpointer.h:484
const_reverse_iterator crbegin() const
Definition: ivectorpointer.h:168
iterator begin()
Definition: ivectorpointer.h:78
iterator insert(const_iterator position, parameter_t value)
Definition: ivectorpointer.h:379
pointer data()
Definition: ivectorpointer.h:296
reference emplace_back(parameter_t value)
Definition: ivectorpointer.h:357
const_pointer data() const
Definition: ivectorpointer.h:305
iterator erase(const_iterator first, const_iterator last)
Definition: ivectorpointer.h:445
void clear()
Clears the vector.
Definition: ivectorpointer.h:337
void resize(size_t new_size)
Definition: ivectorpointer.h:188
Definition: vector.h:72
Definition: ivectorpointer.h:49
Definition: pvoidvector.h:55
bitset_ext
Definition: absolute.h:38
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:684
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:696
ETL_CONSTEXPR TContainer::const_iterator cbegin(const TContainer &container)
Definition: iterator.h:951
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:645
etl::ivector< T >::difference_type erase(etl::ivector< T > &v, const U &value)
erase
Definition: vector.h:1805
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
ETL_CONSTEXPR TContainer::iterator begin(TContainer &container)
Definition: iterator.h:931
ETL_CONSTEXPR TContainer::const_iterator cend(const TContainer &container)
Definition: iterator.h:981
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:657
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:672
ETL_CONSTEXPR TContainer::iterator end(TContainer &container)
Definition: iterator.h:961