Embedded Template Library 1.0
vector.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) 2014 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_VECTOR_INCLUDED
32#define ETL_VECTOR_INCLUDED
33
34#define ETL_IN_VECTOR_H
35
36#include "platform.h"
37#include "algorithm.h"
38#include "type_traits.h"
39#include "error_handler.h"
40#include "memory.h"
41#include "alignment.h"
42#include "array.h"
43#include "exception.h"
44#include "debug_count.h"
45#include "private/vector_base.h"
46#include "iterator.h"
47#include "functional.h"
48#include "static_assert.h"
49#include "placement_new.h"
50#include "algorithm.h"
51#include "initializer_list.h"
52
53#include <stddef.h>
54#include <stdint.h>
55#include <stddef.h>
56
57//*****************************************************************************
61//*****************************************************************************
62
63namespace etl
64{
65 //***************************************************************************
69 //***************************************************************************
70 template <typename T>
72 {
73 public:
74
75 typedef T value_type;
76 typedef T& reference;
77 typedef const T& const_reference;
78#if ETL_USING_CPP11
79 typedef T&& rvalue_reference;
80#endif
81 typedef T* pointer;
82 typedef const T* const_pointer;
83 typedef T* iterator;
84 typedef const T* const_iterator;
85 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
86 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
87 typedef size_t size_type;
88 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
89
90 protected:
91
93
94 public:
95
96 //*********************************************************************
99 //*********************************************************************
100 iterator begin()
101 {
102 return p_buffer;
103 }
104
105 //*********************************************************************
108 //*********************************************************************
109 const_iterator begin() const
110 {
111 return p_buffer;
112 }
113
114 //*********************************************************************
117 //*********************************************************************
118 iterator end()
119 {
120 return p_end;
121 }
122
123 //*********************************************************************
126 //*********************************************************************
127 const_iterator end() const
128 {
129 return p_end;
130 }
131
132 //*********************************************************************
135 //*********************************************************************
136 const_iterator cbegin() const
137 {
138 return p_buffer;
139 }
140
141 //*********************************************************************
144 //*********************************************************************
145 const_iterator cend() const
146 {
147 return p_end;
148 }
149
150 //*********************************************************************
153 //*********************************************************************
154 reverse_iterator rbegin()
155 {
156 return reverse_iterator(end());
157 }
158
159 //*********************************************************************
162 //*********************************************************************
163 const_reverse_iterator rbegin() const
164 {
165 return const_reverse_iterator(end());
166 }
167
168 //*********************************************************************
171 //*********************************************************************
172 reverse_iterator rend()
173 {
174 return reverse_iterator(begin());
175 }
176
177 //*********************************************************************
180 //*********************************************************************
181 const_reverse_iterator rend() const
182 {
183 return const_reverse_iterator(begin());
184 }
185
186 //*********************************************************************
189 //*********************************************************************
190 const_reverse_iterator crbegin() const
191 {
192 return const_reverse_iterator(cend());
193 }
194
195 //*********************************************************************
198 //*********************************************************************
199 const_reverse_iterator crend() const
200 {
201 return const_reverse_iterator(cbegin());
202 }
203
204 //*********************************************************************
209 //*********************************************************************
210 void resize(size_t new_size)
211 {
212 resize(new_size, T());
213 }
214
215 //*********************************************************************
221 //*********************************************************************
222 void resize(size_t new_size, const_reference value)
223 {
224 ETL_ASSERT_OR_RETURN(new_size <= CAPACITY, ETL_ERROR(vector_full));
225
226 const size_t current_size = size();
227 size_t delta = (current_size < new_size) ? new_size - current_size : current_size - new_size;
228
229 if (current_size < new_size)
230 {
231 etl::uninitialized_fill_n(p_end, delta, value);
232 ETL_ADD_DEBUG_COUNT(delta)
233 }
234 else
235 {
236 etl::destroy_n(p_end - delta, delta);
237 ETL_SUBTRACT_DEBUG_COUNT(delta)
238 }
239
240 p_end = p_buffer + new_size;
241 }
242
243 //*********************************************************************
246 //*********************************************************************
247 void uninitialized_resize(size_t new_size)
248 {
249 ETL_ASSERT_OR_RETURN(new_size <= CAPACITY, ETL_ERROR(vector_full));
250
251#if defined(ETL_DEBUG_COUNT)
252 if (size() < new_size)
253 {
254 ETL_ADD_DEBUG_COUNT(new_size - size())
255 }
256 else
257 {
258 ETL_SUBTRACT_DEBUG_COUNT(size() - new_size)
259 }
260#endif
261
262 p_end = p_buffer + new_size;
263 }
264
265 //*********************************************************************
268 //*********************************************************************
269 void reserve(size_t)
270 {
271 }
272
273 //*********************************************************************
277 //*********************************************************************
278 reference operator [](size_t i)
279 {
280 return p_buffer[i];
281 }
282
283 //*********************************************************************
287 //*********************************************************************
288 const_reference operator [](size_t i) const
289 {
290 return p_buffer[i];
291 }
292
293 //*********************************************************************
298 //*********************************************************************
299 reference at(size_t i)
300 {
301 ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
302 return p_buffer[i];
303 }
304
305 //*********************************************************************
310 //*********************************************************************
311 const_reference at(size_t i) const
312 {
313 ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
314 return p_buffer[i];
315 }
316
317 //*********************************************************************
320 //*********************************************************************
321 reference front()
322 {
323 return *p_buffer;
324 }
325
326 //*********************************************************************
329 //*********************************************************************
330 const_reference front() const
331 {
332 return *p_buffer;
333 }
334
335 //*********************************************************************
338 //*********************************************************************
339 reference back()
340 {
341 return *(p_end - 1);
342 }
343
344 //*********************************************************************
347 //*********************************************************************
348 const_reference back() const
349 {
350 return *(p_end - 1);
351 }
352
353 //*********************************************************************
356 //*********************************************************************
357 pointer data()
358 {
359 return p_buffer;
360 }
361
362 //*********************************************************************
365 //*********************************************************************
366 const_pointer data() const
367 {
368 return p_buffer;
369 }
370
371 //*********************************************************************
377 //*********************************************************************
378 template <typename TIterator>
380 assign(TIterator first, TIterator last)
381 {
382 ETL_STATIC_ASSERT((etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<typename etl::iterator_traits<TIterator>::value_type>::type>::value), "Iterator type does not match container type");
383
384#if ETL_IS_DEBUG_BUILD
385 difference_type d = etl::distance(first, last);
386 ETL_ASSERT_OR_RETURN(static_cast<size_t>(d) <= CAPACITY, ETL_ERROR(vector_full));
387#endif
388
389 initialise();
390
391 p_end = etl::uninitialized_copy(first, last, p_buffer);
392 ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last)))
393 }
394
395 //*********************************************************************
400 //*********************************************************************
401 void assign(size_t n, parameter_t value)
402 {
403 ETL_ASSERT_OR_RETURN(n <= CAPACITY, ETL_ERROR(vector_full));
404
405 initialise();
406
408 ETL_ADD_DEBUG_COUNT(uint32_t(n))
409 }
410
411 //*************************************************************************
413 //*************************************************************************
414 void clear()
415 {
416 initialise();
417 }
418
419 //*************************************************************************
421 //*************************************************************************
422 void fill(const T& value)
423 {
424 etl::fill(begin(), end(), value);
425 }
426
427 //*********************************************************************
431 //*********************************************************************
432 void push_back(const_reference value)
433 {
434#if defined(ETL_CHECK_PUSH_POP)
435 ETL_ASSERT_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
436#endif
437 create_back(value);
438 }
439
440#if ETL_USING_CPP11
441 //*********************************************************************
445 //*********************************************************************
446 void push_back(rvalue_reference value)
447 {
448#if defined(ETL_CHECK_PUSH_POP)
449 ETL_ASSERT_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
450#endif
451 create_back(etl::move(value));
452 }
453#endif
454
455#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_VECTOR_FORCE_CPP03_IMPLEMENTATION)
456 //*********************************************************************
460 //*********************************************************************
461 template <typename ... Args>
462 reference emplace_back(Args && ... args)
463 {
464#if defined(ETL_CHECK_PUSH_POP)
465 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
466#endif
467 ::new (p_end) T(etl::forward<Args>(args)...);
468 ++p_end;
469 ETL_INCREMENT_DEBUG_COUNT
470 return back();
471 }
472#else
473 //*********************************************************************
477 //*********************************************************************
478 template <typename T1>
479 reference emplace_back(const T1& value1)
480 {
481#if defined(ETL_CHECK_PUSH_POP)
482 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
483#endif
484 ::new (p_end) T(value1);
485 ++p_end;
486 ETL_INCREMENT_DEBUG_COUNT
487 return back();
488 }
489
490 //*********************************************************************
494 //*********************************************************************
495 template <typename T1, typename T2>
496 reference emplace_back(const T1& value1, const T2& value2)
497 {
498#if defined(ETL_CHECK_PUSH_POP)
499 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
500#endif
501 ::new (p_end) T(value1, value2);
502 ++p_end;
503 ETL_INCREMENT_DEBUG_COUNT
504 return back();
505 }
506
507 //*********************************************************************
511 //*********************************************************************
512 template <typename T1, typename T2, typename T3>
513 reference emplace_back(const T1& value1, const T2& value2, const T3& value3)
514 {
515#if defined(ETL_CHECK_PUSH_POP)
516 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
517#endif
518 ::new (p_end) T(value1, value2, value3);
519 ++p_end;
520 ETL_INCREMENT_DEBUG_COUNT
521 return back();
522 }
523
524 //*********************************************************************
528 //*********************************************************************
529 template <typename T1, typename T2, typename T3, typename T4>
530 reference emplace_back(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
531 {
532#if defined(ETL_CHECK_PUSH_POP)
533 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
534#endif
535 ::new (p_end) T(value1, value2, value3, value4);
536 ++p_end;
537 ETL_INCREMENT_DEBUG_COUNT
538 return back();
539 }
540#endif
541
542 //*************************************************************************
545 //*************************************************************************
546 void pop_back()
547 {
548#if defined(ETL_CHECK_PUSH_POP)
549 ETL_ASSERT_OR_RETURN(size() > 0, ETL_ERROR(vector_empty));
550#endif
551 destroy_back();
552 }
553
554 //*********************************************************************
559 //*********************************************************************
560 iterator insert(const_iterator position, const_reference value)
561 {
562 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
563
564 iterator position_ = to_iterator(position);
565
566 if (position_ == end())
567 {
568 create_back(value);
569 }
570 else
571 {
572 create_back(back());
573 etl::move_backward(position_, p_end - 2, p_end - 1);
574 *position_ = value;
575 }
576
577 return position_;
578 }
579
580#if ETL_USING_CPP11
581 //*********************************************************************
586 //*********************************************************************
587 iterator insert(const_iterator position, rvalue_reference value)
588 {
589 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
590
591 iterator position_ = to_iterator(position);
592
593 if (position_ == end())
594 {
595 create_back(etl::move(value));
596 }
597 else
598 {
599 create_back(etl::move(back()));
600 etl::move_backward(position_, p_end - 2, p_end - 1);
601 *position_ = etl::move(value);
602 }
603
604 return position_;
605 }
606#endif
607
608 //*************************************************************************
610 //*************************************************************************
611#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
612 template <typename ... Args>
613 iterator emplace(const_iterator position, Args && ... args)
614 {
615 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
616
617 iterator position_ = to_iterator(position);
618
619 void* p;
620
621 if (position_ == end())
622 {
623 p = p_end++;
624 ETL_INCREMENT_DEBUG_COUNT
625 }
626 else
627 {
628 p = etl::addressof(*position_);
629 create_back(back());
630 etl::move_backward(position_, p_end - 2, p_end - 1);
631 (*position_).~T();
632 }
633
634 ::new (p) T(etl::forward<Args>(args)...);
635
636 return position_;
637 }
638#else
639 template <typename T1>
640 iterator emplace(const_iterator position, const T1& value1)
641 {
642 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
643
644 iterator position_ = to_iterator(position);
645
646 void* p;
647
648 if (position_ == end())
649 {
650 p = p_end++;
651 ETL_INCREMENT_DEBUG_COUNT
652 }
653 else
654 {
655 p = etl::addressof(*position_);
656 create_back(back());
657 etl::move_backward(position_, p_end - 2, p_end - 1);
658 (*position_).~T();
659 }
660
661 ::new (p) T(value1);
662
663 return position_;
664 }
665
666 template <typename T1, typename T2>
667 iterator emplace(const_iterator position, const T1& value1, const T2& value2)
668 {
669 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
670
671 iterator position_ = to_iterator(position);
672
673 void* p;
674
675 if (position_ == end())
676 {
677 p = p_end++;
678 ETL_INCREMENT_DEBUG_COUNT
679 }
680 else
681 {
682 p = etl::addressof(*position_);
683 create_back(back());
684 etl::move_backward(position_, p_end - 2, p_end - 1);
685 (*position_).~T();
686 }
687
688 ::new (p) T(value1, value2);
689
690 return position_;
691 }
692
693 template <typename T1, typename T2, typename T3>
694 iterator emplace(const_iterator position, const T1& value1, const T2& value2, const T3& value3)
695 {
696 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
697
698 iterator position_ = to_iterator(position);
699
700 void* p;
701
702 if (position_ == end())
703 {
704 p = p_end++;
705 ETL_INCREMENT_DEBUG_COUNT
706 }
707 else
708 {
709 p = etl::addressof(*position_);
710 create_back(back());
711 etl::move_backward(position_, p_end - 2, p_end - 1);
712 (*position_).~T();
713 }
714
715 ::new (p) T(value1, value2, value3);
716
717 return position_;
718 }
719
720 template <typename T1, typename T2, typename T3, typename T4>
721 iterator emplace(const_iterator position, const T1& value1, const T2& value2, const T3& value3, const T4& value4)
722 {
723 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
724
725 iterator position_ = to_iterator(position);
726
727 void* p;
728
729 if (position_ == end())
730 {
731 p = p_end++;
732 ETL_INCREMENT_DEBUG_COUNT
733 }
734 else
735 {
736 p = etl::addressof(*position_);
737 create_back(back());
738 etl::move_backward(position_, p_end - 2, p_end - 1);
739 (*position_).~T();
740 }
741
742 ::new (p) T(value1, value2, value3, value4);
743
744 return position_;
745 }
746#endif
747
748 //*********************************************************************
754 //*********************************************************************
755 void insert(const_iterator position, size_t n, parameter_t value)
756 {
757 ETL_ASSERT_OR_RETURN((size() + n) <= CAPACITY, ETL_ERROR(vector_full));
758
759 iterator position_ = to_iterator(position);
760
761 size_t insert_n = n;
762 size_t insert_begin = etl::distance(begin(), position_);
763 size_t insert_end = insert_begin + insert_n;
764
765 // Copy old data.
766 size_t copy_old_n;
767 size_t construct_old_n;
768 iterator p_construct_old;
769
770 if (insert_end > size())
771 {
772 copy_old_n = 0;
773 construct_old_n = size() - insert_begin;
774 p_construct_old = p_buffer + insert_end;
775 }
776 else
777 {
778 copy_old_n = size() - insert_begin - insert_n;
779 construct_old_n = insert_n;
780 p_construct_old = p_end;
781 }
782
783 size_t copy_new_n = construct_old_n;
784 size_t construct_new_n = insert_n - copy_new_n;
785
786 // Construct old.
787 etl::uninitialized_move(p_end - construct_old_n, p_end, p_construct_old);
788 ETL_ADD_DEBUG_COUNT(construct_old_n)
789
790 // Copy old.
791 etl::move_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n);
792
793 // Construct new.
794 etl::uninitialized_fill_n(p_end, construct_new_n, value);
795 ETL_ADD_DEBUG_COUNT(construct_new_n)
796
797 // Copy new.
798 etl::fill_n(p_buffer + insert_begin, copy_new_n, value);
799
800 p_end += n;
801 }
802
803 //*********************************************************************
810 //*********************************************************************
811 template <class TIterator>
812 void insert(const_iterator position, TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
813 {
814 size_t count = etl::distance(first, last);
815
816 ETL_ASSERT_OR_RETURN((size() + count) <= CAPACITY, ETL_ERROR(vector_full));
817
818 size_t insert_n = count;
819 size_t insert_begin = etl::distance(cbegin(), position);
820 size_t insert_end = insert_begin + insert_n;
821
822 // Move old data.
823 size_t copy_old_n;
824 size_t construct_old_n;
825 iterator p_construct_old;
826
827 if (insert_end > size())
828 {
829 copy_old_n = 0;
830 construct_old_n = size() - insert_begin;
831 p_construct_old = p_buffer + insert_end;
832 }
833 else
834 {
835 copy_old_n = size() - insert_begin - insert_n;
836 construct_old_n = insert_n;
837 p_construct_old = p_end;
838 }
839
840 size_t copy_new_n = construct_old_n;
841 size_t construct_new_n = insert_n - copy_new_n;
842
843 // Move construct old.
844 etl::uninitialized_move(p_end - construct_old_n, p_end, p_construct_old);
845 ETL_ADD_DEBUG_COUNT(construct_old_n)
846
847 // Move old.
848 etl::move_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n);
849
850 // Copy construct new.
851 etl::uninitialized_copy(first + copy_new_n, first + copy_new_n + construct_new_n, p_end);
852 ETL_ADD_DEBUG_COUNT(construct_new_n)
853
854 // Copy new.
855 etl::copy(first, first + copy_new_n, p_buffer + insert_begin);
856
857 p_end += count;
858 }
859
860 //*********************************************************************
864 //*********************************************************************
865 iterator erase(iterator i_element)
866 {
867 etl::move(i_element + 1, end(), i_element);
868 destroy_back();
869
870 return i_element;
871 }
872
873 //*********************************************************************
877 //*********************************************************************
878 iterator erase(const_iterator i_element)
879 {
880 iterator i_element_ = to_iterator(i_element);
881
882 etl::move(i_element_ + 1, end(), i_element_);
883 destroy_back();
884
885 return i_element_;
886 }
887
888 //*********************************************************************
895 //*********************************************************************
896 iterator erase(const_iterator first, const_iterator last)
897 {
898 iterator first_ = to_iterator(first);
899 iterator last_ = to_iterator(last);
900
901 if (first == begin() && last == end())
902 {
903 clear();
904 }
905 else
906 {
907 etl::move(last_, end(), first_);
908 size_t n_delete = etl::distance(first_, last_);
909
910 // Destroy the elements left over at the end.
911 etl::destroy(p_end - n_delete, p_end);
912 ETL_SUBTRACT_DEBUG_COUNT(n_delete)
913 p_end -= n_delete;
914 }
915
916 return first_;
917 }
918
919 //*************************************************************************
921 //*************************************************************************
923 {
924 if (&rhs != this)
925 {
926 assign(rhs.cbegin(), rhs.cend());
927 }
928
929 return *this;
930 }
931
932#if ETL_USING_CPP11
933 //*************************************************************************
935 //*************************************************************************
937 {
938 if (&rhs != this)
939 {
940 clear();
941 iterator itr = rhs.begin();
942 while (itr != rhs.end())
943 {
944 push_back(etl::move(*itr));
945 ++itr;
946 }
947
948 rhs.initialise();
949 }
950
951 return *this;
952 }
953#endif
954
955 //*************************************************************************
958 //*************************************************************************
959 size_type size() const
960 {
961 return size_t(p_end - p_buffer);
962 }
963
964 //*************************************************************************
967 //*************************************************************************
968 bool empty() const
969 {
970 return (p_end == p_buffer);
971 }
972
973 //*************************************************************************
976 //*************************************************************************
977 bool full() const
978 {
979 return size() == CAPACITY;
980 }
981
982 //*************************************************************************
985 //*************************************************************************
986 size_t available() const
987 {
988 return max_size() - size();
989 }
990
991#ifdef ETL_IVECTOR_REPAIR_ENABLE
992 //*************************************************************************
994 //*************************************************************************
995 virtual void repair() = 0;
996#endif
997
998 protected:
999
1000 //*********************************************************************
1002 //*********************************************************************
1003 ivector(T* p_buffer_, size_t MAX_SIZE)
1004 : vector_base(MAX_SIZE)
1005 , p_buffer(p_buffer_)
1006 , p_end(p_buffer_)
1007 {
1008 }
1009
1010 //*********************************************************************
1012 //*********************************************************************
1014 {
1016 ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end)))
1017
1018 p_end = p_buffer;
1019 }
1020
1021 //*************************************************************************
1023 //*************************************************************************
1024 void repair_buffer(T* p_buffer_)
1025 {
1026 uintptr_t length = p_end - p_buffer;
1027 p_buffer = p_buffer_;
1028 p_end = p_buffer_ + length;
1029 }
1030
1031 pointer p_buffer;
1032 pointer p_end;
1033
1034 private:
1035
1036 //*********************************************************************
1038 //*********************************************************************
1039 void create_back()
1040 {
1042 ETL_INCREMENT_DEBUG_COUNT
1043
1044 ++p_end;
1045 }
1046
1047 //*********************************************************************
1049 //*********************************************************************
1050 void create_back(const_reference value)
1051 {
1052 etl::create_copy_at(p_end, value);
1053 ETL_INCREMENT_DEBUG_COUNT
1054
1055 ++p_end;
1056 }
1057
1058#if ETL_USING_CPP11
1059 //*********************************************************************
1061 //*********************************************************************
1062 void create_back(rvalue_reference value)
1063 {
1064 etl::create_copy_at(p_end, etl::move(value));
1065 ETL_INCREMENT_DEBUG_COUNT
1066
1067 ++p_end;
1068 }
1069#endif
1070
1071 //*********************************************************************
1073 //*********************************************************************
1074 void destroy_back()
1075 {
1076 --p_end;
1077
1079 ETL_DECREMENT_DEBUG_COUNT
1080 }
1081
1082 // Disable copy construction.
1083 ivector(const ivector&) ETL_DELETE;
1084
1085 private:
1086
1087 //*************************************************************************
1089 //*************************************************************************
1090 ETL_CONSTEXPR iterator to_iterator(const_iterator itr) const
1091 {
1092 return const_cast<iterator>(itr);
1093 }
1094 };
1095
1096 //***************************************************************************
1102 //***************************************************************************
1103 template <typename T>
1104 bool operator ==(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1105 {
1106 return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
1107 }
1108
1109 //***************************************************************************
1115 //***************************************************************************
1116 template <typename T>
1117 bool operator !=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1118 {
1119 return !(lhs == rhs);
1120 }
1121
1122 //***************************************************************************
1128 //***************************************************************************
1129 template <typename T>
1130 bool operator <(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1131 {
1132 return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
1133 }
1134
1135 //***************************************************************************
1141 //***************************************************************************
1142 template <typename T>
1143 bool operator >(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1144 {
1145 return (rhs < lhs);
1146 }
1147
1148 //***************************************************************************
1154 //***************************************************************************
1155 template <typename T>
1156 bool operator <=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1157 {
1158 return !(lhs > rhs);
1159 }
1160
1161 //***************************************************************************
1167 //***************************************************************************
1168 template <typename T>
1169 bool operator >=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1170 {
1171 return !(lhs < rhs);
1172 }
1173}
1174
1175#include "private/ivectorpointer.h"
1176
1177namespace etl
1178{
1179 //***************************************************************************
1184 //***************************************************************************
1185 template <typename T, const size_t MAX_SIZE_>
1186 class vector : public etl::ivector<T>
1187 {
1188 public:
1189
1190 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U), "Zero capacity etl::vector is not valid");
1191
1192 static const size_t MAX_SIZE = MAX_SIZE_;
1193
1194 //*************************************************************************
1196 //*************************************************************************
1198 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1199 {
1200 this->initialise();
1201 }
1202
1203 //*************************************************************************
1206 //*************************************************************************
1207 explicit vector(size_t initial_size)
1208 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1209 {
1210 this->initialise();
1211 this->resize(initial_size);
1212 }
1213
1214 //*************************************************************************
1218 //*************************************************************************
1219 vector(size_t initial_size, typename etl::ivector<T>::parameter_t value)
1220 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1221 {
1222 this->initialise();
1223 this->resize(initial_size, value);
1224 }
1225
1226 //*************************************************************************
1231 //*************************************************************************
1232 template <typename TIterator>
1233 vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1234 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1235 {
1236 this->assign(first, last);
1237 }
1238
1239#if ETL_HAS_INITIALIZER_LIST
1240 //*************************************************************************
1242 //*************************************************************************
1243 vector(std::initializer_list<T> init)
1244 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1245 {
1246 this->assign(init.begin(), init.end());
1247 }
1248#endif
1249
1250 //*************************************************************************
1252 //*************************************************************************
1253 vector(const vector& other)
1254 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1255 {
1256 this->assign(other.begin(), other.end());
1257 }
1258
1259 //*************************************************************************
1261 //*************************************************************************
1263 {
1264 if (&rhs != this)
1265 {
1266 this->assign(rhs.cbegin(), rhs.cend());
1267 }
1268
1269 return *this;
1270 }
1271
1272#if ETL_USING_CPP11
1273 //*************************************************************************
1275 //*************************************************************************
1276 vector(vector&& other)
1277 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1278 {
1279 if (this != &other)
1280 {
1281 this->initialise();
1282
1283 typename etl::ivector<T>::iterator itr = other.begin();
1284 while (itr != other.end())
1285 {
1286 this->push_back(etl::move(*itr));
1287 ++itr;
1288 }
1289
1290 other.initialise();
1291 }
1292 }
1293
1294 //*************************************************************************
1296 //*************************************************************************
1297 vector& operator = (vector&& rhs)
1298 {
1299 if (&rhs != this)
1300 {
1301 this->clear();
1302 typename etl::ivector<T>::iterator itr = rhs.begin();
1303 while (itr != rhs.end())
1304 {
1305 this->push_back(etl::move(*itr));
1306 ++itr;
1307 }
1308
1309 rhs.initialise();
1310 }
1311
1312 return *this;
1313 }
1314#endif
1315
1316 //*************************************************************************
1318 //*************************************************************************
1319#ifdef ETL_IVECTOR_REPAIR_ENABLE
1320 virtual
1321#endif
1323 {
1324 this->clear();
1325 }
1326
1327 //*************************************************************************
1329 //*************************************************************************
1330#ifdef ETL_IVECTOR_REPAIR_ENABLE
1331 virtual
1332#endif
1333 void repair()
1334#ifdef ETL_IVECTOR_REPAIR_ENABLE
1335 ETL_OVERRIDE
1336#endif
1337 {
1339
1341 }
1342
1343 private:
1344
1345 typename etl::aligned_storage<sizeof(T) * MAX_SIZE, etl::alignment_of<T>::value>::type buffer;
1346 };
1347
1348 //*************************************************************************
1350 //*************************************************************************
1351#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
1352 template <typename... T>
1353 vector(T...) -> vector<typename etl::common_type_t<T...>, sizeof...(T)>;
1354#endif
1355
1356 //*************************************************************************
1358 //*************************************************************************
1359#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
1360 template <typename... T>
1361 constexpr auto make_vector(T&&... t) -> etl::vector<typename etl::common_type_t<T...>, sizeof...(T)>
1362 {
1363 return { { etl::forward<T>(t)... } };
1364 }
1365#endif
1366
1367 //***************************************************************************
1372 //***************************************************************************
1373 template <typename T>
1374 class vector_ext : public etl::ivector<T>
1375 {
1376 public:
1377
1378 //*************************************************************************
1380 //*************************************************************************
1381 vector_ext(void* buffer, size_t max_size)
1382 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1383 {
1384 this->initialise();
1385 }
1386
1387 //*************************************************************************
1390 //*************************************************************************
1391 explicit vector_ext(size_t initial_size, void* buffer, size_t max_size)
1392 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1393 {
1394 this->initialise();
1395 this->resize(initial_size);
1396 }
1397
1398 //*************************************************************************
1402 //*************************************************************************
1403 vector_ext(size_t initial_size, typename etl::ivector<T>::parameter_t value, void* buffer, size_t max_size)
1404 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1405 {
1406 this->initialise();
1407 this->resize(initial_size, value);
1408 }
1409
1410 //*************************************************************************
1415 //*************************************************************************
1416 template <typename TIterator>
1417 vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1418 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1419 {
1420 this->assign(first, last);
1421 }
1422
1423#if ETL_HAS_INITIALIZER_LIST
1424 //*************************************************************************
1426 //*************************************************************************
1427 vector_ext(std::initializer_list<T> init, void* buffer, size_t max_size)
1428 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1429 {
1430 this->assign(init.begin(), init.end());
1431 }
1432#endif
1433
1434 //*************************************************************************
1436 //*************************************************************************
1437 vector_ext(const vector_ext& other, void* buffer, size_t max_size)
1438 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1439 {
1440 this->assign(other.begin(), other.end());
1441 }
1442
1443 //*************************************************************************
1445 //*************************************************************************
1447 {
1448 if (&rhs != this)
1449 {
1450 this->assign(rhs.cbegin(), rhs.cend());
1451 }
1452
1453 return *this;
1454 }
1455
1456#if ETL_USING_CPP11
1457 //*************************************************************************
1459 //*************************************************************************
1460 vector_ext(vector_ext&& other, void* buffer, size_t max_size)
1461 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1462 {
1463 if (this != &other)
1464 {
1465 this->initialise();
1466
1467 typename etl::ivector<T>::iterator itr = other.begin();
1468 while (itr != other.end())
1469 {
1470 this->push_back(etl::move(*itr));
1471 ++itr;
1472 }
1473
1474 other.initialise();
1475 }
1476 }
1477
1478 //*************************************************************************
1480 //*************************************************************************
1482 {
1483 if (&rhs != this)
1484 {
1485 this->clear();
1486
1487 typename etl::ivector<T>::iterator itr = rhs.begin();
1488 while (itr != rhs.end())
1489 {
1490 this->push_back(etl::move(*itr));
1491 ++itr;
1492 }
1493
1494 rhs.initialise();
1495 }
1496
1497 return *this;
1498 }
1499#endif
1500
1501 //*************************************************************************
1503 //*************************************************************************
1505 {
1506 this->clear();
1507 }
1508
1509 //*************************************************************************
1511 //*************************************************************************
1512 void repair()
1513#ifdef ETL_IVECTOR_REPAIR_ENABLE
1514 ETL_OVERRIDE
1515#endif
1516 {
1517 }
1518 };
1519
1520 //***************************************************************************
1525 //***************************************************************************
1526 template <typename T, const size_t MAX_SIZE_>
1527 class vector<T*, MAX_SIZE_> : public etl::ivector<T*>
1528 {
1529 public:
1530
1531 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U), "Zero capacity etl::vector is not valid");
1532
1533 static const size_t MAX_SIZE = MAX_SIZE_;
1534
1535 //*************************************************************************
1537 //*************************************************************************
1539 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1540 {
1541 this->initialise();
1542 }
1543
1544 //*************************************************************************
1547 //*************************************************************************
1548 explicit vector(size_t initial_size)
1549 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1550 {
1551 this->initialise();
1552 this->resize(initial_size);
1553 }
1554
1555 //*************************************************************************
1559 //*************************************************************************
1560 vector(size_t initial_size, typename etl::ivector<T*>::parameter_t value)
1561 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1562 {
1563 this->initialise();
1564 this->resize(initial_size, value);
1565 }
1566
1567 //*************************************************************************
1572 //*************************************************************************
1573 template <typename TIterator>
1574 vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1575 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1576 {
1577 this->assign(first, last);
1578 }
1579
1580#if ETL_HAS_INITIALIZER_LIST
1581 //*************************************************************************
1583 //*************************************************************************
1584 vector(std::initializer_list<T*> init)
1585 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1586 {
1587 this->assign(init.begin(), init.end());
1588 }
1589#endif
1590
1591 //*************************************************************************
1593 //*************************************************************************
1594 vector(const vector& other)
1595 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1596 {
1597 (void)etl::ivector<T*>::operator = (other);
1598 }
1599
1600 //*************************************************************************
1602 //*************************************************************************
1603 vector& operator = (const vector& rhs)
1604 {
1605 (void)etl::ivector<T*>::operator = (rhs);
1606
1607 return *this;
1608 }
1609
1610#if ETL_USING_CPP11
1611 //*************************************************************************
1613 //*************************************************************************
1614 vector(vector&& other)
1615 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1616 {
1617 (void)etl::ivector<T*>::operator = (etl::move(other));
1618 }
1619
1620 //*************************************************************************
1622 //*************************************************************************
1623 vector& operator = (vector&& rhs)
1624 {
1625 (void)etl::ivector<T*>::operator = (etl::move(rhs));
1626
1627 return *this;
1628 }
1629#endif
1630
1631 //*************************************************************************
1633 //*************************************************************************
1634 void repair()
1635#ifdef ETL_IVECTOR_REPAIR_ENABLE
1636 ETL_OVERRIDE
1637#endif
1638 {
1640 }
1641
1642 private:
1643
1644 typename etl::aligned_storage<sizeof(T*) * MAX_SIZE, etl::alignment_of<T*>::value>::type buffer;
1645 };
1646
1647 //*************************************************************************
1649 //*************************************************************************
1650#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
1651 template <typename... T>
1652 vector(T*...) -> vector<typename etl::common_type_t<T*...>, sizeof...(T)>;
1653#endif
1654
1655#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
1656 template <typename... T>
1657 constexpr auto make_vector(T*... t) -> etl::vector<typename etl::common_type_t<T*...>, sizeof...(T)>
1658 {
1659 return { { etl::forward<T*>(t)... } };
1660 }
1661#endif
1662
1663 //***************************************************************************
1668 //***************************************************************************
1669 template <typename T>
1670 class vector_ext<T*> : public etl::ivector<T*>
1671 {
1672 public:
1673
1674 //*************************************************************************
1676 //*************************************************************************
1677 vector_ext(void* buffer, size_t max_size)
1678 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1679 {
1680 this->initialise();
1681 }
1682
1683 //*************************************************************************
1686 //*************************************************************************
1687 vector_ext(size_t initial_size, void* buffer, size_t max_size)
1688 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1689 {
1690 this->initialise();
1691 this->resize(initial_size);
1692 }
1693
1694 //*************************************************************************
1698 //*************************************************************************
1699 vector_ext(size_t initial_size, typename etl::ivector<T*>::parameter_t value, void* buffer, size_t max_size)
1700 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1701 {
1702 this->initialise();
1703 this->resize(initial_size, value);
1704 }
1705
1706 //*************************************************************************
1711 //*************************************************************************
1712 template <typename TIterator>
1713 vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1714 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1715 {
1716 this->assign(first, last);
1717 }
1718
1719#if ETL_HAS_INITIALIZER_LIST
1720 //*************************************************************************
1722 //*************************************************************************
1723 vector_ext(std::initializer_list<T*> init, void* buffer, size_t max_size)
1724 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1725 {
1726 this->assign(init.begin(), init.end());
1727 }
1728#endif
1729
1730 //*************************************************************************
1732 //*************************************************************************
1733 vector_ext(const vector_ext& other, void* buffer, size_t max_size)
1734 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1735 {
1736 (void)etl::ivector<T*>::operator = (other);
1737 }
1738
1739 //*************************************************************************
1741 //*************************************************************************
1742 vector_ext(const vector_ext& other) ETL_DELETE;
1743
1744 //*************************************************************************
1746 //*************************************************************************
1747 vector_ext& operator = (const vector_ext& rhs)
1748 {
1749 (void)etl::ivector<T*>::operator = (rhs);
1750
1751 return *this;
1752 }
1753
1754#if ETL_USING_CPP11
1755 //*************************************************************************
1757 //*************************************************************************
1758 vector_ext(vector_ext&& other, void* buffer, size_t max_size)
1759 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1760 {
1761 (void)etl::ivector<T*>::operator = (etl::move(other));
1762 }
1763
1764 //*************************************************************************
1766 //*************************************************************************
1767 vector_ext(vector_ext&& other) ETL_DELETE;
1768
1769 //*************************************************************************
1771 //*************************************************************************
1772 vector_ext& operator = (vector_ext&& rhs)
1773 {
1774 (void)etl::ivector<T*>::operator = (etl::move(rhs));
1775
1776 return *this;
1777 }
1778#endif
1779
1780 //*************************************************************************
1782 //*************************************************************************
1784 {
1785 this->clear();
1786 }
1787
1788 //*************************************************************************
1790 //*************************************************************************
1791 void repair()
1792#ifdef ETL_IVECTOR_REPAIR_ENABLE
1793 ETL_OVERRIDE
1794#endif
1795 {
1796 etl::ivector<T*>::repair_buffer(this->p_buffer);
1797 }
1798 };
1799
1800 //***************************************************************************
1802 //***************************************************************************
1803 template <typename T, typename U>
1804 typename etl::ivector<T>::difference_type
1805 erase(etl::ivector<T>& v, const U& value)
1806 {
1807 typename etl::ivector<T>::iterator itr = etl::remove(v.begin(), v.end(), value);
1808 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
1809 v.erase(itr, v.end());
1810
1811 return d;
1812 }
1813
1814 //***************************************************************************
1816 //***************************************************************************
1817 template <typename T, typename TPredicate>
1818 typename etl::ivector<T>::difference_type
1819 erase_if(etl::ivector<T>& v, TPredicate predicate)
1820 {
1821 typename etl::ivector<T>::iterator itr = etl::remove_if(v.begin(), v.end(), predicate);
1822 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
1823 v.erase(itr, v.end());
1824
1825 return d;
1826 }
1827}
1828
1829#endif
Definition: constant.h:45
ETL_CONSTEXPR14 TIterator remove(TIterator first, TIterator last, const T &value)
Definition: algorithm.h:1934
ETL_CONSTEXPR14 TIterator remove_if(TIterator first, TIterator last, TUnaryPredicate predicate)
Definition: algorithm.h:1963
Definition: alignment.h:221
#define ETL_ASSERT(b, e)
Definition: error_handler.h:316
void create_copy_at(T *p, const T &value)
Definition: memory.h:1807
void create_value_at(T *p)
Definition: memory.h:1786
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at(T *)
Definition: memory.h:1006
etl::enable_if< etl::is_trivially_destructible< typenameetl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n(TIterator i_begin, TSize n)
Definition: memory.h:1169
TOutputIterator uninitialized_move(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition: memory.h:459
TOutputIterator uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition: memory.h:216
TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T &value)
Definition: memory.h:189
ETL_CONSTEXPR17 T * addressof(T &t)
Definition: addressof.h:51
add_rvalue_reference
Definition: type_traits_generator.h:1327
enable_if
Definition: type_traits_generator.h:1191
is_integral
Definition: type_traits_generator.h:1001
is_same
Definition: type_traits_generator.h:1041
remove_cv
Definition: type_traits_generator.h:968
iterator erase(const_iterator i_element)
Definition: vector.h:878
void initialise()
Initialise the vector.
Definition: vector.h:1013
iterator begin()
Definition: vector.h:100
~vector_ext()
Destructor.
Definition: vector.h:1504
const_reference at(size_t i) const
Definition: vector.h:311
size_type max_size() const
Definition: vector_base.h:140
reference emplace_back(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: vector.h:530
const_iterator begin() const
Definition: vector.h:109
void push_back(const_reference value)
Definition: vector.h:432
vector_ext(size_t initial_size, typename etl::ivector< T >::parameter_t value, void *buffer, size_t max_size)
Definition: vector.h:1403
vector()
Constructor.
Definition: vector.h:1538
vector_ext(TIterator first, TIterator last, void *buffer, size_t max_size, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition: vector.h:1417
const_reverse_iterator crbegin() const
Definition: vector.h:190
vector(size_t initial_size)
Definition: vector.h:1207
reverse_iterator rend()
Definition: vector.h:172
const_iterator cend() const
Definition: vector.h:145
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1333
vector(const vector &other)
Copy constructor.
Definition: vector.h:1253
vector_ext(void *buffer, size_t max_size)
Constructor.
Definition: vector.h:1381
void clear()
Clears the vector.
Definition: vector.h:414
vector_ext(size_t initial_size, void *buffer, size_t max_size)
Definition: vector.h:1391
etl::enable_if<!etl::is_integral< TIterator >::value, void >::type assign(TIterator first, TIterator last)
Definition: vector.h:380
iterator erase(const_iterator first, const_iterator last)
Definition: vector.h:896
void reserve(size_t)
Definition: vector.h:269
const size_type CAPACITY
The maximum number of elements in the vector.
Definition: vector_base.h:170
void insert(const_iterator position, TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition: vector.h:812
reference emplace_back(const T1 &value1, const T2 &value2)
Definition: vector.h:496
pointer p_buffer
Pointer to the start of the buffer.
Definition: vector.h:1031
vector_ext(size_t initial_size, typename etl::ivector< T * >::parameter_t value, void *buffer, size_t max_size)
Definition: vector.h:1699
reference front()
Definition: vector.h:321
iterator end()
Definition: vector.h:118
pointer data()
Definition: vector.h:357
const_pointer data() const
Definition: vector.h:366
vector(size_t initial_size, typename etl::ivector< T * >::parameter_t value)
Definition: vector.h:1560
const_reverse_iterator crend() const
Definition: vector.h:199
vector(size_t initial_size, typename etl::ivector< T >::parameter_t value)
Definition: vector.h:1219
reference operator[](size_t i)
Definition: vector.h:278
~vector_ext()
Destructor.
Definition: vector.h:1783
const_iterator cbegin() const
Definition: vector.h:136
ivector(T *p_buffer_, size_t MAX_SIZE)
Constructor.
Definition: vector.h:1003
const_iterator end() const
Definition: vector.h:127
const_reverse_iterator rend() const
Definition: vector.h:181
vector_ext(size_t initial_size, void *buffer, size_t max_size)
Definition: vector.h:1687
vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition: vector.h:1233
void pop_back()
Definition: vector.h:546
void resize(size_t new_size, const_reference value)
Definition: vector.h:222
void assign(size_t n, parameter_t value)
Definition: vector.h:401
reference at(size_t i)
Definition: vector.h:299
ivector & operator=(const ivector &rhs)
Assignment operator.
Definition: vector.h:922
const_reference back() const
Definition: vector.h:348
vector_ext(TIterator first, TIterator last, void *buffer, size_t max_size, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition: vector.h:1713
reference emplace_back(const T1 &value1)
Definition: vector.h:479
vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition: vector.h:1574
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1512
vector_ext(void *buffer, size_t max_size)
Constructor.
Definition: vector.h:1677
vector_ext & operator=(const vector_ext &rhs)
Assignment operator.
Definition: vector.h:1446
void repair_buffer(T *p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1024
vector(const vector &other)
Copy constructor.
Definition: vector.h:1594
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1634
void fill(const T &value)
Fills the vector.
Definition: vector.h:422
bool full() const
Definition: vector.h:977
vector_ext(const vector_ext &other, void *buffer, size_t max_size)
Copy constructor.
Definition: vector.h:1437
pointer p_end
Pointer to one past the last element in the buffer.
Definition: vector.h:1032
vector(size_t initial_size)
Definition: vector.h:1548
size_type size() const
Definition: vector.h:959
iterator erase(iterator i_element)
Definition: vector.h:865
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1791
void insert(const_iterator position, size_t n, parameter_t value)
Definition: vector.h:755
bool empty() const
Definition: vector.h:968
const_reverse_iterator rbegin() const
Definition: vector.h:163
void resize(size_t new_size)
Definition: vector.h:210
~vector()
Destructor.
Definition: vector.h:1322
reference back()
Definition: vector.h:339
void uninitialized_resize(size_t new_size)
Definition: vector.h:247
size_t available() const
Definition: vector.h:986
vector()
Constructor.
Definition: vector.h:1197
iterator emplace(const_iterator position, const T1 &value1)
Emplaces a value to the vector at the specified position.
Definition: vector.h:640
vector_ext(const vector_ext &other, void *buffer, size_t max_size)
Construct a copy.
Definition: vector.h:1733
vector & operator=(const vector &rhs)
Assignment operator.
Definition: vector.h:1262
reverse_iterator rbegin()
Definition: vector.h:154
const_reference front() const
Definition: vector.h:330
iterator insert(const_iterator position, const_reference value)
Definition: vector.h:560
reference emplace_back(const T1 &value1, const T2 &value2, const T3 &value3)
Definition: vector.h:513
vector_ext(const vector_ext &other) ETL_DELETE
Copy constructor (Deleted)
Definition: vector.h:72
Definition: ivectorpointer.h:49
Definition: vector.h:1187
Definition: vector_base.h:122
Definition: vector_base.h:80
Template deduction guides.
Definition: vector.h:1375
Definition: vector_base.h:66
Definition: vector_base.h:108
Definition: vector_base.h:94
bitset_ext
Definition: absolute.h:38
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:684
size_t max_size() const
Returns the maximum number of items in the variant_pool.
Definition: variant_pool_generator.h:281
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:696
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
void destroy(const T *const p)
Destroys the object.
Definition: variant_pool_generator.h:256
etl::ivector< T >::difference_type erase_if(etl::ivector< T > &v, TPredicate predicate)
erase_if
Definition: vector.h:1819
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
Definition: type_traits_generator.h:2069
iterator
Definition: iterator.h:399