31 #ifndef ETL_VECTOR_INCLUDED
32 #define ETL_VECTOR_INCLUDED
34 #define ETL_IN_VECTOR_H
53 #include "static_assert.h"
56 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
57 #include <initializer_list>
60 #ifdef ETL_COMPILER_GCC
61 #pragma GCC diagnostic push
62 #pragma GCC diagnostic ignored "-Wunused-variable"
85 typedef const T& const_reference;
86 #if ETL_CPP11_SUPPORTED
87 typedef T&& rvalue_reference;
90 typedef const T* const_pointer;
92 typedef const T* const_iterator;
93 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
94 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
95 typedef size_t size_type;
96 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
135 const_iterator
end()
const
164 return reverse_iterator(
end());
173 return const_reverse_iterator(
end());
182 return reverse_iterator(
begin());
189 const_reverse_iterator
rend()
const
191 return const_reverse_iterator(
begin());
200 return const_reverse_iterator(
cend());
207 const_reverse_iterator
crend()
const
209 return const_reverse_iterator(
cbegin());
234 const size_t current_size =
size();
235 size_t delta = (current_size < new_size) ? new_size - current_size : current_size - new_size;
237 if (current_size < new_size)
240 ETL_ADD_DEBUG_COUNT(delta)
245 ETL_SUBTRACT_DEBUG_COUNT(delta)
284 reference
at(
size_t i)
296 const_reference
at(
size_t i)
const
363 template <
typename TIterator>
364 void assign(TIterator first, TIterator last)
366 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");
368 #if defined(ETL_DEBUG)
369 difference_type d = etl::distance(first, last);
376 ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last)))
392 ETL_ADD_DEBUG_COUNT(uint32_t(n))
410 #if defined(ETL_CHECK_PUSH_POP)
416 #if ETL_CPP11_SUPPORTED
424 #if defined(ETL_CHECK_PUSH_POP)
427 create_back(etl::move(value));
431 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && !defined(ETL_VECTOR_FORCE_CPP03)
437 template <
typename ... Args>
440 #if defined(ETL_CHECK_PUSH_POP)
443 ::new (
p_end) T(etl::forward<Args>(args)...);
445 ETL_INCREMENT_DEBUG_COUNT
453 template <
typename T1>
456 #if defined(ETL_CHECK_PUSH_POP)
459 ::new (
p_end) T(value1);
461 ETL_INCREMENT_DEBUG_COUNT
469 template <
typename T1,
typename T2>
472 #if defined(ETL_CHECK_PUSH_POP)
475 ::new (
p_end) T(value1, value2);
477 ETL_INCREMENT_DEBUG_COUNT
485 template <
typename T1,
typename T2,
typename T3>
486 void emplace_back(
const T1& value1,
const T2& value2,
const T3& value3)
488 #if defined(ETL_CHECK_PUSH_POP)
491 ::new (
p_end) T(value1, value2, value3);
493 ETL_INCREMENT_DEBUG_COUNT
501 template <
typename T1,
typename T2,
typename T3,
typename T4>
502 void emplace_back(
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
504 #if defined(ETL_CHECK_PUSH_POP)
507 ::new (
p_end) T(value1, value2, value3, value4);
509 ETL_INCREMENT_DEBUG_COUNT
519 #if defined(ETL_CHECK_PUSH_POP)
531 iterator
insert(iterator position, const_reference value)
535 if (position ==
end())
542 etl::move_backward(position,
p_end - 2,
p_end - 1);
549 #if ETL_CPP11_SUPPORTED
560 if (position ==
end())
562 create_back(etl::move(value));
566 create_back(etl::move(
back()));
567 etl::move_backward(position,
p_end - 2,
p_end - 1);
568 *position = etl::move(value);
578 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT
579 template <
typename ... Args>
580 iterator
emplace(iterator position, Args && ... args)
586 if (position ==
end())
589 ETL_INCREMENT_DEBUG_COUNT
595 etl::move_backward(position,
p_end - 2,
p_end - 1);
599 ::new (p) T(etl::forward<Args>(args)...);
604 template <
typename T1>
605 iterator
emplace(iterator position,
const T1& value1)
611 if (position ==
end())
614 ETL_INCREMENT_DEBUG_COUNT
620 etl::move_backward(position,
p_end - 2,
p_end - 1);
629 template <
typename T1,
typename T2>
636 if (position ==
end())
639 ETL_INCREMENT_DEBUG_COUNT
645 etl::move_backward(position,
p_end - 2,
p_end - 1);
649 ::new (p) T(value1, value2);
654 template <
typename T1,
typename T2,
typename T3>
655 iterator
emplace(iterator position,
const T1& value1,
const T2& value2,
const T3& value3)
661 if (position ==
end())
664 ETL_INCREMENT_DEBUG_COUNT
670 etl::move_backward(position,
p_end - 2,
p_end - 1);
674 ::new (p) T(value1, value2, value3);
679 template <
typename T1,
typename T2,
typename T3,
typename T4>
680 iterator
emplace(iterator position,
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
686 if (position ==
end())
689 ETL_INCREMENT_DEBUG_COUNT
695 etl::move_backward(position,
p_end - 2,
p_end - 1);
699 ::new (p) T(value1, value2, value3, value4);
717 size_t insert_begin = etl::distance(
begin(), position);
718 size_t insert_end = insert_begin + insert_n;
722 size_t construct_old_n;
723 iterator p_construct_old;
725 if (insert_end >
size())
728 construct_old_n =
size() - insert_begin;
729 p_construct_old =
p_buffer + insert_end;
733 copy_old_n =
size() - insert_begin - insert_n;
734 construct_old_n = insert_n;
735 p_construct_old =
p_end;
738 size_t copy_new_n = construct_old_n;
739 size_t construct_new_n = insert_n - copy_new_n;
743 ETL_ADD_DEBUG_COUNT(construct_old_n)
746 etl::move_backward(
p_buffer + insert_begin,
p_buffer + insert_begin + copy_old_n,
p_buffer + insert_end + copy_old_n);
750 ETL_ADD_DEBUG_COUNT(construct_new_n)
753 etl::fill_n(
p_buffer + insert_begin, copy_new_n, value);
766 template <
class TIterator>
767 void insert(iterator position, TIterator first, TIterator last)
769 size_t count = etl::distance(first, last);
773 size_t insert_n = count;
774 size_t insert_begin = etl::distance(
begin(), position);
775 size_t insert_end = insert_begin + insert_n;
779 size_t construct_old_n;
780 iterator p_construct_old;
782 if (insert_end >
size())
785 construct_old_n =
size() - insert_begin;
786 p_construct_old =
p_buffer + insert_end;
790 copy_old_n =
size() - insert_begin - insert_n;
791 construct_old_n = insert_n;
792 p_construct_old =
p_end;
795 size_t copy_new_n = construct_old_n;
796 size_t construct_new_n = insert_n - copy_new_n;
800 ETL_ADD_DEBUG_COUNT(construct_old_n)
803 etl::move_backward(
p_buffer + insert_begin,
p_buffer + insert_begin + copy_old_n,
p_buffer + insert_end + copy_old_n);
807 ETL_ADD_DEBUG_COUNT(construct_new_n)
810 etl::copy(first, first + copy_new_n,
p_buffer + insert_begin);
822 etl::move(i_element + 1,
end(), i_element);
836 iterator
erase(iterator first, iterator last)
838 if (first ==
begin() && last ==
end())
844 etl::move(last,
end(), first);
845 size_t n_delete = etl::distance(first, last);
849 ETL_SUBTRACT_DEBUG_COUNT(n_delete)
869 #if ETL_CPP11_SUPPORTED
879 while (itr != rhs.end())
928 #ifdef ETL_IVECTOR_REPAIR_ENABLE
932 virtual void repair() = 0;
953 ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(
p_buffer,
p_end)))
965 p_end = p_buffer_ + length;
976 inline void create_back()
979 ETL_INCREMENT_DEBUG_COUNT
987 inline void create_back(const_reference value)
990 ETL_INCREMENT_DEBUG_COUNT
995 #if ETL_CPP11_SUPPORTED
999 inline void create_back(rvalue_reference value)
1002 ETL_INCREMENT_DEBUG_COUNT
1011 inline void destroy_back()
1016 ETL_DECREMENT_DEBUG_COUNT
1025 #if defined(ETL_POLYMORPHIC_VECTOR) || defined(ETL_POLYMORPHIC_CONTAINERS)
1045 template <
typename T>
1058 template <
typename T>
1061 return !(lhs == rhs);
1071 template <
typename T>
1074 return etl::lexicographical_compare(lhs.
begin(), lhs.
end(), rhs.
begin(), rhs.
end());
1084 template <
typename T>
1097 template <
typename T>
1100 return !(lhs > rhs);
1110 template <
typename T>
1113 return !(lhs < rhs);
1127 template <
typename T, const
size_t MAX_SIZE_>
1132 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U),
"Zero capacity etl::vector is not valid");
1134 static const size_t MAX_SIZE = MAX_SIZE_;
1140 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1150 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1153 this->
resize(initial_size);
1162 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1165 this->
resize(initial_size, value);
1174 template <
typename TIterator>
1176 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1178 this->
assign(first, last);
1181 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1185 vector(std::initializer_list<T> init)
1186 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1188 this->
assign(init.begin(), init.end());
1196 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1214 #if ETL_CPP11_SUPPORTED
1219 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1225 typename etl::ivector<T>::iterator itr = other.begin();
1226 while (itr != other.end())
1244 typename etl::ivector<T>::iterator itr = rhs.
begin();
1245 while (itr != rhs.end())
1269 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1273 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1277 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1292 #if ETL_CPP17_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1293 template <
typename T,
typename... Ts>
1295 ->vector<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T>, 1U +
sizeof...(Ts)>;
1304 template <
typename T>
1326 this->
resize(initial_size);
1338 this->
resize(initial_size, value);
1347 template <
typename TIterator>
1351 this->
assign(first, last);
1354 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1361 this->
assign(init.begin(), init.end());
1387 #if ETL_CPP11_SUPPORTED
1398 typename etl::ivector<T>::iterator itr = other.
begin();
1399 while (itr != other.end())
1418 typename etl::ivector<T>::iterator itr = rhs.
begin();
1419 while (itr != rhs.end())
1444 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1448 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1462 template <
typename T, const
size_t MAX_SIZE_>
1467 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U),
"Zero capacity etl::vector is not valid");
1469 static const size_t MAX_SIZE = MAX_SIZE_;
1475 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1485 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1488 this->resize(initial_size);
1497 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1500 this->resize(initial_size, value);
1509 template <
typename TIterator>
1511 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1513 this->assign(first, last);
1516 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1520 vector(std::initializer_list<T*> init)
1521 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1523 this->assign(init.begin(), init.end());
1531 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1546 #if ETL_CPP11_SUPPORTED
1551 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1559 vector& operator = (vector&& rhs)
1571 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1586 #if ETL_CPP17_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1587 template <
typename T,
typename... Ts>
1589 ->vector<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T*>, 1U +
sizeof...(Ts)>;
1598 template <
typename T>
1607 :
etl::
ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1617 :
etl::
ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1620 this->resize(initial_size);
1629 :
etl::
ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1632 this->resize(initial_size, value);
1641 template <
typename TIterator>
1642 vector_ext(TIterator first, TIterator last,
void* buffer,
size_t max_size)
1643 :
etl::
ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1645 this->assign(first, last);
1648 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1652 vector_ext(std::initializer_list<T*> init,
void* buffer,
size_t max_size)
1653 :
etl::
ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1655 this->assign(init.begin(), init.end());
1663 :
etl::
ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1678 #if ETL_CPP11_SUPPORTED
1683 :
etl::
ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1691 vector_ext& operator = (vector_ext&& rhs)
1711 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1720 #ifdef ETL_COMPILER_GCC
1721 #pragma GCC diagnostic pop
Definition: constant.h:45
Definition: alignment.h:116
#define ETL_ASSERT(b, e)
Definition: error_handler.h:290
void create_copy_at(T *p, const T &value)
Definition: memory.h:1635
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at(T *)
Definition: memory.h:949
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n(TIterator i_begin, TSize n)
Definition: memory.h:1111
void create_value_at(T *p)
Definition: memory.h:1614
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, void >::type destroy(TIterator, TIterator)
Definition: memory.h:1025
TOutputIterator uninitialized_move(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition: memory.h:472
TOutputIterator uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition: memory.h:297
TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T &value)
Definition: memory.h:177
T * addressof(T &t)
Definition: memory.h:61
add_rvalue_reference
Definition: type_traits_generator.h:1348
is_same
Definition: type_traits_generator.h:981
is_trivially_copyable
Definition: type_traits_generator.h:1191
remove_cv
Definition: type_traits_generator.h:921
void initialise()
Initialise the vector.
Definition: vector.h:950
iterator erase(iterator first, iterator last)
Definition: vector.h:836
iterator begin()
Definition: vector.h:108
~vector_ext()
Destructor.
Definition: vector.h:1435
iterator emplace(iterator position, const T1 &value1)
Emplaces a value to the vector at the specified position.
Definition: vector.h:605
const_reference at(size_t i) const
Definition: vector.h:296
size_type max_size() const
Definition: vector_base.h:143
vector_ext & operator=(const vector_ext &rhs)
Assignment operator.
Definition: vector.h:1377
void emplace_back(const T1 &value1, const T2 &value2, const T3 &value3)
Definition: vector.h:486
vector_ext(TIterator first, TIterator last, void *buffer, size_t max_size)
Definition: vector.h:1642
const_iterator begin() const
Definition: vector.h:117
void push_back(const_reference value)
Definition: vector.h:408
vector_ext(size_t initial_size, typename etl::ivector< T >::parameter_t value, void *buffer, size_t max_size)
Definition: vector.h:1334
vector()
Constructor.
Definition: vector.h:1474
const_reverse_iterator crbegin() const
Definition: vector.h:198
vector(size_t initial_size)
Definition: vector.h:1149
reverse_iterator rend()
Definition: vector.h:180
iterator insert(iterator position, const_reference value)
Definition: vector.h:531
const_iterator cend() const
Definition: vector.h:153
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1272
vector(const vector &other)
Copy constructor.
Definition: vector.h:1195
vector_ext(void *buffer, size_t max_size)
Constructor.
Definition: vector.h:1312
void clear()
Clears the vector.
Definition: vector.h:398
vector_ext(size_t initial_size, void *buffer, size_t max_size)
Definition: vector.h:1322
void emplace_back(const T1 &value1)
Definition: vector.h:454
void insert(iterator position, size_t n, parameter_t value)
Definition: vector.h:712
void reserve(size_t)
Does nothing.
Definition: vector.h:254
const size_type CAPACITY
The maximum number of elements in the vector.
Definition: vector_base.h:165
void emplace_back(const T1 &value1, const T2 &value2)
Definition: vector.h:470
pointer p_buffer
Pointer to the start of the buffer.
Definition: vector.h:968
vector_ext(size_t initial_size, typename etl::ivector< T * >::parameter_t value, void *buffer, size_t max_size)
Definition: vector.h:1628
reference front()
Definition: vector.h:306
iterator end()
Definition: vector.h:126
pointer data()
Definition: vector.h:342
const_pointer data() const
Definition: vector.h:351
vector(size_t initial_size, typename etl::ivector< T * >::parameter_t value)
Definition: vector.h:1496
const_reverse_iterator crend() const
Definition: vector.h:207
vector_ext(TIterator first, TIterator last, void *buffer, size_t max_size)
Definition: vector.h:1348
vector(size_t initial_size, typename etl::ivector< T >::parameter_t value)
Definition: vector.h:1161
reference operator[](size_t i)
Definition: vector.h:263
~vector_ext()
Destructor.
Definition: vector.h:1702
const_iterator cbegin() const
Definition: vector.h:144
ivector(T *p_buffer_, size_t MAX_SIZE)
Constructor.
Definition: vector.h:940
const_iterator end() const
Definition: vector.h:135
const_reverse_iterator rend() const
Definition: vector.h:189
~ivector()
Destructor.
Definition: vector.h:1032
vector_ext(size_t initial_size, void *buffer, size_t max_size)
Definition: vector.h:1616
void pop_back()
Definition: vector.h:517
void assign(size_t n, parameter_t value)
Definition: vector.h:385
reference at(size_t i)
Definition: vector.h:284
void emplace_back(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: vector.h:502
vector & operator=(const vector &rhs)
Assignment operator.
Definition: vector.h:1204
const_reference back() const
Definition: vector.h:333
vector(TIterator first, TIterator last)
Definition: vector.h:1175
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1443
vector_ext(void *buffer, size_t max_size)
Constructor.
Definition: vector.h:1606
void repair_buffer(T *p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition: vector.h:961
void insert(iterator position, TIterator first, TIterator last)
Definition: vector.h:767
vector(const vector &other)
Copy constructor.
Definition: vector.h:1530
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1570
bool full() const
Definition: vector.h:914
vector_ext(const vector_ext &other, void *buffer, size_t max_size)
Copy constructor.
Definition: vector.h:1368
void assign(TIterator first, TIterator last)
Definition: vector.h:364
pointer p_end
Pointer to one past the last element in the buffer.
Definition: vector.h:969
vector(size_t initial_size)
Definition: vector.h:1484
ivector & operator=(const ivector &rhs)
Assignment operator.
Definition: vector.h:859
size_type size() const
Definition: vector.h:896
iterator erase(iterator i_element)
Definition: vector.h:820
void resize(size_t new_size, T value)
Definition: vector.h:230
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1710
bool empty() const
Definition: vector.h:905
const_reverse_iterator rbegin() const
Definition: vector.h:171
void resize(size_t new_size)
Definition: vector.h:218
~vector()
Destructor.
Definition: vector.h:1261
reference back()
Definition: vector.h:324
size_t available() const
Definition: vector.h:923
vector()
Constructor.
Definition: vector.h:1139
vector_ext(const vector_ext &other, void *buffer, size_t max_size)
Copy constructor.
Definition: vector.h:1662
reverse_iterator rbegin()
Definition: vector.h:162
const_reference front() const
Definition: vector.h:315
vector(TIterator first, TIterator last)
Definition: vector.h:1510
Definition: ivectorpointer.h:49
Definition: vector.h:1129
Definition: vector_base.h:125
Definition: vector_base.h:83
Template deduction guides.
Definition: vector.h:1306
Definition: vector_base.h:69
Definition: vector_base.h:111
Definition: vector_base.h:97
Definition: absolute.h:37
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:645
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:594
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:582
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:606
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:621
iterator
Definition: iterator.h:422