31#ifndef ETL_DEQUE_INCLUDED
32#define ETL_DEQUE_INCLUDED
69 deque_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
70 :
exception(reason_, file_name_, line_number_)
83 deque_full(string_type file_name_, numeric_type line_number_)
84 :
etl::deque_exception(ETL_ERROR_TEXT(
"deque:full", ETL_DEQUE_FILE_ID
"A"), file_name_, line_number_)
97 deque_empty(string_type file_name_, numeric_type line_number_)
98 :
etl::deque_exception(ETL_ERROR_TEXT(
"deque:empty", ETL_DEQUE_FILE_ID
"B"), file_name_, line_number_)
112 :
etl::deque_exception(ETL_ERROR_TEXT(
"deque:bounds", ETL_DEQUE_FILE_ID
"C"), file_name_, line_number_)
126 :
deque_exception(ETL_ERROR_TEXT(
"deque:type", ETL_DEQUE_FILE_ID
"D"), file_name_, line_number_)
139 typedef size_t size_type;
217 ETL_DECLARE_DEBUG_COUNT
225 template <
typename T>
230 typedef T value_type;
231 typedef size_t size_type;
232 typedef T& reference;
233 typedef const T& const_reference;
235 typedef T&& rvalue_reference;
238 typedef const T* const_pointer;
239 typedef typename etl::iterator_traits<pointer>::difference_type difference_type;
261 : index(other.index),
262 p_deque(other.p_deque),
263 p_buffer(other.p_buffer)
271 p_deque = other.p_deque;
272 p_buffer = other.p_buffer;
280 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
289 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
295 iterator& operator +=(difference_type offset)
304 operator -= (-offset);
311 iterator& operator -=(difference_type offset)
316 index = (index < 0) ? index + p_deque->
BUFFER_SIZE : index;
320 operator += (-offset);
329 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
338 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
344 reference operator *()
const
346 return p_buffer[index];
350 pointer operator ->()
const
352 return &p_buffer[index];
374 return lhs.index == rhs.index;
380 return !(lhs == rhs);
386 const difference_type lhs_index = lhs.get_index();
387 const difference_type rhs_index = rhs.get_index();
388 const difference_type reference_index = lhs.container().
begin().get_index();
389 const size_t buffer_size = lhs.container().
max_size() + 1;
391 const difference_type lhs_distance = (lhs_index < reference_index) ? buffer_size + lhs_index - reference_index : lhs_index - reference_index;
392 const difference_type rhs_distance = (rhs_index < reference_index) ? buffer_size + rhs_index - reference_index : rhs_index - reference_index;
394 return lhs_distance < rhs_distance;
416 difference_type get_index()
const
428 pointer get_buffer()
const
438 swap(index, other.index);
444 difference_type distance(difference_type firstIndex, difference_type index_)
const
446 if (index_ < firstIndex)
452 return index_ - firstIndex;
457 iterator(difference_type index_,
ideque& the_deque, pointer p_buffer_)
459 , p_deque(&the_deque)
460 , p_buffer(p_buffer_)
464 difference_type index;
489 , p_deque(other.p_deque)
490 , p_buffer(other.p_buffer)
497 , p_deque(other.p_deque)
498 , p_buffer(other.p_buffer)
506 p_deque = other.p_deque;
507 p_buffer = other.p_buffer;
515 p_deque = other.p_deque;
516 p_buffer = other.p_buffer;
524 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
533 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
548 operator -= (-offset);
560 index = (index < 0) ? static_cast<size_t>(index) + p_deque->
BUFFER_SIZE : index;
564 operator += (-offset);
573 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
582 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
588 const_reference operator *()
const
590 return p_buffer[index];
594 const_pointer operator ->()
const
596 return &p_buffer[index];
618 return lhs.index == rhs.index;
624 return !(lhs == rhs);
630 const difference_type lhs_index = lhs.get_index();
631 const difference_type rhs_index = rhs.get_index();
632 const difference_type reference_index = lhs.container().
begin().get_index();
633 const size_t buffer_size = lhs.container().
max_size() + 1UL;
635 const difference_type lhs_distance = (lhs_index < reference_index) ? buffer_size + lhs_index - reference_index : lhs_index - reference_index;
636 const difference_type rhs_distance = (rhs_index < reference_index) ? buffer_size + rhs_index - reference_index : rhs_index - reference_index;
638 return lhs_distance < rhs_distance;
660 difference_type get_index()
const
672 pointer get_buffer()
const
686 difference_type distance(difference_type firstIndex, difference_type index_)
const
688 if (index_ < firstIndex)
694 return index_ - firstIndex;
701 , p_deque(&the_deque)
702 , p_buffer(p_buffer_)
706 difference_type index;
711 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
712 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
717 template<
typename TIterator>
719 assign(TIterator range_begin, TIterator range_end)
723 while (range_begin != range_end)
736 void assign(size_type n,
const value_type& value)
744 create_element_back(value);
754 reference
at(
size_t index)
769 const_reference
at(
size_t index)
const
892 return reverse_iterator(
end());
900 return const_reverse_iterator(
end());
908 return const_reverse_iterator(
cend());
916 return reverse_iterator(
begin());
922 const_reverse_iterator
rend()
const
924 return const_reverse_iterator(
begin());
930 const_reverse_iterator
crend()
const
932 return const_reverse_iterator(
cbegin());
959 iterator position(to_iterator(insert_position));
963 if (insert_position ==
begin())
965 create_element_front(value);
968 else if (insert_position ==
end())
970 create_element_back(value);
976 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
979 create_element_front(*_begin);
982 etl::move(_begin + 1, position, _begin);
990 create_element_back(*(
_end - 1));
993 etl::move_backward(position,
_end - 2,
_end - 1);
1010 iterator insert(const_iterator insert_position, value_type&& value)
1016 if (insert_position ==
begin())
1018 create_element_front(etl::move(value));
1021 else if (insert_position ==
end())
1023 create_element_back(etl::move(value));
1024 position =
_end - 1;
1029 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1032 create_element_front(etl::move(*_begin));
1035 etl::move(_begin + 1, position, _begin);
1038 *--position = etl::move(value);
1043 create_element_back(etl::move(*(
_end - 1)));
1046 etl::move_backward(position,
_end - 2,
_end - 1);
1049 *position = etl::move(value);
1062#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
1063 template <
typename ... Args>
1064 iterator
emplace(const_iterator insert_position, Args && ... args)
1066 iterator position(insert_position.index, *
this,
p_buffer);
1072 if (insert_position ==
begin())
1077 ETL_INCREMENT_DEBUG_COUNT
1080 else if (insert_position ==
end())
1085 ETL_INCREMENT_DEBUG_COUNT
1086 position =
_end - 1;
1091 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1094 create_element_front(*_begin);
1097 etl::move(_begin + 1, position, _begin);
1107 create_element_back(*(
_end - 1));
1110 etl::move_backward(position,
_end - 2,
_end - 1);
1118 ::new (p) T(etl::forward<Args>(args)...);
1130 template <
typename T1>
1139 if (insert_position ==
begin())
1144 ETL_INCREMENT_DEBUG_COUNT
1147 else if (insert_position ==
end())
1152 ETL_INCREMENT_DEBUG_COUNT
1153 position =
_end - 1;
1158 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1161 create_element_front(*_begin);
1164 etl::move(_begin + 1, position, _begin);
1174 create_element_back(*(
_end - 1));
1177 etl::move_backward(position,
_end - 2,
_end - 1);
1185 ::new (p) T(value1);
1195 template <
typename T1,
typename T2>
1204 if (insert_position ==
begin())
1209 ETL_INCREMENT_DEBUG_COUNT
1212 else if (insert_position ==
end())
1217 ETL_INCREMENT_DEBUG_COUNT
1218 position =
_end - 1;
1223 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1226 create_element_front(*_begin);
1229 etl::move(_begin + 1, position, _begin);
1239 create_element_back(*(
_end - 1));
1242 etl::move_backward(position,
_end - 2,
_end - 1);
1250 ::new (p) T(value1, value2);
1260 template <
typename T1,
typename T2,
typename T3>
1269 if (insert_position ==
begin())
1274 ETL_INCREMENT_DEBUG_COUNT
1277 else if (insert_position ==
end())
1282 ETL_INCREMENT_DEBUG_COUNT
1283 position =
_end - 1;
1288 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1291 create_element_front(*_begin);
1294 etl::move(_begin + 1, position, _begin);
1304 create_element_back(*(
_end - 1));
1307 etl::move_backward(position,
_end - 2,
_end - 1);
1315 ::new (p) T(value1, value2, value3);
1325 template <
typename T1,
typename T2,
typename T3,
typename T4>
1334 if (insert_position ==
begin())
1339 ETL_INCREMENT_DEBUG_COUNT
1342 else if (insert_position ==
end())
1347 ETL_INCREMENT_DEBUG_COUNT
1348 position =
_end - 1;
1353 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1356 create_element_front(*_begin);
1359 etl::move(_begin + 1, position, _begin);
1369 create_element_back(*(
_end - 1));
1372 etl::move_backward(position,
_end - 2,
_end - 1);
1380 ::new (p) T(value1, value2, value3, value4);
1399 if (insert_position ==
begin())
1401 for (
size_t i = 0UL; i < n; ++i)
1403 create_element_front(value);
1408 else if (insert_position ==
end())
1410 for (
size_t i = 0UL; i < n; ++i)
1412 create_element_back(value);
1415 position =
_end - n;
1423 if (distance(_begin, insert_position) <= difference_type(
current_size / 2))
1425 size_t n_insert = n;
1426 size_t n_move = etl::distance(
begin(), position);
1427 size_t n_create_copy = etl::min(n_insert, n_move);
1428 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1429 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1430 size_t n_copy_old = n_move - n_create_copy;
1433 iterator from = _begin + n_create_copy - 1;
1437 for (
size_t i = 0UL; i < n_create_new; ++i)
1439 create_element_front(value);
1443 for (
size_t i = 0UL; i < n_create_copy; ++i)
1445 create_element_front(*from);
1450 from = position - n_copy_old;
1451 to = _begin + n_create_copy;
1452 etl::move(from, from + n_copy_old, to);
1455 to = position - n_create_copy;
1456 etl::fill_n(to, n_copy_new, value);
1458 position = _begin + n_move;
1462 size_t n_insert = n;
1463 size_t n_move = etl::distance(position,
end());
1464 size_t n_create_copy = etl::min(n_insert, n_move);
1465 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1466 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1467 size_t n_copy_old = n_move - n_create_copy;
1470 for (
size_t i = 0UL; i < n_create_new; ++i)
1472 create_element_back(value);
1478 for (
size_t i = 0UL; i < n_create_copy; ++i)
1480 create_element_back(*from);
1485 etl::move_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
1488 etl::fill_n(position, n_copy_new, value);
1502 template<
typename TIterator>
1508 difference_type n = etl::distance(range_begin, range_end);
1512 if (insert_position ==
begin())
1514 create_element_front(n, range_begin);
1518 else if (insert_position ==
end())
1520 for (difference_type i = 0; i < n; ++i)
1522 create_element_back(*range_begin);
1526 position =
_end - n;
1534 if (distance(_begin, insert_position) < difference_type(
current_size / 2))
1536 size_t n_insert = n;
1537 size_t n_move = etl::distance(
begin(), position);
1538 size_t n_create_copy = etl::min(n_insert, n_move);
1539 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1540 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1541 size_t n_copy_old = n_move - n_create_copy;
1548 create_element_front(n_create_new, range_begin);
1551 create_element_front(n_create_copy, _begin + n_create_new);
1554 from = position - n_copy_old;
1555 to = _begin + n_create_copy;
1556 etl::move(from, from + n_copy_old, to);
1559 to = position - n_create_copy;
1560 range_begin += n_create_new;
1561 etl::copy(range_begin, range_begin + n_copy_new, to);
1563 position = _begin + n_move;
1567 size_t n_insert = n;
1568 size_t n_move = etl::distance(position,
end());
1569 size_t n_create_copy = etl::min(n_insert, n_move);
1570 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1571 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1572 size_t n_copy_old = n_move - n_create_copy;
1575 TIterator item = range_begin + (n - n_create_new);
1576 for (
size_t i = 0UL; i < n_create_new; ++i)
1578 create_element_back(*item);
1585 for (
size_t i = 0UL; i < n_create_copy; ++i)
1587 create_element_back(*from);
1592 etl::move_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
1596 etl::copy(item, item + n_copy_new, position);
1610 iterator position(to_iterator(erase_position));
1615 if (position == _begin)
1617 destroy_element_front();
1620 else if (position ==
_end - 1)
1622 destroy_element_back();
1628 if (distance(_begin, position) < difference_type(
current_size / 2))
1630 etl::move_backward(_begin, position, position + 1);
1631 destroy_element_front();
1636 etl::move(position + 1,
_end, position);
1637 destroy_element_back();
1652 iterator position(to_iterator(range_begin));
1657 size_t length = etl::distance(range_begin, range_end);
1660 if (position == _begin)
1662 for (
size_t i = 0UL; i < length; ++i)
1664 destroy_element_front();
1670 else if (position ==
_end - length)
1672 for (
size_t i = 0UL; i < length; ++i)
1674 destroy_element_back();
1683 if (distance(_begin, position) < difference_type(
current_size / 2))
1686 etl::move_backward(_begin, position, position + length);
1688 for (
size_t i = 0UL; i < length; ++i)
1690 destroy_element_front();
1699 etl::move(position + length,
_end, position);
1701 for (
size_t i = 0UL; i < length; ++i)
1703 destroy_element_back();
1718#if defined(ETL_CHECK_PUSH_POP)
1721 create_element_back(item);
1732#if defined(ETL_CHECK_PUSH_POP)
1735 create_element_back(etl::move(item));
1739#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
1744 template <
typename ... Args>
1747#if defined(ETL_CHECK_PUSH_POP)
1751 ::new (&(*
_end)) T(etl::forward<Args>(args)...);
1754 ETL_INCREMENT_DEBUG_COUNT
1764 template <
typename T1>
1767#if defined(ETL_CHECK_PUSH_POP)
1771 ::new (&(*
_end)) T(value1);
1774 ETL_INCREMENT_DEBUG_COUNT
1782 template <
typename T1,
typename T2>
1785#if defined(ETL_CHECK_PUSH_POP)
1789 ::new (&(*
_end)) T(value1, value2);
1792 ETL_INCREMENT_DEBUG_COUNT
1800 template <
typename T1,
typename T2,
typename T3>
1801 reference
emplace_back(
const T1& value1,
const T2& value2,
const T3& value3)
1803#if defined(ETL_CHECK_PUSH_POP)
1807 ::new (&(*
_end)) T(value1, value2, value3);
1810 ETL_INCREMENT_DEBUG_COUNT
1818 template <
typename T1,
typename T2,
typename T3,
typename T4>
1819 reference
emplace_back(
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
1821#if defined(ETL_CHECK_PUSH_POP)
1825 ::new (&(*
_end)) T(value1, value2, value3, value4);
1828 ETL_INCREMENT_DEBUG_COUNT
1838#if defined(ETL_CHECK_PUSH_POP)
1841 destroy_element_back();
1851#if defined(ETL_CHECK_PUSH_POP)
1854 create_element_front(item);
1865#if defined(ETL_CHECK_PUSH_POP)
1868 create_element_front(etl::move(item));
1872#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
1877 template <
typename ... Args>
1880#if defined(ETL_CHECK_PUSH_POP)
1885 ::new (&(*_begin)) T(etl::forward<Args>(args)...);
1887 ETL_INCREMENT_DEBUG_COUNT
1897 template <
typename T1>
1900#if defined(ETL_CHECK_PUSH_POP)
1905 ::new (&(*_begin)) T(value1);
1907 ETL_INCREMENT_DEBUG_COUNT
1915 template <
typename T1,
typename T2>
1918#if defined(ETL_CHECK_PUSH_POP)
1923 ::new (&(*_begin)) T(value1, value2);
1925 ETL_INCREMENT_DEBUG_COUNT
1933 template <
typename T1,
typename T2,
typename T3>
1936#if defined(ETL_CHECK_PUSH_POP)
1941 ::new (&(*_begin)) T(value1, value2, value3);
1943 ETL_INCREMENT_DEBUG_COUNT
1951 template <
typename T1,
typename T2,
typename T3,
typename T4>
1952 reference
emplace_front(
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
1954#if defined(ETL_CHECK_PUSH_POP)
1959 ::new (&(*_begin)) T(value1, value2, value3, value4);
1961 ETL_INCREMENT_DEBUG_COUNT
1971#if defined(ETL_CHECK_PUSH_POP)
1974 destroy_element_front();
1983 void resize(
size_t new_size,
const value_type& value = value_type())
1992 destroy_element_back();
2000 for (
size_t i = 0UL; i < count; ++i)
2002 create_element_back(value);
2012 return distance(rhs, lhs);
2020 return distance(rhs, lhs);
2026 friend difference_type
operator -(
const reverse_iterator& lhs,
const reverse_iterator& rhs)
2028 return distance(lhs.base(), rhs.base());
2034 friend difference_type
operator -(
const const_reverse_iterator& lhs,
const const_reverse_iterator& rhs)
2036 return distance(lhs.base(), rhs.base());
2062 while (itr != rhs.end())
2075#ifdef ETL_IDEQUE_REPAIR_ENABLE
2079 virtual void repair() = 0;
2087 ideque(pointer p_buffer_,
size_t max_size_,
size_t buffer_size_)
2101 ETL_RESET_DEBUG_COUNT
2107 destroy_element_back();
2135 void create_element_front()
2138 ::new (&(*_begin)) T();
2140 ETL_INCREMENT_DEBUG_COUNT
2146 template <
typename TIterator>
2147 void create_element_front(
size_t n, TIterator from)
2156 iterator item = _begin;
2160 ::new (&(*item)) T(*from);
2164 ETL_INCREMENT_DEBUG_COUNT
2171 void create_element_back()
2173 ::new (&(*
_end)) T();
2176 ETL_INCREMENT_DEBUG_COUNT
2182 void create_element_front(const_reference value)
2185 ::new (&(*_begin)) T(value);
2187 ETL_INCREMENT_DEBUG_COUNT
2193 void create_element_back(const_reference value)
2195 ::new (&(*
_end)) T(value);
2198 ETL_INCREMENT_DEBUG_COUNT
2205 void create_element_front(rvalue_reference value)
2208 ::new (&(*_begin)) T(etl::move(value));
2210 ETL_INCREMENT_DEBUG_COUNT
2216 void create_element_back(rvalue_reference value)
2218 ::new (&(*
_end)) T(etl::move(value));
2221 ETL_INCREMENT_DEBUG_COUNT
2228 void destroy_element_front()
2232 ETL_DECREMENT_DEBUG_COUNT
2239 void destroy_element_back()
2244 ETL_DECREMENT_DEBUG_COUNT
2250 template <
typename TIterator1,
typename TIterator2>
2251 static difference_type distance(
const TIterator1& range_begin,
const TIterator2& range_end)
2253 difference_type distance1 = distance(range_begin);
2254 difference_type distance2 = distance(range_end);
2256 return distance2 - distance1;
2262 template <
typename TIterator>
2263 static difference_type distance(
const TIterator& other)
2265 const difference_type index = other.get_index();
2266 const difference_type reference_index = other.container()._begin.index;
2267 const size_t buffer_size = other.container().BUFFER_SIZE;
2269 if (index < reference_index)
2271 return buffer_size + index - reference_index;
2275 return index - reference_index;
2282 iterator to_iterator(const_iterator itr)
const
2284 return iterator(itr.index,
const_cast<ideque&
>(*
this),
p_buffer);
2293#if defined(ETL_POLYMORPHIC_DEQUE) || defined(ETL_POLYMORPHIC_CONTAINERS) || defined(ETL_IDEQUE_REPAIR_ENABLE)
2313 template <
typename T, const
size_t MAX_SIZE_>
2318 static ETL_CONSTANT
size_t MAX_SIZE = MAX_SIZE_;
2322 static ETL_CONSTANT
size_t BUFFER_SIZE = MAX_SIZE + 1;
2326 typedef T value_type;
2328 typedef const T* const_pointer;
2329 typedef T& reference;
2330 typedef const T& const_reference;
2331 typedef size_t size_type;
2332 typedef typename etl::iterator_traits<pointer>::difference_type difference_type;
2338 :
etl::
ideque<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, BUFFER_SIZE)
2355 :
etl::
ideque<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, BUFFER_SIZE)
2368 :
etl::
ideque<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, BUFFER_SIZE)
2375 while (itr != other.end())
2387 template <
typename TIterator>
2389 :
etl::
ideque<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, BUFFER_SIZE)
2391 this->
assign(begin_, end_);
2397 explicit deque(
size_t n, const_reference value = value_type())
2398 :
etl::
ideque<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, BUFFER_SIZE)
2403#if ETL_HAS_INITIALIZER_LIST
2407 deque(std::initializer_list<T> init)
2408 :
ideque<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, BUFFER_SIZE)
2410 this->
assign(init.begin(), init.end());
2437 while (itr != rhs.end())
2451#ifdef ETL_IDEQUE_REPAIR_ENABLE
2455#ifdef ETL_IDEQUE_REPAIR_ENABLE
2459#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
2472 template <
typename T, const
size_t MAX_SIZE_>
2473 ETL_CONSTANT
size_t deque<T, MAX_SIZE_>::MAX_SIZE;
2478#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
2479 template <
typename... T>
2480 deque(T...) -> deque<
typename etl::common_type_t<T...>,
sizeof...(T)>;
2486#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
2487 template <
typename T,
typename... TValues>
2488 constexpr auto make_deque(TValues&&... values) ->
etl::deque<T,
sizeof...(TValues)>
2490 return { { etl::forward<T>(values)... } };
2501 template <
typename T>
2514 template <
typename T>
2517 return !(lhs == rhs);
2527 template <
typename T>
2530 return etl::lexicographical_compare(lhs.
begin(),
2543 template <
typename T>
2546 return !(lhs > rhs);
2556 template <
typename T>
2569 template <
typename T>
2572 return !(lhs < rhs);
Const Iterator.
Definition: deque.h:473
Iterator.
Definition: deque.h:245
reference emplace_front(const T1 &value1)
Definition: deque.h:1898
reference emplace_back(const T1 &value1, const T2 &value2, const T3 &value3)
Definition: deque.h:1801
const_reverse_iterator crbegin() const
Gets a const reverse iterator to the end of the deque.
Definition: deque.h:906
void clear()
Clears the deque.
Definition: deque.h:938
iterator erase(const_iterator erase_position)
Definition: deque.h:1608
const size_type CAPACITY
The maximum number of elements in the deque.
Definition: deque.h:215
void pop_back()
Removes the oldest item from the deque.
Definition: deque.h:1836
ideque & operator=(const ideque &rhs)
Assignment operator.
Definition: deque.h:2042
const size_type BUFFER_SIZE
The number of elements in the buffer.
Definition: deque.h:216
const_reverse_iterator rbegin() const
Gets a const reverse iterator to the end of the deque.
Definition: deque.h:898
void resize(size_t new_size, const value_type &value=value_type())
Definition: deque.h:1983
iterator emplace(const_iterator insert_position, const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: deque.h:1326
iterator begin()
Gets an iterator to the beginning of the deque.
Definition: deque.h:842
reference front()
Definition: deque.h:807
reference at(size_t index)
Definition: deque.h:754
reference emplace_back(const T1 &value1, const T2 &value2)
Definition: deque.h:1783
pointer p_buffer
Iterator to the _end item in the deque.
Definition: deque.h:2128
friend difference_type operator-(const iterator &lhs, const iterator &rhs)
Definition: deque.h:2010
reference emplace_front(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: deque.h:1952
etl::enable_if<!etl::is_integral< TIterator >::value, void >::type assign(TIterator range_begin, TIterator range_end)
Assigns a range to the deque.
Definition: deque.h:719
void initialise()
Initialise the deque.
Definition: deque.h:2096
reference operator[](size_t index)
Definition: deque.h:783
~deque_base()
Destructor.
Definition: deque.h:210
iterator _end
Iterator to the _begin item in the deque.
Definition: deque.h:2127
reference emplace_front(const T1 &value1, const T2 &value2, const T3 &value3)
Definition: deque.h:1934
size_type size() const
Definition: deque.h:145
const_reference at(size_t index) const
Definition: deque.h:769
const_reverse_iterator crend() const
Gets a const reverse iterator to the beginning of the deque.
Definition: deque.h:930
iterator end()
Gets an iterator to the end of the deque.
Definition: deque.h:866
const_iterator end() const
Gets a const iterator to the end of the deque.
Definition: deque.h:874
void push_front(const_reference item)
Definition: deque.h:1849
size_type max_size() const
Definition: deque.h:172
~ideque()
Destructor.
Definition: deque.h:2300
iterator erase(const_iterator range_begin, const_iterator range_end)
Definition: deque.h:1650
iterator emplace(const_iterator insert_position, const T1 &value1)
Definition: deque.h:1131
deque(const deque &other)
Copy constructor.
Definition: deque.h:2354
iterator emplace(const_iterator insert_position, const T1 &value1, const T2 &value2)
Definition: deque.h:1196
iterator insert(const_iterator insert_position, size_type n, const value_type &value)
Definition: deque.h:1393
enable_if<!etl::is_integral< TIterator >::value, iterator >::type insert(const_iterator insert_position, TIterator range_begin, TIterator range_end)
Definition: deque.h:1504
bool full() const
Definition: deque.h:163
size_type capacity() const
Definition: deque.h:181
const_reference back() const
Definition: deque.h:834
bool empty() const
Definition: deque.h:154
void repair()
Fix the internal pointers after a low level memory copy.
Definition: deque.h:2454
const_reverse_iterator rend() const
Gets a const reverse iterator to the beginning of the deque.
Definition: deque.h:922
const_iterator cend() const
Gets a const iterator to the end of the deque.
Definition: deque.h:882
reference emplace_back(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: deque.h:1819
deque_base(size_t max_size_, size_t buffer_size_)
Constructor.
Definition: deque.h:200
reference emplace_front(const T1 &value1, const T2 &value2)
Definition: deque.h:1916
void assign(size_type n, const value_type &value)
Definition: deque.h:736
deque()
Default constructor.
Definition: deque.h:2337
reference back()
Definition: deque.h:825
iterator emplace(const_iterator insert_position, const T1 &value1, const T2 &value2, const T3 &value3)
Definition: deque.h:1261
reverse_iterator rbegin()
Gets a reverse iterator to the end of the deque.
Definition: deque.h:890
void fill(const T &value)
Fills the deque.
Definition: deque.h:946
void pop_front()
Removes the oldest item from the deque.
Definition: deque.h:1969
reference emplace_back(const T1 &value1)
Definition: deque.h:1765
void push_back(const_reference item)
Definition: deque.h:1716
const_iterator cbegin() const
Gets a const iterator to the beginning of the deque.
Definition: deque.h:858
deque(TIterator begin_, TIterator end_, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Assigns data to the deque.
Definition: deque.h:2388
~deque()
Destructor.
Definition: deque.h:2346
reverse_iterator rend()
Gets a reverse iterator to the beginning of the deque.
Definition: deque.h:914
const_reference front() const
Definition: deque.h:816
deque(size_t n, const_reference value=value_type())
Assigns data to the deque.
Definition: deque.h:2397
size_t available() const
Definition: deque.h:190
deque & operator=(const deque &rhs)
Assignment operator.
Definition: deque.h:2417
const_iterator begin() const
Gets a const iterator to the beginning of the deque.
Definition: deque.h:850
iterator insert(const_iterator insert_position, const value_type &value)
Definition: deque.h:957
void repair_buffer(pointer p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition: deque.h:2118
size_type current_size
The current number of elements in the deque.
Definition: deque.h:214
ideque(pointer p_buffer_, size_t max_size_, size_t buffer_size_)
Constructor.
Definition: deque.h:2087
bool operator>=(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2570
bool operator==(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Template deduction guides.
Definition: deque.h:2502
bool operator<(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2528
bool operator<=(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2544
bool operator>(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2557
bool operator!=(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2515
#define ETL_ASSERT(b, e)
Definition: error_handler.h:316
ETL_CONSTEXPR exception(string_type reason_, string_type, numeric_type line_)
Constructor.
Definition: exception.h:69
Definition: exception.h:47
ETL_CONSTEXPR17 T * addressof(T &t)
Definition: addressof.h:51
enable_if
Definition: type_traits_generator.h:1191
is_integral
Definition: type_traits_generator.h:1001
bitset_ext
Definition: absolute.h:38
ETL_CONSTEXPR14 etl::circular_iterator< TIterator > operator-(etl::circular_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type offset)
Definition: circular_iterator.h:672
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:684
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
void swap(etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
Template deduction guides.
Definition: array.h:621
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
ETL_CONSTEXPR14 etl::circular_iterator< TIterator > operator+(etl::circular_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type offset)
Definition: circular_iterator.h:659
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
Definition: type_traits_generator.h:2055
iterator
Definition: iterator.h:399