31 #ifndef ETL_DEQUE_INCLUDED
32 #define ETL_DEQUE_INCLUDED
51 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
52 #include <initializer_list>
76 deque_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
77 :
exception(reason_, file_name_, line_number_)
90 deque_full(string_type file_name_, numeric_type line_number_)
104 deque_empty(string_type file_name_, numeric_type line_number_)
133 :
deque_exception(ETL_ERROR_TEXT(
"deque:type", ETL_FILE
"D"), file_name_, line_number_)
146 typedef size_t size_type;
224 ETL_DECLARE_DEBUG_COUNT
232 template <
typename T>
237 typedef T value_type;
238 typedef size_t size_type;
239 typedef T& reference;
240 typedef const T& const_reference;
241 #if ETL_CPP11_SUPPORTED
242 typedef T&& rvalue_reference;
245 typedef const T* const_pointer;
246 typedef typename etl::iterator_traits<pointer>::difference_type difference_type;
253 template <
typename TIterator>
278 : index(other.index),
279 p_deque(other.p_deque),
280 p_buffer(other.p_buffer)
288 p_deque = other.p_deque;
289 p_buffer = other.p_buffer;
297 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
306 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
312 iterator& operator +=(difference_type offset)
321 operator -= (-offset);
328 iterator& operator -=(difference_type offset)
333 index = (index < 0) ? index + p_deque->
BUFFER_SIZE : index;
337 operator += (-offset);
346 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
355 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
361 reference operator *()
363 return p_buffer[index];
367 const_reference operator *()
const
369 return p_buffer[index];
373 pointer operator ->()
375 return &p_buffer[index];
379 const_pointer operator ->()
const
381 return &p_buffer[index];
403 return lhs.index == rhs.index;
409 return !(lhs == rhs);
415 const difference_type lhs_index = lhs.get_index();
416 const difference_type rhs_index = rhs.get_index();
417 const difference_type reference_index = lhs.container().
begin().get_index();
418 const size_t buffer_size = lhs.container().
max_size() + 1;
420 const difference_type lhs_distance = (lhs_index < reference_index) ? buffer_size + lhs_index - reference_index : lhs_index - reference_index;
421 const difference_type rhs_distance = (rhs_index < reference_index) ? buffer_size + rhs_index - reference_index : rhs_index - reference_index;
423 return lhs_distance < rhs_distance;
445 difference_type get_index()
const
457 pointer get_buffer()
const
467 swap(index, other.index);
473 difference_type distance(difference_type firstIndex, difference_type index_)
const
475 if (index_ < firstIndex)
481 return index_ - firstIndex;
486 iterator(difference_type index_,
ideque& the_deque, pointer p_buffer_)
488 , p_deque(&the_deque)
489 , p_buffer(p_buffer_)
493 difference_type index;
516 , p_deque(other.p_deque)
517 , p_buffer(other.p_buffer)
524 , p_deque(other.p_deque)
525 , p_buffer(other.p_buffer)
533 p_deque = other.p_deque;
534 p_buffer = other.p_buffer;
542 p_deque = other.p_deque;
543 p_buffer = other.p_buffer;
551 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
560 index = (
static_cast<size_t>(index) == p_deque->
BUFFER_SIZE - 1) ? 0 : index + 1;
575 operator -= (-offset);
587 index = (index < 0) ? static_cast<size_t>(index) + p_deque->
BUFFER_SIZE : index;
591 operator += (-offset);
600 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
609 index = (index == 0) ? p_deque->
BUFFER_SIZE - 1 : index - 1;
615 const_reference operator *()
const
617 return p_buffer[index];
621 const_pointer operator ->()
const
623 return &p_buffer[index];
647 return lhs.index == rhs.index;
653 return !(lhs == rhs);
659 const difference_type lhs_index = lhs.get_index();
660 const difference_type rhs_index = rhs.get_index();
661 const difference_type reference_index = lhs.container().
begin().get_index();
662 const size_t buffer_size = lhs.container().
max_size() + 1;
664 const difference_type lhs_distance = (lhs_index < reference_index) ? buffer_size + lhs_index - reference_index : lhs_index - reference_index;
665 const difference_type rhs_distance = (rhs_index < reference_index) ? buffer_size + rhs_index - reference_index : rhs_index - reference_index;
667 return lhs_distance < rhs_distance;
689 difference_type get_index()
const
701 pointer get_buffer()
const
715 difference_type distance(difference_type firstIndex, difference_type index_)
const
717 if (index_ < firstIndex)
723 return index_ - firstIndex;
730 , p_deque(&the_deque)
731 , p_buffer(p_buffer_)
735 difference_type index;
740 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
741 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
746 template<
typename TIterator>
748 assign(TIterator range_begin, TIterator range_end)
752 while (range_begin != range_end)
764 void assign(size_type n,
const value_type& value)
772 create_element_back(value);
782 reference
at(
size_t index)
797 const_reference
at(
size_t index)
const
920 return reverse_iterator(
end());
928 return const_reverse_iterator(
end());
936 return const_reverse_iterator(
cend());
944 return reverse_iterator(
begin());
950 const_reverse_iterator
rend()
const
952 return const_reverse_iterator(
begin());
958 const_reverse_iterator
crend()
const
960 return const_reverse_iterator(
cbegin());
983 if (insert_position ==
begin())
985 create_element_front(value);
988 else if (insert_position ==
end())
990 create_element_back(value);
996 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
999 create_element_front(*_begin);
1002 etl::move(_begin + 1, position, _begin);
1005 *--position = value;
1010 create_element_back(*(
_end - 1));
1013 etl::move_backward(position,
_end - 2,
_end - 1);
1023 #if ETL_CPP11_SUPPORTED
1030 iterator insert(const_iterator insert_position, value_type&& value)
1036 if (insert_position ==
begin())
1038 create_element_front(etl::move(value));
1041 else if (insert_position ==
end())
1043 create_element_back(etl::move(value));
1044 position =
_end - 1;
1049 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1052 create_element_front(etl::move(*_begin));
1055 etl::move(_begin + 1, position, _begin);
1058 *--position = etl::move(value);
1063 create_element_back(etl::move(*(
_end - 1)));
1066 etl::move_backward(position,
_end - 2,
_end - 1);
1069 *position = etl::move(value);
1082 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT
1083 template <
typename ... Args>
1084 iterator
emplace(const_iterator insert_position, Args && ... args)
1086 iterator position(insert_position.index, *
this,
p_buffer);
1092 if (insert_position ==
begin())
1097 ETL_INCREMENT_DEBUG_COUNT
1100 else if (insert_position ==
end())
1105 ETL_INCREMENT_DEBUG_COUNT
1106 position =
_end - 1;
1111 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1114 create_element_front(*_begin);
1117 etl::move(_begin + 1, position, _begin);
1127 create_element_back(*(
_end - 1));
1130 etl::move_backward(position,
_end - 2,
_end - 1);
1138 ::new (p) T(etl::forward<Args>(args)...);
1150 template <
typename T1>
1159 if (insert_position ==
begin())
1164 ETL_INCREMENT_DEBUG_COUNT
1167 else if (insert_position ==
end())
1172 ETL_INCREMENT_DEBUG_COUNT
1173 position =
_end - 1;
1178 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1181 create_element_front(*_begin);
1184 etl::move(_begin + 1, position, _begin);
1194 create_element_back(*(
_end - 1));
1197 etl::move_backward(position,
_end - 2,
_end - 1);
1205 ::new (p) T(value1);
1215 template <
typename T1,
typename T2>
1224 if (insert_position ==
begin())
1229 ETL_INCREMENT_DEBUG_COUNT
1232 else if (insert_position ==
end())
1237 ETL_INCREMENT_DEBUG_COUNT
1238 position =
_end - 1;
1243 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1246 create_element_front(*_begin);
1249 etl::move(_begin + 1, position, _begin);
1259 create_element_back(*(
_end - 1));
1262 etl::move_backward(position,
_end - 2,
_end - 1);
1270 ::new (p) T(value1, value2);
1280 template <
typename T1,
typename T2,
typename T3>
1289 if (insert_position ==
begin())
1294 ETL_INCREMENT_DEBUG_COUNT
1297 else if (insert_position ==
end())
1302 ETL_INCREMENT_DEBUG_COUNT
1303 position =
_end - 1;
1308 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1311 create_element_front(*_begin);
1314 etl::move(_begin + 1, position, _begin);
1324 create_element_back(*(
_end - 1));
1327 etl::move_backward(position,
_end - 2,
_end - 1);
1335 ::new (p) T(value1, value2, value3);
1345 template <
typename T1,
typename T2,
typename T3,
typename T4>
1354 if (insert_position ==
begin())
1359 ETL_INCREMENT_DEBUG_COUNT
1362 else if (insert_position ==
end())
1367 ETL_INCREMENT_DEBUG_COUNT
1368 position =
_end - 1;
1373 if (etl::distance(_begin, position) < etl::distance(position,
_end - 1))
1376 create_element_front(*_begin);
1379 etl::move(_begin + 1, position, _begin);
1389 create_element_back(*(
_end - 1));
1392 etl::move_backward(position,
_end - 2,
_end - 1);
1400 ::new (p) T(value1, value2, value3, value4);
1419 if (insert_position ==
begin())
1421 for (
size_t i = 0; i < n; ++i)
1423 create_element_front(value);
1428 else if (insert_position ==
end())
1430 for (
size_t i = 0; i < n; ++i)
1432 create_element_back(value);
1435 position =
_end - n;
1443 if (distance(_begin, insert_position) <= difference_type(
current_size / 2))
1445 size_t n_insert = n;
1446 size_t n_move = etl::distance(
begin(), position);
1447 size_t n_create_copy = etl::min(n_insert, n_move);
1448 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1449 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1450 size_t n_copy_old = n_move - n_create_copy;
1453 iterator from = _begin + n_create_copy - 1;
1457 for (
size_t i = 0; i < n_create_new; ++i)
1459 create_element_front(value);
1463 for (
size_t i = 0; i < n_create_copy; ++i)
1465 create_element_front(*from--);
1469 from = position - n_copy_old;
1470 to = _begin + n_create_copy;
1471 etl::move(from, from + n_copy_old, to);
1474 to = position - n_create_copy;
1475 etl::fill_n(to, n_copy_new, value);
1477 position = _begin + n_move;
1481 size_t n_insert = n;
1482 size_t n_move = etl::distance(position,
end());
1483 size_t n_create_copy = etl::min(n_insert, n_move);
1484 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1485 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1486 size_t n_copy_old = n_move - n_create_copy;
1489 for (
size_t i = 0; i < n_create_new; ++i)
1491 create_element_back(value);
1497 for (
size_t i = 0; i < n_create_copy; ++i)
1499 create_element_back(*from++);
1503 etl::move_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
1506 etl::fill_n(position, n_copy_new, value);
1520 template<
typename TIterator>
1526 difference_type n = etl::distance(range_begin, range_end);
1530 if (insert_position ==
begin())
1532 create_element_front(n, range_begin);
1536 else if (insert_position ==
end())
1538 for (difference_type i = 0; i < n; ++i)
1540 create_element_back(*range_begin++);
1543 position =
_end - n;
1551 if (distance(_begin, insert_position) < difference_type(
current_size / 2))
1553 size_t n_insert = n;
1554 size_t n_move = etl::distance(
begin(), position);
1555 size_t n_create_copy = etl::min(n_insert, n_move);
1556 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1557 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1558 size_t n_copy_old = n_move - n_create_copy;
1565 create_element_front(n_create_new, range_begin);
1568 create_element_front(n_create_copy, _begin + n_create_new);
1571 from = position - n_copy_old;
1572 to = _begin + n_create_copy;
1573 etl::move(from, from + n_copy_old, to);
1576 to = position - n_create_copy;
1577 range_begin += n_create_new;
1578 etl::copy(range_begin, range_begin + n_copy_new, to);
1580 position = _begin + n_move;
1584 size_t n_insert = n;
1585 size_t n_move = etl::distance(position,
end());
1586 size_t n_create_copy = etl::min(n_insert, n_move);
1587 size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
1588 size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
1589 size_t n_copy_old = n_move - n_create_copy;
1592 TIterator item = range_begin + (n - n_create_new);
1593 for (
size_t i = 0; i < n_create_new; ++i)
1595 create_element_back(*item++);
1601 for (
size_t i = 0; i < n_create_copy; ++i)
1603 create_element_back(*from++);
1607 etl::move_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
1611 etl::copy(item, item + n_copy_new, position);
1629 if (position == _begin)
1631 destroy_element_front();
1634 else if (position ==
_end - 1)
1636 destroy_element_back();
1642 if (distance(_begin, position) < difference_type(
current_size / 2))
1644 etl::move_backward(_begin, position, position + 1);
1645 destroy_element_front();
1650 etl::move(position + 1,
_end, position);
1651 destroy_element_back();
1671 size_t length = etl::distance(range_begin, range_end);
1674 if (position == _begin)
1676 for (
size_t i = 0; i < length; ++i)
1678 destroy_element_front();
1684 else if (position ==
_end - length)
1686 for (
size_t i = 0; i < length; ++i)
1688 destroy_element_back();
1697 if (distance(_begin, position) < difference_type(
current_size / 2))
1700 etl::move_backward(_begin, position, position + length);
1702 for (
size_t i = 0; i < length; ++i)
1704 destroy_element_front();
1713 etl::move(position + length,
_end, position);
1715 for (
size_t i = 0; i < length; ++i)
1717 destroy_element_back();
1732 #if defined(ETL_CHECK_PUSH_POP)
1735 create_element_back(item);
1738 #if ETL_CPP11_SUPPORTED
1746 #if defined(ETL_CHECK_PUSH_POP)
1749 create_element_back(etl::move(item));
1753 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT
1758 template <
typename ... Args>
1761 #if defined(ETL_CHECK_PUSH_POP)
1765 ::new (&(*
_end)) T(etl::forward<Args>(args)...);
1768 ETL_INCREMENT_DEBUG_COUNT
1777 template <
typename T1>
1780 #if defined(ETL_CHECK_PUSH_POP)
1784 ::new (&(*
_end)) T(value1);
1787 ETL_INCREMENT_DEBUG_COUNT
1794 template <
typename T1,
typename T2>
1797 #if defined(ETL_CHECK_PUSH_POP)
1801 ::new (&(*
_end)) T(value1, value2);
1804 ETL_INCREMENT_DEBUG_COUNT
1811 template <
typename T1,
typename T2,
typename T3>
1814 #if defined(ETL_CHECK_PUSH_POP)
1818 ::new (&(*
_end)) T(value1, value2, value3);
1821 ETL_INCREMENT_DEBUG_COUNT
1828 template <
typename T1,
typename T2,
typename T3,
typename T4>
1829 void emplace_back(
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
1831 #if defined(ETL_CHECK_PUSH_POP)
1835 ::new (&(*
_end)) T(value1, value2, value3, value4);
1838 ETL_INCREMENT_DEBUG_COUNT
1847 #if defined(ETL_CHECK_PUSH_POP)
1850 destroy_element_back();
1860 #if defined(ETL_CHECK_PUSH_POP)
1863 create_element_front(item);
1866 #if ETL_CPP11_SUPPORTED
1874 #if defined(ETL_CHECK_PUSH_POP)
1877 create_element_front(etl::move(item));
1881 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT
1886 template <
typename ... Args>
1889 #if defined(ETL_CHECK_PUSH_POP)
1894 ::new (&(*_begin)) T(etl::forward<Args>(args)...);
1896 ETL_INCREMENT_DEBUG_COUNT
1905 template <
typename T1>
1908 #if defined(ETL_CHECK_PUSH_POP)
1913 ::new (&(*_begin)) T(value1);
1915 ETL_INCREMENT_DEBUG_COUNT
1922 template <
typename T1,
typename T2>
1925 #if defined(ETL_CHECK_PUSH_POP)
1930 ::new (&(*_begin)) T(value1, value2);
1932 ETL_INCREMENT_DEBUG_COUNT
1939 template <
typename T1,
typename T2,
typename T3>
1942 #if defined(ETL_CHECK_PUSH_POP)
1947 ::new (&(*_begin)) T(value1, value2, value3);
1949 ETL_INCREMENT_DEBUG_COUNT
1956 template <
typename T1,
typename T2,
typename T3,
typename T4>
1957 void emplace_front(
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
1959 #if defined(ETL_CHECK_PUSH_POP)
1964 ::new (&(*_begin)) T(value1, value2, value3, value4);
1966 ETL_INCREMENT_DEBUG_COUNT
1975 #if defined(ETL_CHECK_PUSH_POP)
1978 destroy_element_front();
1987 void resize(
size_t new_size,
const value_type& value = value_type())
1996 destroy_element_back();
2004 for (
size_t i = 0; i < count; ++i)
2006 create_element_back(value);
2016 return distance(rhs, lhs);
2024 return distance(rhs, lhs);
2030 friend difference_type
operator -(
const reverse_iterator& lhs,
const reverse_iterator& rhs)
2032 return distance(lhs.base(), rhs.base());
2038 friend difference_type
operator -(
const const_reverse_iterator& lhs,
const const_reverse_iterator& rhs)
2040 return distance(lhs.base(), rhs.base());
2056 #if ETL_CPP11_SUPPORTED
2066 while (itr != rhs.end())
2079 #ifdef ETL_IDEQUE_REPAIR_ENABLE
2083 virtual void repair() = 0;
2091 ideque(pointer p_buffer_,
size_t max_size_,
size_t buffer_size_)
2105 ETL_RESET_DEBUG_COUNT
2111 destroy_element_back();
2139 void create_element_front()
2142 ::new (&(*_begin)) T();
2144 ETL_INCREMENT_DEBUG_COUNT
2150 template <
typename TIterator>
2151 void create_element_front(
size_t n, TIterator from)
2160 iterator item = _begin;
2164 ::new (&(*item++)) T(*from);
2167 ETL_INCREMENT_DEBUG_COUNT
2174 void create_element_back()
2176 ::new (&(*
_end)) T();
2179 ETL_INCREMENT_DEBUG_COUNT
2185 void create_element_front(const_reference value)
2188 ::new (&(*_begin)) T(value);
2190 ETL_INCREMENT_DEBUG_COUNT
2196 void create_element_back(const_reference value)
2198 ::new (&(*
_end)) T(value);
2201 ETL_INCREMENT_DEBUG_COUNT
2204 #if ETL_CPP11_SUPPORTED
2208 void create_element_front(rvalue_reference value)
2211 ::new (&(*_begin)) T(etl::move(value));
2213 ETL_INCREMENT_DEBUG_COUNT
2219 void create_element_back(rvalue_reference value)
2221 ::new (&(*
_end)) T(etl::move(value));
2224 ETL_INCREMENT_DEBUG_COUNT
2231 void destroy_element_front()
2235 ETL_DECREMENT_DEBUG_COUNT
2242 void destroy_element_back()
2247 ETL_DECREMENT_DEBUG_COUNT
2253 template <
typename TIterator1,
typename TIterator2>
2254 static difference_type distance(
const TIterator1& range_begin,
const TIterator2& range_end)
2256 difference_type distance1 = distance(range_begin);
2257 difference_type distance2 = distance(range_end);
2259 return distance2 - distance1;
2265 template <
typename TIterator>
2266 static difference_type distance(
const TIterator& other)
2268 const difference_type index = other.get_index();
2269 const difference_type reference_index = other.container()._begin.index;
2270 const size_t buffer_size = other.container().BUFFER_SIZE;
2272 if (index < reference_index)
2274 return buffer_size + index - reference_index;
2278 return index - reference_index;
2288 #if defined(ETL_POLYMORPHIC_DEQUE) || defined(ETL_POLYMORPHIC_CONTAINERS)
2308 template <
typename T, const
size_t MAX_SIZE_>
2313 static ETL_CONSTANT
size_t MAX_SIZE = MAX_SIZE_;
2317 static ETL_CONSTANT
size_t BUFFER_SIZE = MAX_SIZE + 1;
2321 typedef T value_type;
2323 typedef const T* const_pointer;
2324 typedef T& reference;
2325 typedef const T& const_reference;
2326 typedef size_t size_type;
2327 typedef typename etl::iterator_traits<pointer>::difference_type difference_type;
2358 #if ETL_CPP11_SUPPORTED
2370 while (itr != other.end())
2382 template <
typename TIterator>
2386 this->
assign(begin_, end_);
2392 explicit deque(
size_t n, const_reference value = value_type())
2398 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
2402 deque(std::initializer_list<T> init)
2405 this->
assign(init.begin(), init.end());
2422 #if ETL_CPP11_SUPPORTED
2432 while (itr != rhs.end())
2447 #ifdef ETL_ISTRING_REPAIR_ENABLE
2451 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
2467 #if ETL_CPP17_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
2468 template <
typename T,
typename... Ts>
2470 ->deque<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T>, 1U +
sizeof...(Ts)>;
2480 template <
typename T>
2493 template <
typename T>
2496 return !(lhs == rhs);
2506 template <
typename T>
2509 return etl::lexicographical_compare(lhs.
begin(),
2522 template <
typename T>
2525 return !(lhs > rhs);
2535 template <
typename T>
2548 template <
typename T>
2551 return !(lhs < rhs);
deque(TIterator begin_, TIterator end_)
Assigns data to the deque.
Definition: deque.h:2383
void emplace_front(const T1 &value1)
Definition: deque.h:1906
const_reverse_iterator crbegin() const
Gets a const reverse iterator to the end of the deque.
Definition: deque.h:934
void clear()
Clears the deque.
Definition: deque.h:966
iterator erase(const_iterator erase_position)
Definition: deque.h:1623
const size_type CAPACITY
The maximum number of elements in the deque.
Definition: deque.h:222
ideque & operator=(const ideque &rhs)
Assignment operator.
Definition: deque.h:2046
etl::enable_if< is_iterator< TIterator >::value, void >::type assign(TIterator range_begin, TIterator range_end)
Assigns a range to the deque.
Definition: deque.h:748
void pop_back()
Removes the oldest item from the deque.
Definition: deque.h:1845
const size_type BUFFER_SIZE
The number of elements in the buffer.
Definition: deque.h:223
const_reverse_iterator rbegin() const
Gets a const reverse iterator to the end of the deque.
Definition: deque.h:926
void resize(size_t new_size, const value_type &value=value_type())
Definition: deque.h:1987
iterator emplace(const_iterator insert_position, const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: deque.h:1346
iterator begin()
Gets an iterator to the beginning of the deque.
Definition: deque.h:870
reference front()
Definition: deque.h:835
reference at(size_t index)
Definition: deque.h:782
pointer p_buffer
Iterator to the _end item in the deque.
Definition: deque.h:2132
friend difference_type operator-(const iterator &lhs, const iterator &rhs)
Definition: deque.h:2014
void initialise()
Initialise the deque.
Definition: deque.h:2100
reference operator[](size_t index)
Definition: deque.h:811
~deque_base()
Destructor.
Definition: deque.h:217
iterator _end
Iterator to the _begin item in the deque.
Definition: deque.h:2131
size_type size() const
Definition: deque.h:152
const_reference at(size_t index) const
Definition: deque.h:797
const_reverse_iterator crend() const
Gets a const reverse iterator to the beginning of the deque.
Definition: deque.h:958
void emplace_back(const T1 &value1, const T2 &value2, const T3 &value3)
Definition: deque.h:1812
iterator end()
Gets an iterator to the end of the deque.
Definition: deque.h:894
const_iterator end() const
Gets a const iterator to the end of the deque.
Definition: deque.h:902
void push_front(const_reference item)
Definition: deque.h:1858
size_type max_size() const
Definition: deque.h:179
~ideque()
Destructor.
Definition: deque.h:2295
iterator erase(const_iterator range_begin, const_iterator range_end)
Definition: deque.h:1664
iterator emplace(const_iterator insert_position, const T1 &value1)
Definition: deque.h:1151
deque(const deque &other)
Copy constructor.
Definition: deque.h:2349
iterator emplace(const_iterator insert_position, const T1 &value1, const T2 &value2)
Definition: deque.h:1216
iterator insert(const_iterator insert_position, size_type n, const value_type &value)
Definition: deque.h:1413
void emplace_front(const T1 &value1, const T2 &value2)
Definition: deque.h:1923
bool full() const
Definition: deque.h:170
size_type capacity() const
Definition: deque.h:188
void emplace_front(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: deque.h:1957
const_reference back() const
Definition: deque.h:862
bool empty() const
Definition: deque.h:161
void repair()
Fix the internal pointers after a low level memory copy.
Definition: deque.h:2446
const_reverse_iterator rend() const
Gets a const reverse iterator to the beginning of the deque.
Definition: deque.h:950
const_iterator cend() const
Gets a const iterator to the end of the deque.
Definition: deque.h:910
void emplace_front(const T1 &value1, const T2 &value2, const T3 &value3)
Definition: deque.h:1940
deque_base(size_t max_size_, size_t buffer_size_)
Constructor.
Definition: deque.h:207
enable_if< is_iterator< TIterator >::value, iterator >::type insert(const_iterator insert_position, TIterator range_begin, TIterator range_end)
Definition: deque.h:1522
void assign(size_type n, const value_type &value)
Definition: deque.h:764
void emplace_back(const T1 &value1)
Definition: deque.h:1778
deque()
Default constructor.
Definition: deque.h:2332
reference back()
Definition: deque.h:853
iterator emplace(const_iterator insert_position, const T1 &value1, const T2 &value2, const T3 &value3)
Definition: deque.h:1281
reverse_iterator rbegin()
Gets a reverse iterator to the end of the deque.
Definition: deque.h:918
void pop_front()
Removes the oldest item from the deque.
Definition: deque.h:1973
void emplace_back(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: deque.h:1829
void push_back(const_reference item)
Definition: deque.h:1730
const_iterator cbegin() const
Gets a const iterator to the beginning of the deque.
Definition: deque.h:886
~deque()
Destructor.
Definition: deque.h:2341
reverse_iterator rend()
Gets a reverse iterator to the beginning of the deque.
Definition: deque.h:942
const_reference front() const
Definition: deque.h:844
deque(size_t n, const_reference value=value_type())
Assigns data to the deque.
Definition: deque.h:2392
size_t available() const
Definition: deque.h:197
const_iterator begin() const
Gets a const iterator to the beginning of the deque.
Definition: deque.h:878
iterator insert(const_iterator insert_position, const value_type &value)
Definition: deque.h:977
void repair_buffer(pointer p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition: deque.h:2122
size_type current_size
The current number of elements in the deque.
Definition: deque.h:221
void emplace_back(const T1 &value1, const T2 &value2)
Definition: deque.h:1795
ideque(pointer p_buffer_, size_t max_size_, size_t buffer_size_)
Constructor.
Definition: deque.h:2091
bool operator>=(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2549
bool operator==(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Template deduction guides.
Definition: deque.h:2481
bool operator<(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2507
bool operator<=(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2523
bool operator>(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2536
bool operator!=(const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
Definition: deque.h:2494
#define ETL_ASSERT(b, e)
Definition: error_handler.h:290
exception(string_type reason_, string_type file_, numeric_type line_)
Constructor.
Definition: exception.h:67
Definition: exception.h:47
T * addressof(T &t)
Definition: memory.h:61
enable_if
Definition: type_traits_generator.h:1228
integral_constant
Definition: type_traits_generator.h:800
is_trivially_copyable
Definition: type_traits_generator.h:1191
is_trivially_destructible
Definition: type_traits_generator.h:1171
Definition: absolute.h:37
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
etl::fixed_iterator< TIterator > & operator-(etl::fixed_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type)
Definition: fixed_iterator.h:193
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
void swap(etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
Template deduction guides.
Definition: array.h:570
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:582
etl::fixed_iterator< TIterator > & operator+(etl::fixed_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type)
Definition: fixed_iterator.h:183
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
Const Iterator.
Definition: deque.h:502
Test for an iterator.
Definition: deque.h:255
Iterator.
Definition: deque.h:264
iterator
Definition: iterator.h:422