31#ifndef ETL_VECTOR_INCLUDED
32#define ETL_VECTOR_INCLUDED
34#define ETL_IN_VECTOR_H
48#include "static_assert.h"
77 typedef const T& const_reference;
79 typedef T&& rvalue_reference;
82 typedef const T* const_pointer;
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;
127 const_iterator
end()
const
156 return reverse_iterator(
end());
165 return const_reverse_iterator(
end());
174 return reverse_iterator(
begin());
181 const_reverse_iterator
rend()
const
183 return const_reverse_iterator(
begin());
192 return const_reverse_iterator(
cend());
199 const_reverse_iterator
crend()
const
201 return const_reverse_iterator(
cbegin());
222 void resize(
size_t new_size, const_reference value)
226 const size_t current_size =
size();
227 size_t delta = (current_size < new_size) ? new_size - current_size : current_size - new_size;
229 if (current_size < new_size)
232 ETL_ADD_DEBUG_COUNT(delta)
237 ETL_SUBTRACT_DEBUG_COUNT(delta)
251#if defined(ETL_DEBUG_COUNT)
252 if (
size() < new_size)
254 ETL_ADD_DEBUG_COUNT(new_size -
size())
258 ETL_SUBTRACT_DEBUG_COUNT(
size() - new_size)
299 reference
at(
size_t i)
311 const_reference
at(
size_t i)
const
378 template <
typename TIterator>
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");
384#if ETL_IS_DEBUG_BUILD
385 difference_type d = etl::distance(first, last);
392 ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last)))
408 ETL_ADD_DEBUG_COUNT(uint32_t(n))
434#if defined(ETL_CHECK_PUSH_POP)
448#if defined(ETL_CHECK_PUSH_POP)
451 create_back(etl::move(value));
455#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_VECTOR_FORCE_CPP03_IMPLEMENTATION)
461 template <
typename ... Args>
464#if defined(ETL_CHECK_PUSH_POP)
467 ::new (
p_end) T(etl::forward<Args>(args)...);
469 ETL_INCREMENT_DEBUG_COUNT
478 template <
typename T1>
481#if defined(ETL_CHECK_PUSH_POP)
484 ::new (
p_end) T(value1);
486 ETL_INCREMENT_DEBUG_COUNT
495 template <
typename T1,
typename T2>
498#if defined(ETL_CHECK_PUSH_POP)
501 ::new (
p_end) T(value1, value2);
503 ETL_INCREMENT_DEBUG_COUNT
512 template <
typename T1,
typename T2,
typename T3>
513 reference
emplace_back(
const T1& value1,
const T2& value2,
const T3& value3)
515#if defined(ETL_CHECK_PUSH_POP)
518 ::new (
p_end) T(value1, value2, value3);
520 ETL_INCREMENT_DEBUG_COUNT
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)
532#if defined(ETL_CHECK_PUSH_POP)
535 ::new (
p_end) T(value1, value2, value3, value4);
537 ETL_INCREMENT_DEBUG_COUNT
548#if defined(ETL_CHECK_PUSH_POP)
560 iterator
insert(const_iterator position, const_reference value)
564 iterator position_ = to_iterator(position);
566 if (position_ ==
end())
573 etl::move_backward(position_,
p_end - 2,
p_end - 1);
591 iterator position_ = to_iterator(position);
593 if (position_ ==
end())
595 create_back(etl::move(value));
599 create_back(etl::move(
back()));
600 etl::move_backward(position_,
p_end - 2,
p_end - 1);
601 *position_ = etl::move(value);
611#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
612 template <
typename ... Args>
613 iterator
emplace(const_iterator position, Args && ... args)
617 iterator position_ = to_iterator(position);
621 if (position_ ==
end())
624 ETL_INCREMENT_DEBUG_COUNT
630 etl::move_backward(position_,
p_end - 2,
p_end - 1);
634 ::new (p) T(etl::forward<Args>(args)...);
639 template <
typename T1>
640 iterator
emplace(const_iterator position,
const T1& value1)
644 iterator position_ = to_iterator(position);
648 if (position_ ==
end())
651 ETL_INCREMENT_DEBUG_COUNT
657 etl::move_backward(position_,
p_end - 2,
p_end - 1);
666 template <
typename T1,
typename T2>
667 iterator emplace(const_iterator position,
const T1& value1,
const T2& value2)
671 iterator position_ = to_iterator(position);
675 if (position_ ==
end())
678 ETL_INCREMENT_DEBUG_COUNT
684 etl::move_backward(position_,
p_end - 2,
p_end - 1);
688 ::new (p) T(value1, value2);
693 template <
typename T1,
typename T2,
typename T3>
694 iterator
emplace(const_iterator position,
const T1& value1,
const T2& value2,
const T3& value3)
698 iterator position_ = to_iterator(position);
702 if (position_ ==
end())
705 ETL_INCREMENT_DEBUG_COUNT
711 etl::move_backward(position_,
p_end - 2,
p_end - 1);
715 ::new (p) T(value1, value2, value3);
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)
725 iterator position_ = to_iterator(position);
729 if (position_ ==
end())
732 ETL_INCREMENT_DEBUG_COUNT
738 etl::move_backward(position_,
p_end - 2,
p_end - 1);
742 ::new (p) T(value1, value2, value3, value4);
759 iterator position_ = to_iterator(position);
762 size_t insert_begin = etl::distance(
begin(), position_);
763 size_t insert_end = insert_begin + insert_n;
767 size_t construct_old_n;
768 iterator p_construct_old;
770 if (insert_end >
size())
773 construct_old_n =
size() - insert_begin;
774 p_construct_old =
p_buffer + insert_end;
778 copy_old_n =
size() - insert_begin - insert_n;
779 construct_old_n = insert_n;
780 p_construct_old =
p_end;
783 size_t copy_new_n = construct_old_n;
784 size_t construct_new_n = insert_n - copy_new_n;
788 ETL_ADD_DEBUG_COUNT(construct_old_n)
791 etl::move_backward(
p_buffer + insert_begin,
p_buffer + insert_begin + copy_old_n,
p_buffer + insert_end + copy_old_n);
795 ETL_ADD_DEBUG_COUNT(construct_new_n)
798 etl::fill_n(
p_buffer + insert_begin, copy_new_n, value);
811 template <
class TIterator>
814 size_t count = etl::distance(first, last);
818 size_t insert_n = count;
819 size_t insert_begin = etl::distance(
cbegin(), position);
820 size_t insert_end = insert_begin + insert_n;
824 size_t construct_old_n;
825 iterator p_construct_old;
827 if (insert_end >
size())
830 construct_old_n =
size() - insert_begin;
831 p_construct_old =
p_buffer + insert_end;
835 copy_old_n =
size() - insert_begin - insert_n;
836 construct_old_n = insert_n;
837 p_construct_old =
p_end;
840 size_t copy_new_n = construct_old_n;
841 size_t construct_new_n = insert_n - copy_new_n;
845 ETL_ADD_DEBUG_COUNT(construct_old_n)
848 etl::move_backward(
p_buffer + insert_begin,
p_buffer + insert_begin + copy_old_n,
p_buffer + insert_end + copy_old_n);
852 ETL_ADD_DEBUG_COUNT(construct_new_n)
855 etl::copy(first, first + copy_new_n,
p_buffer + insert_begin);
867 etl::move(i_element + 1,
end(), i_element);
878 iterator
erase(const_iterator i_element)
880 iterator i_element_ = to_iterator(i_element);
882 etl::move(i_element_ + 1,
end(), i_element_);
896 iterator
erase(const_iterator first, const_iterator last)
898 iterator first_ = to_iterator(first);
899 iterator last_ = to_iterator(last);
901 if (first ==
begin() && last ==
end())
907 etl::move(last_,
end(), first_);
908 size_t n_delete = etl::distance(first_, last_);
912 ETL_SUBTRACT_DEBUG_COUNT(n_delete)
942 while (itr != rhs.end())
991#ifdef ETL_IVECTOR_REPAIR_ENABLE
995 virtual void repair() = 0;
1016 ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(
p_buffer,
p_end)))
1028 p_end = p_buffer_ + length;
1042 ETL_INCREMENT_DEBUG_COUNT
1050 void create_back(const_reference value)
1053 ETL_INCREMENT_DEBUG_COUNT
1062 void create_back(rvalue_reference value)
1065 ETL_INCREMENT_DEBUG_COUNT
1079 ETL_DECREMENT_DEBUG_COUNT
1090 ETL_CONSTEXPR iterator to_iterator(const_iterator itr)
const
1092 return const_cast<iterator
>(itr);
1103 template <
typename T>
1116 template <
typename T>
1119 return !(lhs == rhs);
1129 template <
typename T>
1132 return etl::lexicographical_compare(lhs.
begin(), lhs.
end(), rhs.
begin(), rhs.
end());
1142 template <
typename T>
1155 template <
typename T>
1158 return !(lhs > rhs);
1168 template <
typename T>
1171 return !(lhs < rhs);
1185 template <
typename T, const
size_t MAX_SIZE_>
1190 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U),
"Zero capacity etl::vector is not valid");
1192 static const size_t MAX_SIZE = MAX_SIZE_;
1198 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1208 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1211 this->
resize(initial_size);
1220 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1223 this->
resize(initial_size, value);
1232 template <
typename TIterator>
1234 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1236 this->
assign(first, last);
1239#if ETL_HAS_INITIALIZER_LIST
1243 vector(std::initializer_list<T> init)
1244 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1246 this->
assign(init.begin(), init.end());
1254 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1277 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1283 typename etl::ivector<T>::iterator itr = other.begin();
1284 while (itr != other.end())
1302 typename etl::ivector<T>::iterator itr = rhs.
begin();
1303 while (itr != rhs.end())
1319#ifdef ETL_IVECTOR_REPAIR_ENABLE
1330#ifdef ETL_IVECTOR_REPAIR_ENABLE
1334#ifdef ETL_IVECTOR_REPAIR_ENABLE
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)>;
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)>
1363 return { { etl::forward<T>(t)... } };
1373 template <
typename T>
1395 this->
resize(initial_size);
1407 this->
resize(initial_size, value);
1416 template <
typename TIterator>
1420 this->
assign(first, last);
1423#if ETL_HAS_INITIALIZER_LIST
1430 this->
assign(init.begin(), init.end());
1467 typename etl::ivector<T>::iterator itr = other.
begin();
1468 while (itr != other.end())
1487 typename etl::ivector<T>::iterator itr = rhs.
begin();
1488 while (itr != rhs.end())
1513#ifdef ETL_IVECTOR_REPAIR_ENABLE
1526 template <
typename T, const
size_t MAX_SIZE_>
1531 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U),
"Zero capacity etl::vector is not valid");
1533 static const size_t MAX_SIZE = MAX_SIZE_;
1539 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1549 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1552 this->resize(initial_size);
1561 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1564 this->resize(initial_size, value);
1573 template <
typename TIterator>
1575 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1577 this->assign(first, last);
1580#if ETL_HAS_INITIALIZER_LIST
1584 vector(std::initializer_list<T*> init)
1585 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1587 this->assign(init.begin(), init.end());
1595 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1615 :
etl::
ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1623 vector& operator = (vector&& rhs)
1635#ifdef ETL_IVECTOR_REPAIR_ENABLE
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)>;
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)>
1659 return { { etl::forward<T*>(t)... } };
1669 template <
typename T>
1691 this->resize(initial_size);
1703 this->resize(initial_size, value);
1712 template <
typename TIterator>
1716 this->assign(first, last);
1719#if ETL_HAS_INITIALIZER_LIST
1726 this->assign(init.begin(), init.end());
1767 vector_ext(vector_ext&& other) ETL_DELETE;
1772 vector_ext& operator = (vector_ext&& rhs)
1792#ifdef ETL_IVECTOR_REPAIR_ENABLE
1803 template <
typename T,
typename U>
1804 typename etl::ivector<T>::difference_type
1808 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.
end());
1817 template <
typename T,
typename TPredicate>
1818 typename etl::ivector<T>::difference_type
1822 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.
end());
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: 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