Embedded Template Library 1.0
Loading...
Searching...
No Matches
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 //*********************************************************************
101 {
102 return p_buffer;
103 }
104
105 //*********************************************************************
108 //*********************************************************************
110 {
111 return p_buffer;
112 }
113
114 //*********************************************************************
117 //*********************************************************************
119 {
120 return p_end;
121 }
122
123 //*********************************************************************
126 //*********************************************************************
128 {
129 return p_end;
130 }
131
132 //*********************************************************************
135 //*********************************************************************
137 {
138 return p_buffer;
139 }
140
141 //*********************************************************************
144 //*********************************************************************
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
241 }
242
243 //*********************************************************************
246 //*********************************************************************
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
263 }
264
265 //*********************************************************************
269 //*********************************************************************
270 void reserve(size_t n)
271 {
272 (void)n; // Stop 'unused parameter' warning in release mode.
274 }
275
276 //*********************************************************************
280 //*********************************************************************
282 {
283 return p_buffer[i];
284 }
285
286 //*********************************************************************
290 //*********************************************************************
292 {
293 return p_buffer[i];
294 }
295
296 //*********************************************************************
301 //*********************************************************************
302 reference at(size_t i)
303 {
304 ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
305 return p_buffer[i];
306 }
307
308 //*********************************************************************
313 //*********************************************************************
314 const_reference at(size_t i) const
315 {
316 ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
317 return p_buffer[i];
318 }
319
320 //*********************************************************************
323 //*********************************************************************
325 {
326 return *p_buffer;
327 }
328
329 //*********************************************************************
332 //*********************************************************************
334 {
335 return *p_buffer;
336 }
337
338 //*********************************************************************
341 //*********************************************************************
343 {
344 return *(p_end - 1);
345 }
346
347 //*********************************************************************
350 //*********************************************************************
352 {
353 return *(p_end - 1);
354 }
355
356 //*********************************************************************
359 //*********************************************************************
361 {
362 return p_buffer;
363 }
364
365 //*********************************************************************
368 //*********************************************************************
369 ETL_CONSTEXPR const_pointer data() const
370 {
371 return p_buffer;
372 }
373
374 //*********************************************************************
380 //*********************************************************************
381 template <typename TIterator>
384 {
385 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");
386
387#if ETL_IS_DEBUG_BUILD
388 difference_type d = etl::distance(first, last);
389 ETL_ASSERT_OR_RETURN(static_cast<size_t>(d) <= CAPACITY, ETL_ERROR(vector_full));
390#endif
391
392 initialise();
393
394 p_end = etl::uninitialized_copy(first, last, p_buffer);
395 ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last)));
396 }
397
398 //*********************************************************************
403 //*********************************************************************
404 void assign(size_t n, parameter_t value)
405 {
406 ETL_ASSERT_OR_RETURN(n <= CAPACITY, ETL_ERROR(vector_full));
407
408 initialise();
409
411 ETL_ADD_DEBUG_COUNT(uint32_t(n));
412 }
413
414 //*************************************************************************
416 //*************************************************************************
417 void clear()
418 {
419 initialise();
420 }
421
422 //*************************************************************************
424 //*************************************************************************
425 void fill(const T& value)
426 {
427 etl::fill(begin(), end(), value);
428 }
429
430 //*********************************************************************
434 //*********************************************************************
436 {
437#if defined(ETL_CHECK_PUSH_POP)
438 ETL_ASSERT_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
439#endif
440 create_back(value);
441 }
442
443#if ETL_USING_CPP11
444 //*********************************************************************
448 //*********************************************************************
449 void push_back(rvalue_reference value)
450 {
451#if defined(ETL_CHECK_PUSH_POP)
452 ETL_ASSERT_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
453#endif
454 create_back(etl::move(value));
455 }
456#endif
457
458#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_VECTOR_FORCE_CPP03_IMPLEMENTATION)
459 //*********************************************************************
463 //*********************************************************************
464 template <typename ... Args>
465 reference emplace_back(Args && ... args)
466 {
467#if defined(ETL_CHECK_PUSH_POP)
468 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
469#endif
470 ::new (p_end) T(etl::forward<Args>(args)...);
471 ++p_end;
472 ETL_INCREMENT_DEBUG_COUNT;
473 return back();
474 }
475#else
476 //*********************************************************************
480 //*********************************************************************
482 {
483#if defined(ETL_CHECK_PUSH_POP)
484 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
485#endif
486 ::new (p_end) T();
487 ++p_end;
488 ETL_INCREMENT_DEBUG_COUNT;
489 return back();
490 }
491
492 //*********************************************************************
496 //*********************************************************************
497 template <typename T1>
498 reference emplace_back(const T1& value1)
499 {
500#if defined(ETL_CHECK_PUSH_POP)
501 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
502#endif
503 ::new (p_end) T(value1);
504 ++p_end;
505 ETL_INCREMENT_DEBUG_COUNT;
506 return back();
507 }
508
509 //*********************************************************************
513 //*********************************************************************
514 template <typename T1, typename T2>
515 reference emplace_back(const T1& value1, const T2& value2)
516 {
517#if defined(ETL_CHECK_PUSH_POP)
518 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
519#endif
520 ::new (p_end) T(value1, value2);
521 ++p_end;
522 ETL_INCREMENT_DEBUG_COUNT;
523 return back();
524 }
525
526 //*********************************************************************
530 //*********************************************************************
531 template <typename T1, typename T2, typename T3>
532 reference emplace_back(const T1& value1, const T2& value2, const T3& value3)
533 {
534#if defined(ETL_CHECK_PUSH_POP)
535 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
536#endif
537 ::new (p_end) T(value1, value2, value3);
538 ++p_end;
539 ETL_INCREMENT_DEBUG_COUNT;
540 return back();
541 }
542
543 //*********************************************************************
547 //*********************************************************************
548 template <typename T1, typename T2, typename T3, typename T4>
549 reference emplace_back(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
550 {
551#if defined(ETL_CHECK_PUSH_POP)
552 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
553#endif
554 ::new (p_end) T(value1, value2, value3, value4);
555 ++p_end;
556 ETL_INCREMENT_DEBUG_COUNT;
557 return back();
558 }
559#endif
560
561 //*************************************************************************
564 //*************************************************************************
565 void pop_back()
566 {
567#if defined(ETL_CHECK_PUSH_POP)
568 ETL_ASSERT_OR_RETURN(size() > 0, ETL_ERROR(vector_empty));
569#endif
570 destroy_back();
571 }
572
573 //*********************************************************************
578 //*********************************************************************
580 {
581 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
582
583 iterator position_ = to_iterator(position);
584
585 if (position_ == end())
586 {
587 create_back(value);
588 }
589 else
590 {
591 create_back(back());
592 etl::move_backward(position_, p_end - 2, p_end - 1);
593 *position_ = value;
594 }
595
596 return position_;
597 }
598
599#if ETL_USING_CPP11
600 //*********************************************************************
605 //*********************************************************************
606 iterator insert(const_iterator position, rvalue_reference value)
607 {
608 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
609
610 iterator position_ = to_iterator(position);
611
612 if (position_ == end())
613 {
614 create_back(etl::move(value));
615 }
616 else
617 {
618 create_back(etl::move(back()));
619 etl::move_backward(position_, p_end - 2, p_end - 1);
620 *position_ = etl::move(value);
621 }
622
623 return position_;
624 }
625#endif
626
627 //*************************************************************************
629 //*************************************************************************
630#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
631 template <typename ... Args>
632 iterator emplace(const_iterator position, Args && ... args)
633 {
634 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
635
636 iterator position_ = to_iterator(position);
637
638 void* p;
639
640 if (position_ == end())
641 {
642 p = p_end++;
643 ETL_INCREMENT_DEBUG_COUNT;
644 }
645 else
646 {
647 p = etl::addressof(*position_);
648 create_back(back());
649 etl::move_backward(position_, p_end - 2, p_end - 1);
650 (*position_).~T();
651 }
652
653 ::new (p) T(etl::forward<Args>(args)...);
654
655 return position_;
656 }
657#else
658 template <typename T1>
659 iterator emplace(const_iterator position, const T1& value1)
660 {
661 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
662
663 iterator position_ = to_iterator(position);
664
665 void* p;
666
667 if (position_ == end())
668 {
669 p = p_end++;
670 ETL_INCREMENT_DEBUG_COUNT;
671 }
672 else
673 {
675 create_back(back());
676 etl::move_backward(position_, p_end - 2, p_end - 1);
677 (*position_).~T();
678 }
679
680 ::new (p) T(value1);
681
682 return position_;
683 }
684
685 template <typename T1, typename T2>
686 iterator emplace(const_iterator position, const T1& value1, const T2& value2)
687 {
688 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
689
690 iterator position_ = to_iterator(position);
691
692 void* p;
693
694 if (position_ == end())
695 {
696 p = p_end++;
697 ETL_INCREMENT_DEBUG_COUNT;
698 }
699 else
700 {
701 p = etl::addressof(*position_);
702 create_back(back());
703 etl::move_backward(position_, p_end - 2, p_end - 1);
704 (*position_).~T();
705 }
706
707 ::new (p) T(value1, value2);
708
709 return position_;
710 }
711
712 template <typename T1, typename T2, typename T3>
713 iterator emplace(const_iterator position, const T1& value1, const T2& value2, const T3& value3)
714 {
715 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
716
717 iterator position_ = to_iterator(position);
718
719 void* p;
720
721 if (position_ == end())
722 {
723 p = p_end++;
724 ETL_INCREMENT_DEBUG_COUNT;
725 }
726 else
727 {
728 p = etl::addressof(*position_);
729 create_back(back());
730 etl::move_backward(position_, p_end - 2, p_end - 1);
731 (*position_).~T();
732 }
733
734 ::new (p) T(value1, value2, value3);
735
736 return position_;
737 }
738
739 template <typename T1, typename T2, typename T3, typename T4>
740 iterator emplace(const_iterator position, const T1& value1, const T2& value2, const T3& value3, const T4& value4)
741 {
742 ETL_ASSERT(!full(), ETL_ERROR(vector_full));
743
744 iterator position_ = to_iterator(position);
745
746 void* p;
747
748 if (position_ == end())
749 {
750 p = p_end++;
751 ETL_INCREMENT_DEBUG_COUNT;
752 }
753 else
754 {
755 p = etl::addressof(*position_);
756 create_back(back());
757 etl::move_backward(position_, p_end - 2, p_end - 1);
758 (*position_).~T();
759 }
760
761 ::new (p) T(value1, value2, value3, value4);
762
763 return position_;
764 }
765#endif
766
767 //*********************************************************************
773 //*********************************************************************
774 void insert(const_iterator position, size_t n, parameter_t value)
775 {
776 ETL_ASSERT_OR_RETURN((size() + n) <= CAPACITY, ETL_ERROR(vector_full));
777
778 iterator position_ = to_iterator(position);
779
780 size_t insert_n = n;
781 size_t insert_begin = etl::distance(begin(), position_);
783
784 // Copy old data.
785 size_t copy_old_n;
786 size_t construct_old_n;
788
789 if (insert_end > size())
790 {
791 copy_old_n = 0;
794 }
795 else
796 {
800 }
801
804
805 // Construct old.
807 ETL_ADD_DEBUG_COUNT(construct_old_n);
808
809 // Copy old.
811
812 // Construct new.
814 ETL_ADD_DEBUG_COUNT(construct_new_n);
815
816 // Copy new.
817 etl::fill_n(p_buffer + insert_begin, copy_new_n, value);
818
819 p_end += n;
820 }
821
822 //*********************************************************************
829 //*********************************************************************
830 template <class TIterator>
831 void insert(const_iterator position, TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
832 {
833 size_t count = etl::distance(first, last);
834
835 ETL_ASSERT_OR_RETURN((size() + count) <= CAPACITY, ETL_ERROR(vector_full));
836
837 size_t insert_n = count;
838 size_t insert_begin = etl::distance(cbegin(), position);
840
841 // Move old data.
842 size_t copy_old_n;
843 size_t construct_old_n;
845
846 if (insert_end > size())
847 {
848 copy_old_n = 0;
851 }
852 else
853 {
857 }
858
861
862 // Move construct old.
864 ETL_ADD_DEBUG_COUNT(construct_old_n);
865
866 // Move old.
868
869 // Copy construct new.
871 ETL_ADD_DEBUG_COUNT(construct_new_n);
872
873 // Copy new.
874 etl::copy(first, first + copy_new_n, p_buffer + insert_begin);
875
876 p_end += count;
877 }
878
879 //*********************************************************************
883 //*********************************************************************
885 {
886 etl::move(i_element + 1, end(), i_element);
887 destroy_back();
888
889 return i_element;
890 }
891
892 //*********************************************************************
896 //*********************************************************************
898 {
899 iterator i_element_ = to_iterator(i_element);
900
901 etl::move(i_element_ + 1, end(), i_element_);
902 destroy_back();
903
904 return i_element_;
905 }
906
907 //*********************************************************************
914 //*********************************************************************
916 {
917 iterator first_ = to_iterator(first);
918 iterator last_ = to_iterator(last);
919
920 if (first == begin() && last == end())
921 {
922 clear();
923 }
924 else
925 {
926 etl::move(last_, end(), first_);
927 size_t n_delete = etl::distance(first_, last_);
928
929 // Destroy the elements left over at the end.
931 ETL_SUBTRACT_DEBUG_COUNT(n_delete);
932 p_end -= n_delete;
933 }
934
935 return first_;
936 }
937
938 //*************************************************************************
940 //*************************************************************************
942 {
943 if (&rhs != this)
944 {
945 assign(rhs.cbegin(), rhs.cend());
946 }
947
948 return *this;
949 }
950
951#if ETL_USING_CPP11
952 //*************************************************************************
954 //*************************************************************************
956 {
957 if (&rhs != this)
958 {
959 clear();
960 iterator itr = rhs.begin();
961 while (itr != rhs.end())
962 {
963 push_back(etl::move(*itr));
964 ++itr;
965 }
966
967 rhs.initialise();
968 }
969
970 return *this;
971 }
972#endif
973
974 //*************************************************************************
977 //*************************************************************************
979 {
980 return size_t(p_end - p_buffer);
981 }
982
983 //*************************************************************************
986 //*************************************************************************
987 bool empty() const
988 {
989 return (p_end == p_buffer);
990 }
991
992 //*************************************************************************
995 //*************************************************************************
996 bool full() const
997 {
998 return size() == CAPACITY;
999 }
1000
1001 //*************************************************************************
1004 //*************************************************************************
1005 size_t available() const
1006 {
1007 return max_size() - size();
1008 }
1009
1010#ifdef ETL_IVECTOR_REPAIR_ENABLE
1011 //*************************************************************************
1013 //*************************************************************************
1014 virtual void repair() = 0;
1015#endif
1016
1017 protected:
1018
1019 //*********************************************************************
1021 //*********************************************************************
1022 ivector(T* p_buffer_, size_t MAX_SIZE)
1023 : vector_base(MAX_SIZE)
1025 , p_end(p_buffer_)
1026 {
1027 }
1028
1029 //*********************************************************************
1031 //*********************************************************************
1033 {
1035 ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end)));
1036
1037 p_end = p_buffer;
1038 }
1039
1040 //*************************************************************************
1042 //*************************************************************************
1044 {
1045 uintptr_t length = p_end - p_buffer;
1047 p_end = p_buffer_ + length;
1048 }
1049
1052
1053 private:
1054
1055 //*********************************************************************
1057 //*********************************************************************
1058 void create_back()
1059 {
1060 etl::create_value_at(p_end);
1061 ETL_INCREMENT_DEBUG_COUNT;
1062
1063 ++p_end;
1064 }
1065
1066 //*********************************************************************
1068 //*********************************************************************
1069 void create_back(const_reference value)
1070 {
1071 etl::create_copy_at(p_end, value);
1072 ETL_INCREMENT_DEBUG_COUNT;
1073
1074 ++p_end;
1075 }
1076
1077#if ETL_USING_CPP11
1078 //*********************************************************************
1080 //*********************************************************************
1081 void create_back(rvalue_reference value)
1082 {
1083 etl::create_copy_at(p_end, etl::move(value));
1084 ETL_INCREMENT_DEBUG_COUNT;
1085
1086 ++p_end;
1087 }
1088#endif
1089
1090 //*********************************************************************
1092 //*********************************************************************
1093 void destroy_back()
1094 {
1095 --p_end;
1096
1098 ETL_DECREMENT_DEBUG_COUNT;
1099 }
1100
1101 // Disable copy construction.
1102 ivector(const ivector&) ETL_DELETE;
1103
1104 private:
1105
1106 //*************************************************************************
1108 //*************************************************************************
1109 ETL_CONSTEXPR iterator to_iterator(const_iterator itr) const
1110 {
1111 return const_cast<iterator>(itr);
1112 }
1113 };
1114
1115 //***************************************************************************
1121 //***************************************************************************
1122 template <typename T>
1124 {
1125 return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
1126 }
1127
1128 //***************************************************************************
1134 //***************************************************************************
1135 template <typename T>
1137 {
1138 return !(lhs == rhs);
1139 }
1140
1141 //***************************************************************************
1147 //***************************************************************************
1148 template <typename T>
1150 {
1151 return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
1152 }
1153
1154 //***************************************************************************
1160 //***************************************************************************
1161 template <typename T>
1163 {
1164 return (rhs < lhs);
1165 }
1166
1167 //***************************************************************************
1173 //***************************************************************************
1174 template <typename T>
1176 {
1177 return !(lhs > rhs);
1178 }
1179
1180 //***************************************************************************
1186 //***************************************************************************
1187 template <typename T>
1189 {
1190 return !(lhs < rhs);
1191 }
1192}
1193
1194#include "private/ivectorpointer.h"
1195
1196namespace etl
1197{
1198 //***************************************************************************
1203 //***************************************************************************
1204 template <typename T, const size_t MAX_SIZE_>
1205 class vector : public etl::ivector<T>
1206 {
1207 public:
1208
1209 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U), "Zero capacity etl::vector is not valid");
1210
1211 static const size_t MAX_SIZE = MAX_SIZE_;
1212
1213 //*************************************************************************
1215 //*************************************************************************
1216 vector()
1217 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1218 {
1219 this->initialise();
1220 }
1221
1222 //*************************************************************************
1225 //*************************************************************************
1226 explicit vector(size_t initial_size)
1227 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1228 {
1229 this->initialise();
1230 this->resize(initial_size);
1231 }
1232
1233 //*************************************************************************
1237 //*************************************************************************
1238 vector(size_t initial_size, typename etl::ivector<T>::parameter_t value)
1239 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1240 {
1241 this->initialise();
1242 this->resize(initial_size, value);
1243 }
1244
1245 //*************************************************************************
1250 //*************************************************************************
1251 template <typename TIterator>
1252 vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1253 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1254 {
1255 this->assign(first, last);
1256 }
1257
1258#if ETL_HAS_INITIALIZER_LIST
1259 //*************************************************************************
1261 //*************************************************************************
1262 vector(std::initializer_list<T> init)
1263 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1264 {
1265 this->assign(init.begin(), init.end());
1266 }
1267#endif
1268
1269 //*************************************************************************
1271 //*************************************************************************
1272 vector(const vector& other)
1273 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1274 {
1275 this->assign(other.begin(), other.end());
1276 }
1277
1278 //*************************************************************************
1280 //*************************************************************************
1281 vector& operator = (const vector& rhs)
1282 {
1283 if (&rhs != this)
1284 {
1285 this->assign(rhs.cbegin(), rhs.cend());
1286 }
1287
1288 return *this;
1289 }
1290
1291#if ETL_USING_CPP11
1292 //*************************************************************************
1294 //*************************************************************************
1295 vector(vector&& other)
1296 : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1297 {
1298 if (this != &other)
1299 {
1300 this->initialise();
1301
1302 typename etl::ivector<T>::iterator itr = other.begin();
1303 while (itr != other.end())
1304 {
1305 this->push_back(etl::move(*itr));
1306 ++itr;
1307 }
1308
1309 other.initialise();
1310 }
1311 }
1312
1313 //*************************************************************************
1315 //*************************************************************************
1316 vector& operator = (vector&& rhs)
1317 {
1318 if (&rhs != this)
1319 {
1320 this->clear();
1321 typename etl::ivector<T>::iterator itr = rhs.begin();
1322 while (itr != rhs.end())
1323 {
1324 this->push_back(etl::move(*itr));
1325 ++itr;
1326 }
1327
1328 rhs.initialise();
1329 }
1330
1331 return *this;
1332 }
1333#endif
1334
1335 //*************************************************************************
1337 //*************************************************************************
1338#ifdef ETL_IVECTOR_REPAIR_ENABLE
1339 virtual
1340#endif
1341 ~vector()
1342 {
1343 this->clear();
1344 }
1345
1346 //*************************************************************************
1348 //*************************************************************************
1349#ifdef ETL_IVECTOR_REPAIR_ENABLE
1350 virtual void repair() ETL_OVERRIDE
1351#else
1352 void repair()
1353#endif
1354 {
1356
1358 }
1359
1360 private:
1361
1362 typename etl::aligned_storage<sizeof(T) * MAX_SIZE, etl::alignment_of<T>::value>::type buffer;
1363 };
1364
1365 //*************************************************************************
1367 //*************************************************************************
1368#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
1369 template <typename... T>
1370 vector(T...) -> vector<typename etl::common_type_t<T...>, sizeof...(T)>;
1371#endif
1372
1373 //*************************************************************************
1375 //*************************************************************************
1376#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
1377 template <typename... T>
1378 constexpr auto make_vector(T&&... t) -> etl::vector<typename etl::common_type_t<T...>, sizeof...(T)>
1379 {
1380 return { etl::forward<T>(t)... };
1381 }
1382#endif
1383
1384 //***************************************************************************
1389 //***************************************************************************
1390 template <typename T>
1391 class vector_ext : public etl::ivector<T>
1392 {
1393 public:
1394
1395 //*************************************************************************
1397 //*************************************************************************
1398 vector_ext(void* buffer, size_t max_size)
1399 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1400 {
1401 this->initialise();
1402 }
1403
1404 //*************************************************************************
1407 //*************************************************************************
1408 explicit vector_ext(size_t initial_size, void* buffer, size_t max_size)
1409 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1410 {
1411 this->initialise();
1412 this->resize(initial_size);
1413 }
1414
1415 //*************************************************************************
1419 //*************************************************************************
1420 vector_ext(size_t initial_size, typename etl::ivector<T>::parameter_t value, void* buffer, size_t max_size)
1421 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1422 {
1423 this->initialise();
1424 this->resize(initial_size, value);
1425 }
1426
1427 //*************************************************************************
1432 //*************************************************************************
1433 template <typename TIterator>
1434 vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1435 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1436 {
1437 this->assign(first, last);
1438 }
1439
1440#if ETL_HAS_INITIALIZER_LIST
1441 //*************************************************************************
1443 //*************************************************************************
1444 vector_ext(std::initializer_list<T> init, void* buffer, size_t max_size)
1445 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1446 {
1447 this->assign(init.begin(), init.end());
1448 }
1449#endif
1450
1451 //*************************************************************************
1453 //*************************************************************************
1454 vector_ext(const vector_ext& other, void* buffer, size_t max_size)
1455 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1456 {
1457 this->assign(other.begin(), other.end());
1458 }
1459
1460 //*************************************************************************
1462 //*************************************************************************
1463 vector_ext& operator = (const vector_ext& rhs)
1464 {
1465 if (&rhs != this)
1466 {
1467 this->assign(rhs.cbegin(), rhs.cend());
1468 }
1469
1470 return *this;
1471 }
1472
1473#if ETL_USING_CPP11
1474 //*************************************************************************
1476 //*************************************************************************
1477 vector_ext(vector_ext&& other, void* buffer, size_t max_size)
1478 : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1479 {
1480 if (this != &other)
1481 {
1482 this->initialise();
1483
1484 typename etl::ivector<T>::iterator itr = other.begin();
1485 while (itr != other.end())
1486 {
1487 this->push_back(etl::move(*itr));
1488 ++itr;
1489 }
1490
1491 other.initialise();
1492 }
1493 }
1494
1495 //*************************************************************************
1497 //*************************************************************************
1498 vector_ext& operator = (vector_ext&& rhs)
1499 {
1500 if (&rhs != this)
1501 {
1502 this->clear();
1503
1504 typename etl::ivector<T>::iterator itr = rhs.begin();
1505 while (itr != rhs.end())
1506 {
1507 this->push_back(etl::move(*itr));
1508 ++itr;
1509 }
1510
1511 rhs.initialise();
1512 }
1513
1514 return *this;
1515 }
1516#endif
1517
1518 //*************************************************************************
1520 //*************************************************************************
1521 ~vector_ext()
1522 {
1523 this->clear();
1524 }
1525
1526 //*************************************************************************
1528 //*************************************************************************
1529#ifdef ETL_IVECTOR_REPAIR_ENABLE
1530 virtual void repair() ETL_OVERRIDE
1531#else
1532 void repair()
1533#endif
1534 {
1535 }
1536 };
1537
1538 //***************************************************************************
1543 //***************************************************************************
1544 template <typename T, const size_t MAX_SIZE_>
1545 class vector<T*, MAX_SIZE_> : public etl::ivector<T*>
1546 {
1547 public:
1548
1549 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U), "Zero capacity etl::vector is not valid");
1550
1551 static const size_t MAX_SIZE = MAX_SIZE_;
1552
1553 //*************************************************************************
1555 //*************************************************************************
1556 vector()
1557 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1558 {
1559 this->initialise();
1560 }
1561
1562 //*************************************************************************
1565 //*************************************************************************
1566 explicit vector(size_t initial_size)
1567 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1568 {
1569 this->initialise();
1570 this->resize(initial_size);
1571 }
1572
1573 //*************************************************************************
1577 //*************************************************************************
1578 vector(size_t initial_size, typename etl::ivector<T*>::parameter_t value)
1579 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1580 {
1581 this->initialise();
1582 this->resize(initial_size, value);
1583 }
1584
1585 //*************************************************************************
1590 //*************************************************************************
1591 template <typename TIterator>
1592 vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1593 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1594 {
1595 this->assign(first, last);
1596 }
1597
1598#if ETL_HAS_INITIALIZER_LIST
1599 //*************************************************************************
1601 //*************************************************************************
1602 vector(std::initializer_list<T*> init)
1603 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1604 {
1605 this->assign(init.begin(), init.end());
1606 }
1607#endif
1608
1609 //*************************************************************************
1611 //*************************************************************************
1612 vector(const vector& other)
1613 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1614 {
1615 (void)etl::ivector<T*>::operator = (other);
1616 }
1617
1618 //*************************************************************************
1620 //*************************************************************************
1621 vector& operator = (const vector& rhs)
1622 {
1623 (void)etl::ivector<T*>::operator = (rhs);
1624
1625 return *this;
1626 }
1627
1628#if ETL_USING_CPP11
1629 //*************************************************************************
1631 //*************************************************************************
1632 vector(vector&& other)
1633 : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1634 {
1635 (void)etl::ivector<T*>::operator = (etl::move(other));
1636 }
1637
1638 //*************************************************************************
1640 //*************************************************************************
1641 vector& operator = (vector&& rhs)
1642 {
1643 (void)etl::ivector<T*>::operator = (etl::move(rhs));
1644
1645 return *this;
1646 }
1647#endif
1648
1649 //*************************************************************************
1651 //*************************************************************************
1652#ifdef ETL_IVECTOR_REPAIR_ENABLE
1653 virtual void repair() ETL_OVERRIDE
1654#else
1655 void repair()
1656#endif
1657 {
1659 }
1660
1661 private:
1662
1663 typename etl::aligned_storage<sizeof(T*) * MAX_SIZE, etl::alignment_of<T*>::value>::type buffer;
1664 };
1665
1666 //*************************************************************************
1668 //*************************************************************************
1669#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
1670 template <typename... T>
1671 vector(T*...) -> vector<typename etl::common_type_t<T*...>, sizeof...(T)>;
1672#endif
1673
1674#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
1675 template <typename... T>
1676 constexpr auto make_vector(T*... t) -> etl::vector<typename etl::common_type_t<T*...>, sizeof...(T)>
1677 {
1678 return { etl::forward<T*>(t)... };
1679 }
1680#endif
1681
1682 //***************************************************************************
1687 //***************************************************************************
1688 template <typename T>
1689 class vector_ext<T*> : public etl::ivector<T*>
1690 {
1691 public:
1692
1693 //*************************************************************************
1695 //*************************************************************************
1696 vector_ext(void* buffer, size_t max_size)
1697 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1698 {
1699 this->initialise();
1700 }
1701
1702 //*************************************************************************
1705 //*************************************************************************
1706 vector_ext(size_t initial_size, void* buffer, size_t max_size)
1707 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1708 {
1709 this->initialise();
1710 this->resize(initial_size);
1711 }
1712
1713 //*************************************************************************
1717 //*************************************************************************
1718 vector_ext(size_t initial_size, typename etl::ivector<T*>::parameter_t value, void* buffer, size_t max_size)
1719 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1720 {
1721 this->initialise();
1722 this->resize(initial_size, value);
1723 }
1724
1725 //*************************************************************************
1730 //*************************************************************************
1731 template <typename TIterator>
1732 vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
1733 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1734 {
1735 this->assign(first, last);
1736 }
1737
1738#if ETL_HAS_INITIALIZER_LIST
1739 //*************************************************************************
1741 //*************************************************************************
1742 vector_ext(std::initializer_list<T*> init, void* buffer, size_t max_size)
1743 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1744 {
1745 this->assign(init.begin(), init.end());
1746 }
1747#endif
1748
1749 //*************************************************************************
1751 //*************************************************************************
1752 vector_ext(const vector_ext& other, void* buffer, size_t max_size)
1753 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1754 {
1755 (void)etl::ivector<T*>::operator = (other);
1756 }
1757
1758 //*************************************************************************
1760 //*************************************************************************
1761 vector_ext(const vector_ext& other) ETL_DELETE;
1762
1763 //*************************************************************************
1765 //*************************************************************************
1766 vector_ext& operator = (const vector_ext& rhs)
1767 {
1768 (void)etl::ivector<T*>::operator = (rhs);
1769
1770 return *this;
1771 }
1772
1773#if ETL_USING_CPP11
1774 //*************************************************************************
1776 //*************************************************************************
1777 vector_ext(vector_ext&& other, void* buffer, size_t max_size)
1778 : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1779 {
1780 (void)etl::ivector<T*>::operator = (etl::move(other));
1781 }
1782
1783 //*************************************************************************
1785 //*************************************************************************
1786 vector_ext(vector_ext&& other) ETL_DELETE;
1787
1788 //*************************************************************************
1790 //*************************************************************************
1791 vector_ext& operator = (vector_ext&& rhs)
1792 {
1793 (void)etl::ivector<T*>::operator = (etl::move(rhs));
1794
1795 return *this;
1796 }
1797#endif
1798
1799 //*************************************************************************
1801 //*************************************************************************
1802 ~vector_ext()
1803 {
1804 this->clear();
1805 }
1806
1807 //*************************************************************************
1809 //*************************************************************************
1810#ifdef ETL_IVECTOR_REPAIR_ENABLE
1811 virtual void repair() ETL_OVERRIDE
1812#else
1813 void repair()
1814#endif
1815 {
1816 etl::ivector<T*>::repair_buffer(this->p_buffer);
1817 }
1818 };
1819
1820 //***************************************************************************
1822 //***************************************************************************
1823 template <typename T, typename U>
1824 typename etl::ivector<T>::difference_type
1825 erase(etl::ivector<T>& v, const U& value)
1826 {
1827 typename etl::ivector<T>::iterator itr = etl::remove(v.begin(), v.end(), value);
1828 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
1829 v.erase(itr, v.end());
1830
1831 return d;
1832 }
1833
1834 //***************************************************************************
1836 //***************************************************************************
1837 template <typename T, typename TPredicate>
1838 typename etl::ivector<T>::difference_type
1839 erase_if(etl::ivector<T>& v, TPredicate predicate)
1840 {
1841 typename etl::ivector<T>::iterator itr = etl::remove_if(v.begin(), v.end(), predicate);
1842 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
1843 v.erase(itr, v.end());
1844
1845 return d;
1846 }
1847}
1848
1849#endif
ETL_CONSTEXPR14 TIterator remove(TIterator first, TIterator last, const T &value)
Definition algorithm.h:2192
ETL_CONSTEXPR14 TIterator remove_if(TIterator first, TIterator last, TUnaryPredicate predicate)
Definition algorithm.h:2218
Definition alignment.h:231
#define ETL_ASSERT(b, e)
Definition error_handler.h:356
ETL_CONSTEXPR17 etl::enable_if<!etl::is_same< T, etl::nullptr_t >::value, T >::type * addressof(T &t)
Definition addressof.h:52
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at(T *)
Definition memory.h:1027
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:1190
TOutputIterator uninitialized_move(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition memory.h:480
TOutputIterator uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition memory.h:237
TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T &value)
Definition memory.h:210
add_rvalue_reference
Definition type_traits_generator.h:1322
enable_if
Definition type_traits_generator.h:1186
is_integral
Definition type_traits_generator.h:996
is_same
Definition type_traits_generator.h:1036
remove_cv
Definition type_traits_generator.h:963
iterator erase(const_iterator i_element)
Definition vector.h:897
void initialise()
Initialise the vector.
Definition vector.h:1032
iterator begin()
Definition vector.h:100
const_reference at(size_t i) const
Definition vector.h:314
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:549
const_iterator begin() const
Definition vector.h:109
void push_back(const_reference value)
Definition vector.h:435
const_reverse_iterator crbegin() const
Definition vector.h:190
reverse_iterator rend()
Definition vector.h:172
const_iterator cend() const
Definition vector.h:145
void clear()
Clears the vector.
Definition vector.h:417
etl::enable_if<!etl::is_integral< TIterator >::value, void >::type assign(TIterator first, TIterator last)
Definition vector.h:383
iterator erase(const_iterator first, const_iterator last)
Definition vector.h:915
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:831
reference emplace_back(const T1 &value1, const T2 &value2)
Definition vector.h:515
pointer p_buffer
Pointer to the start of the buffer.
Definition vector.h:1050
reference front()
Definition vector.h:324
iterator end()
Definition vector.h:118
pointer data()
Definition vector.h:360
const_reverse_iterator crend() const
Definition vector.h:199
reference operator[](size_t i)
Definition vector.h:281
const_iterator cbegin() const
Definition vector.h:136
ivector(T *p_buffer_, size_t MAX_SIZE)
Constructor.
Definition vector.h:1022
const_iterator end() const
Definition vector.h:127
const_reverse_iterator rend() const
Definition vector.h:181
void pop_back()
Definition vector.h:565
void resize(size_t new_size, const_reference value)
Definition vector.h:222
void assign(size_t n, parameter_t value)
Definition vector.h:404
reference at(size_t i)
Definition vector.h:302
ivector & operator=(const ivector &rhs)
Assignment operator.
Definition vector.h:941
const_reference back() const
Definition vector.h:351
reference emplace_back(const T1 &value1)
Definition vector.h:498
void repair_buffer(T *p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition vector.h:1043
void fill(const T &value)
Fills the vector.
Definition vector.h:425
bool full() const
Definition vector.h:996
reference emplace_back()
Definition vector.h:481
pointer p_end
Pointer to one past the last element in the buffer.
Definition vector.h:1051
size_type size() const
Definition vector.h:978
iterator erase(iterator i_element)
Definition vector.h:884
void insert(const_iterator position, size_t n, parameter_t value)
Definition vector.h:774
bool empty() const
Definition vector.h:987
const_reverse_iterator rbegin() const
Definition vector.h:163
void resize(size_t new_size)
Definition vector.h:210
ETL_CONSTEXPR const_pointer data() const
Definition vector.h:369
reference back()
Definition vector.h:342
void uninitialized_resize(size_t new_size)
Definition vector.h:247
size_t available() const
Definition vector.h:1005
iterator emplace(const_iterator position, const T1 &value1)
Emplaces a value to the vector at the specified position.
Definition vector.h:659
void reserve(size_t n)
Definition vector.h:270
reverse_iterator rbegin()
Definition vector.h:154
const_reference front() const
Definition vector.h:333
iterator insert(const_iterator position, const_reference value)
Definition vector.h:579
reference emplace_back(const T1 &value1, const T2 &value2, const T3 &value3)
Definition vector.h:532
Definition vector.h:72
Definition vector_base.h:122
Definition vector_base.h:80
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:693
size_t max_size() const
Returns the maximum number of items in the variant_pool.
Definition variant_pool_generator.h:395
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:705
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:654
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:642
void destroy(const T *const p)
Destroys the object.
Definition variant_pool_generator.h:370
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:666
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:681
Definition type_traits_generator.h:2110
iterator
Definition iterator.h:399
pair holds two objects of arbitrary type
Definition utility.h:164