31#ifndef ETL_VECTOR_INCLUDED
32#define ETL_VECTOR_INCLUDED
34#define ETL_IN_VECTOR_H
48#include "static_assert.h"
85 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
86 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
88 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
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());
226 const size_t current_size =
size();
232 ETL_ADD_DEBUG_COUNT(delta);
237 ETL_SUBTRACT_DEBUG_COUNT(delta);
251#if defined(ETL_DEBUG_COUNT)
381 template <
typename TIterator>
387#if ETL_IS_DEBUG_BUILD
388 difference_type
d = etl::distance(first, last);
395 ETL_ADD_DEBUG_COUNT(
uint32_t(etl::distance(first, last)));
437#if defined(ETL_CHECK_PUSH_POP)
451#if defined(ETL_CHECK_PUSH_POP)
454 create_back(etl::move(value));
458#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_VECTOR_FORCE_CPP03_IMPLEMENTATION)
464 template <
typename ... Args>
467#if defined(ETL_CHECK_PUSH_POP)
472 ETL_INCREMENT_DEBUG_COUNT;
483#if defined(ETL_CHECK_PUSH_POP)
488 ETL_INCREMENT_DEBUG_COUNT;
497 template <
typename T1>
500#if defined(ETL_CHECK_PUSH_POP)
505 ETL_INCREMENT_DEBUG_COUNT;
514 template <
typename T1,
typename T2>
517#if defined(ETL_CHECK_PUSH_POP)
520 ::new (
p_end)
T(value1, value2);
522 ETL_INCREMENT_DEBUG_COUNT;
531 template <
typename T1,
typename T2,
typename T3>
534#if defined(ETL_CHECK_PUSH_POP)
537 ::new (
p_end)
T(value1, value2, value3);
539 ETL_INCREMENT_DEBUG_COUNT;
548 template <
typename T1,
typename T2,
typename T3,
typename T4>
551#if defined(ETL_CHECK_PUSH_POP)
554 ::new (
p_end)
T(value1, value2, value3, value4);
556 ETL_INCREMENT_DEBUG_COUNT;
567#if defined(ETL_CHECK_PUSH_POP)
614 create_back(etl::move(value));
618 create_back(etl::move(
back()));
619 etl::move_backward(position_,
p_end - 2,
p_end - 1);
620 *position_ = etl::move(value);
630#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
631 template <
typename ... Args>
632 iterator
emplace(const_iterator position, Args && ... args)
636 iterator position_ = to_iterator(position);
640 if (position_ ==
end())
643 ETL_INCREMENT_DEBUG_COUNT;
649 etl::move_backward(position_,
p_end - 2,
p_end - 1);
658 template <
typename T1>
670 ETL_INCREMENT_DEBUG_COUNT;
685 template <
typename T1,
typename T2>
697 ETL_INCREMENT_DEBUG_COUNT;
703 etl::move_backward(position_,
p_end - 2,
p_end - 1);
707 ::new (p) T(value1, value2);
712 template <
typename T1,
typename T2,
typename T3>
713 iterator
emplace(const_iterator position,
const T1& value1,
const T2& value2,
const T3& value3)
717 iterator position_ = to_iterator(position);
721 if (position_ ==
end())
724 ETL_INCREMENT_DEBUG_COUNT;
730 etl::move_backward(position_,
p_end - 2,
p_end - 1);
734 ::new (p) T(value1, value2, value3);
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)
744 iterator position_ = to_iterator(position);
748 if (position_ ==
end())
751 ETL_INCREMENT_DEBUG_COUNT;
757 etl::move_backward(position_,
p_end - 2,
p_end - 1);
761 ::new (p) T(value1, value2, value3, value4);
830 template <
class TIterator>
833 size_t count = etl::distance(first, last);
920 if (first ==
begin() && last ==
end())
961 while (itr !=
rhs.end())
1010#ifdef ETL_IVECTOR_REPAIR_ENABLE
1014 virtual void repair() = 0;
1060 etl::create_value_at(
p_end);
1061 ETL_INCREMENT_DEBUG_COUNT;
1069 void create_back(const_reference value)
1071 etl::create_copy_at(
p_end, value);
1072 ETL_INCREMENT_DEBUG_COUNT;
1081 void create_back(rvalue_reference value)
1083 etl::create_copy_at(
p_end, etl::move(value));
1084 ETL_INCREMENT_DEBUG_COUNT;
1098 ETL_DECREMENT_DEBUG_COUNT;
1102 ivector(
const ivector&) ETL_DELETE;
1109 ETL_CONSTEXPR iterator to_iterator(const_iterator itr)
const
1111 return const_cast<iterator
>(itr);
1122 template <
typename T>
1125 return (
lhs.size() ==
rhs.size()) && etl::equal(
lhs.begin(),
lhs.end(),
rhs.begin());
1135 template <
typename T>
1148 template <
typename T>
1151 return etl::lexicographical_compare(
lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
1161 template <
typename T>
1174 template <
typename T>
1187 template <
typename T>
1204 template <
typename T, const
size_t MAX_SIZE_>
1209 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U),
"Zero capacity etl::vector is not valid");
1211 static const size_t MAX_SIZE = MAX_SIZE_;
1217 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1226 explicit vector(
size_t initial_size)
1227 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1230 this->
resize(initial_size);
1239 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1242 this->
resize(initial_size, value);
1251 template <
typename TIterator>
1253 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1255 this->
assign(first, last);
1258#if ETL_HAS_INITIALIZER_LIST
1262 vector(std::initializer_list<T> init)
1263 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1265 this->
assign(init.begin(), init.end());
1272 vector(
const vector& other)
1273 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1275 this->
assign(other.begin(), other.end());
1281 vector& operator = (
const vector& rhs)
1285 this->
assign(rhs.cbegin(), rhs.cend());
1295 vector(vector&& other)
1296 :
etl::
ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1303 while (itr != other.end())
1316 vector& operator = (vector&& rhs)
1322 while (itr != rhs.end())
1338#ifdef ETL_IVECTOR_REPAIR_ENABLE
1349#ifdef ETL_IVECTOR_REPAIR_ENABLE
1350 virtual void repair() ETL_OVERRIDE
1368#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
1369 template <
typename... T>
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)>
1390 template <
typename T>
1398 vector_ext(
void* buffer,
size_t max_size)
1408 explicit vector_ext(
size_t initial_size,
void* buffer,
size_t max_size)
1412 this->
resize(initial_size);
1424 this->
resize(initial_size, value);
1433 template <
typename TIterator>
1437 this->
assign(first, last);
1440#if ETL_HAS_INITIALIZER_LIST
1444 vector_ext(std::initializer_list<T> init,
void* buffer,
size_t max_size)
1447 this->
assign(init.begin(), init.end());
1454 vector_ext(
const vector_ext& other,
void* buffer,
size_t max_size)
1457 this->
assign(other.begin(), other.end());
1463 vector_ext& operator = (
const vector_ext& rhs)
1467 this->
assign(rhs.cbegin(), rhs.cend());
1477 vector_ext(vector_ext&& other,
void* buffer,
size_t max_size)
1485 while (itr != other.end())
1498 vector_ext& operator = (vector_ext&& rhs)
1505 while (itr != rhs.end())
1529#ifdef ETL_IVECTOR_REPAIR_ENABLE
1530 virtual void repair() ETL_OVERRIDE
1544 template <
typename T, const
size_t MAX_SIZE_>
1549 ETL_STATIC_ASSERT((MAX_SIZE_ > 0U),
"Zero capacity etl::vector is not valid");
1551 static const size_t MAX_SIZE = MAX_SIZE_;
1557 :
etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1566 explicit vector(
size_t initial_size)
1567 :
etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1570 this->resize(initial_size);
1579 :
etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1582 this->resize(initial_size, value);
1591 template <
typename TIterator>
1593 :
etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1595 this->assign(first, last);
1598#if ETL_HAS_INITIALIZER_LIST
1602 vector(std::initializer_list<T*> init)
1603 :
etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1605 this->assign(init.begin(), init.end());
1612 vector(
const vector& other)
1613 :
etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1621 vector& operator = (
const vector& rhs)
1632 vector(vector&& other)
1633 :
etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1641 vector& operator = (vector&& rhs)
1652#ifdef ETL_IVECTOR_REPAIR_ENABLE
1653 virtual void repair() ETL_OVERRIDE
1669#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
1670 template <
typename... T>
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)>
1688 template <
typename T>
1696 vector_ext(
void* buffer,
size_t max_size)
1697 :
etl::ivector<T*>(reinterpret_cast<T**>(buffer),
max_size)
1706 vector_ext(
size_t initial_size,
void* buffer,
size_t max_size)
1707 :
etl::ivector<T*>(reinterpret_cast<T**>(buffer),
max_size)
1710 this->resize(initial_size);
1719 :
etl::ivector<T*>(reinterpret_cast<T**>(buffer),
max_size)
1722 this->resize(initial_size, value);
1731 template <
typename TIterator>
1733 :
etl::ivector<T*>(reinterpret_cast<T**>(buffer),
max_size)
1735 this->assign(first, last);
1738#if ETL_HAS_INITIALIZER_LIST
1742 vector_ext(std::initializer_list<T*> init,
void* buffer,
size_t max_size)
1743 :
etl::ivector<T*>(reinterpret_cast<T**>(buffer),
max_size)
1745 this->assign(init.begin(), init.end());
1752 vector_ext(
const vector_ext& other,
void* buffer,
size_t max_size)
1753 :
etl::ivector<T*>(reinterpret_cast<T**>(buffer),
max_size)
1761 vector_ext(
const vector_ext& other) ETL_DELETE;
1766 vector_ext& operator = (
const vector_ext& rhs)
1777 vector_ext(vector_ext&& other,
void* buffer,
size_t max_size)
1778 :
etl::ivector<T*>(reinterpret_cast<T**>(buffer),
max_size)
1786 vector_ext(vector_ext&& other) ETL_DELETE;
1791 vector_ext& operator = (vector_ext&& rhs)
1810#ifdef ETL_IVECTOR_REPAIR_ENABLE
1811 virtual void repair() ETL_OVERRIDE
1823 template <
typename T,
typename U>
1824 typename etl::ivector<T>::difference_type
1828 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
1829 v.erase(itr, v.end());
1837 template <
typename T,
typename TPredicate>
1838 typename etl::ivector<T>::difference_type
1842 typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
1843 v.erase(itr, v.end());
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_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