31 #ifndef ETL_MULTIMAP_INCLUDED
32 #define ETL_MULTIMAP_INCLUDED
52 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
53 #include <initializer_list>
76 multimap_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
77 :
exception(reason_, file_name_, line_number_)
90 multimap_full(string_type file_name_, numeric_type line_number_)
202 weight((uint_least8_t) kNeither),
203 dir((uint_least8_t) kNeither)
212 weight = (uint_least8_t) kNeither;
213 dir = (uint_least8_t) kNeither;
214 parent = ETL_NULLPTR;
215 children[0] = ETL_NULLPTR;
216 children[1] = ETL_NULLPTR;
221 uint_least8_t weight;
250 Node* weight_node = critical_node->children[critical_node->dir];
254 if ((uint_least8_t) kNeither != weight_node->dir)
257 if (weight_node->weight == 1 - weight_node->dir)
259 weight_node->weight = (uint_least8_t) kNeither;
263 weight_node->weight = weight_node->dir;
267 weight_node = weight_node->children[weight_node->dir];
277 if ((uint_least8_t) kNeither == critical_node->weight)
279 critical_node->weight = critical_node->dir;
282 else if (critical_node->dir != critical_node->weight)
284 critical_node->weight = (uint_least8_t) kNeither;
291 if (critical_node->weight == critical_node->children[critical_node->dir]->dir)
300 critical_node->children[critical_node->dir]->children[1 - critical_node->dir]->dir);
322 Node* new_root = position->children[dir];
325 position->children[dir] = new_root->children[1 - dir];
327 if (position->children[dir])
329 position->children[dir]->parent = position;
333 new_root->parent = position->parent;
334 new_root->children[1 - dir] = position;
335 new_root->dir = 1 - dir;
338 position->weight = (uint_least8_t) kNeither;
340 position->parent = new_root;
343 position->weight = (uint_least8_t) kNeither;
364 Node* new_root = position->children[dir]->children[1 - dir];
366 position->children[dir]->weight = third != (uint_least8_t) kNeither && third != dir ? dir : (uint_least8_t) kNeither;
369 position->children[dir]->children[1 - dir] = new_root->children[dir];
371 if (new_root->children[dir])
373 new_root->children[dir]->parent = position->children[dir];
377 new_root->children[dir] = position->children[dir];
378 position->children[dir]->parent = new_root;
381 position->weight = third != (uint_least8_t) kNeither && third == dir ? 1 - dir : (uint_least8_t) kNeither;
384 position->children[dir] = new_root->children[1 - dir];
385 if (new_root->children[1 - dir])
387 new_root->children[1 - dir]->parent = position;
391 new_root->parent = position->parent;
392 new_root->children[1 - dir] = position;
393 new_root->dir = 1 - dir;
396 position->parent = new_root;
399 position->weight = (uint_least8_t) kNeither;
410 if (position->children[(uint_least8_t) kRight])
413 position =
find_limit_node(position->children[(uint_least8_t) kRight], kLeft);
419 Node* parent = position;
424 parent = position->parent;
426 }
while (parent && parent->children[(uint_least8_t) kRight] == position);
442 if (position->children[(uint_least8_t) kRight])
445 position =
find_limit_node(position->children[(uint_least8_t) kRight], kLeft);
451 const Node* parent = position;
456 parent = position->parent;
458 }
while (parent && parent->children[(uint_least8_t) kRight] == position);
480 if (position->children[(uint_least8_t) kLeft])
483 position =
find_limit_node(position->children[(uint_least8_t) kLeft], kRight);
489 Node* parent = position;
494 parent = position->parent;
496 }
while (parent && parent->children[(uint_least8_t) kLeft] == position);
518 if (position->children[(uint_least8_t) kLeft])
521 position =
find_limit_node(position->children[(uint_least8_t) kLeft], kRight);
527 const Node* parent = position;
532 parent = position->parent;
534 }
while (parent && parent->children[(uint_least8_t) kLeft] == position);
549 Node* limit_node = position;
550 while (limit_node && limit_node->children[dir])
552 limit_node = limit_node->children[dir];
568 node.parent = parent;
585 Node* detached = position;
593 replacement =
swap->children[1 -
swap->dir];
595 if (replacement != ETL_NULLPTR)
597 replacement->parent =
swap->parent;
601 swap->parent = detached->parent;
602 swap->children[(uint_least8_t) kLeft] = detached->children[(uint_least8_t) kLeft];
603 swap->children[(uint_least8_t) kRight] = detached->children[(uint_least8_t) kRight];
604 if (
swap->children[(uint_least8_t) kLeft])
606 swap->children[(uint_least8_t) kLeft]->parent =
swap;
608 if (
swap->children[(uint_least8_t) kRight])
610 swap->children[(uint_least8_t) kRight]->parent =
swap;
612 swap->weight = detached->weight;
618 ETL_DECLARE_DEBUG_COUNT
625 template <
typename TKey,
typename TMapped,
typename TKeyCompare = etl::less<TKey> >
630 typedef ETL_OR_STD::pair<const TKey, TMapped> value_type;
631 typedef const TKey key_type;
632 typedef TMapped mapped_type;
633 typedef TKeyCompare key_compare;
634 typedef value_type& reference;
635 typedef const value_type& const_reference;
636 #if ETL_CPP11_SUPPORTED
637 typedef value_type&& rvalue_reference;
639 typedef value_type* pointer;
640 typedef const value_type* const_pointer;
647 bool operator()(const_reference lhs, const_reference rhs)
const
649 return (kcompare(lhs.first, rhs.first));
654 key_compare kcompare;
680 return kcompare(node1.value.first, node2.value.first);
685 return kcompare(node.value.first, key);
690 return kcompare(key, node.value.first);
698 key_compare kcompare;
699 value_compare vcompare;
704 static Data_Node* data_cast(Node* p_node)
706 return static_cast<Data_Node*
>(p_node);
712 static Data_Node& data_cast(Node& node)
714 return static_cast<Data_Node&
>(node);
720 static const Data_Node* data_cast(
const Node* p_node)
722 return static_cast<const Data_Node*
>(p_node);
728 static const Data_Node& data_cast(
const Node& node)
730 return static_cast<const Data_Node&
>(node);
745 : p_multimap(ETL_NULLPTR)
746 , p_node(ETL_NULLPTR)
752 , p_node(ETL_NULLPTR)
763 : p_multimap(other.p_multimap)
764 , p_node(other.p_node)
800 p_multimap = other.p_multimap;
801 p_node = other.p_node;
805 reference operator *()
807 return imultimap::data_cast(p_node)->value;
810 const_reference operator *()
const
812 return imultimap::data_cast(p_node)->value;
817 return &(imultimap::data_cast(p_node)->value);
822 return &(imultimap::data_cast(p_node)->value);
825 pointer operator ->()
827 return &(imultimap::data_cast(p_node)->value);
830 const_pointer operator ->()
const
832 return &(imultimap::data_cast(p_node)->value);
837 return lhs.p_multimap == rhs.p_multimap && lhs.p_node == rhs.p_node;
842 return !(lhs == rhs);
865 : p_multimap(ETL_NULLPTR)
866 , p_node(ETL_NULLPTR)
872 , p_node(ETL_NULLPTR)
883 : p_multimap(other.p_multimap)
884 , p_node(other.p_node)
889 : p_multimap(other.p_multimap)
890 , p_node(other.p_node)
926 p_multimap = other.p_multimap;
927 p_node = other.p_node;
931 const_reference operator *()
const
933 return imultimap::data_cast(p_node)->value;
938 return imultimap::data_cast(p_node)->value;
941 const_pointer operator ->()
const
943 return &(imultimap::data_cast(p_node)->value);
948 return lhs.p_multimap == rhs.p_multimap && lhs.p_node == rhs.p_node;
953 return !(lhs == rhs);
965 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
967 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
968 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
1023 return reverse_iterator(
iterator(*
this));
1045 const_reverse_iterator
rend()
const
1073 template <
typename TIterator>
1095 return count_nodes(key);
1104 return ETL_OR_STD::make_pair<iterator, iterator>(
1115 return ETL_OR_STD::make_pair<const_iterator, const_iterator>(
1137 Node* node =
const_cast<Node*
>(position.p_node);
1154 const_iterator lower(*
this, find_lower_node(
root_node, key));
1155 const_iterator upper(*
this, find_upper_node(
root_node, key));
1156 while (lower != upper)
1161 (void)
erase(lower++);
1174 while (first != last)
1188 while (first != last)
1190 next =
erase(first++);
1224 Node* inserted_node = ETL_NULLPTR;
1229 Data_Node& node = allocate_data_node(value);
1232 inserted_node = insert_node(
root_node, node);
1235 return iterator(*
this, inserted_node);
1238 #if ETL_CPP11_SUPPORTED
1247 Node* inserted_node = ETL_NULLPTR;
1252 Data_Node& node = allocate_data_node(etl::move(value));
1255 inserted_node = insert_node(
root_node, node);
1258 return iterator(*
this, inserted_node);
1286 #if ETL_CPP11_SUPPORTED
1296 return insert(etl::move(value));
1305 iterator
insert(const_iterator , rvalue_reference value)
1308 return insert(etl::move(value));
1319 template <
class TIterator>
1322 while (first != last)
1386 #if ETL_CPP11_SUPPORTED
1399 while (from != rhs.end())
1401 this->
insert(etl::move(*from++));
1432 , p_node_pool(&node_pool)
1443 while (item !=
end())
1454 Data_Node& allocate_data_node(const_reference value)
1456 Data_Node& node = create_data_node();
1457 ::new (&node.value) const value_type(value);
1458 ETL_INCREMENT_DEBUG_COUNT
1462 #if ETL_CPP11_SUPPORTED
1466 Data_Node& allocate_data_node(rvalue_reference value)
1468 Data_Node& node = create_data_node();
1469 ::new (&node.value) const value_type(
etl::move(value));
1470 ETL_INCREMENT_DEBUG_COUNT
1478 Data_Node& create_data_node()
1480 Data_Node* (
etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
1481 return *(p_node_pool->*func)();
1487 void destroy_data_node(Data_Node& node)
1489 node.value.~value_type();
1490 p_node_pool->release(&node);
1491 ETL_DECREMENT_DEBUG_COUNT
1500 size_type result = 0;
1503 const Node* lower = find_lower_node(
root_node, key);
1504 const Node* upper = find_upper_node(
root_node, key);
1507 while (lower != upper)
1510 const Data_Node& data_node = imultimap::data_cast(*lower);
1531 Node* found = ETL_NULLPTR;
1535 Data_Node& data_node = imultimap::data_cast(*position);
1540 position = position->children[(uint_least8_t) kLeft];
1545 position = position->children[(uint_least8_t) kRight];
1551 position = position->children[(uint_least8_t) kLeft];
1562 const Node* find_node(
const Node* position,
key_parameter_t key)
const
1564 const Node* found = ETL_NULLPTR;
1568 const Data_Node& data_node = imultimap::data_cast(*position);
1573 position = position->children[(uint_least8_t) kLeft];
1578 position = position->children[(uint_least8_t) kRight];
1584 position = position->children[(uint_least8_t) kLeft];
1598 Node* lower_node = ETL_NULLPTR;
1602 Data_Node& data_node = imultimap::data_cast(*position);
1606 lower_node = position;
1607 if (position->children[(uint_least8_t) kLeft])
1609 position = position->children[(uint_least8_t) kLeft];
1619 position = position->children[(uint_least8_t) kRight];
1624 lower_node = position;
1625 position = position->children[(uint_least8_t) kLeft];
1639 Node* upper_node = ETL_NULLPTR;
1645 Data_Node& data_node = imultimap::data_cast(*position);
1649 position = position->children[(uint_least8_t) kRight];
1653 upper_node = position;
1655 if (!found && position->children[(uint_least8_t) kLeft])
1657 position = position->children[(uint_least8_t) kLeft];
1679 Node* insert_node(Node*& position, Data_Node& node)
1682 Node* found = position;
1688 Node* critical_parent_node = ETL_NULLPTR;
1695 if ((uint_least8_t) kNeither != found->weight)
1697 critical_node = found;
1701 Data_Node& found_data_node = imultimap::data_cast(*found);
1707 found->dir = (uint_least8_t) kLeft;
1710 else if (
node_comp(found_data_node, node))
1713 found->dir = (uint_least8_t) kRight;
1719 found->dir = (uint_least8_t) kRight;
1723 if (found->children[found->dir])
1727 if ((uint_least8_t) kNeither != found->children[found->dir]->weight)
1729 critical_parent_node = found;
1733 found = found->children[found->dir];
1738 attach_node(found, found->children[found->dir], node);
1741 found = found->children[found->dir];
1751 if (critical_parent_node == ETL_NULLPTR && critical_node ==
root_node)
1755 else if (critical_parent_node == ETL_NULLPTR && critical_node == position)
1761 if (critical_parent_node != ETL_NULLPTR)
1763 balance_node(critical_parent_node->children[critical_parent_node->dir]);
1785 void remove_node(Node* node)
1791 Data_Node& data_node = imultimap::data_cast(*node);
1806 node->parent->children[(uint_least8_t) kLeft] == node ? (uint_least8_t) kLeft : (uint_least8_t) kRight;
1809 node = node->parent;
1828 node->dir = node->children[(uint_least8_t) kLeft] ? (uint_least8_t) kLeft : (uint_least8_t) kRight;
1839 if ((node->weight == (uint_least8_t) kNeither) ||
1840 (node->weight == (1 - node->dir) &&
1841 node->children[1 - node->dir]->weight == (uint_least8_t) kNeither))
1848 node = node->children[node->dir];
1862 if (node->children[node->dir] == ETL_NULLPTR)
1872 if ((node->weight == (uint_least8_t) kNeither) ||
1873 (node->weight == (1 - node->dir) &&
1874 node->children[1 - node->dir]->weight == (uint_least8_t) kNeither))
1881 node = node->children[node->dir];
1884 Data_Node& replace_data_node = imultimap::data_cast(*node);
1887 if (
node_comp(data_node, replace_data_node))
1890 node->dir = (uint_least8_t) kLeft;
1892 else if (
node_comp(replace_data_node, data_node))
1895 node->dir = (uint_least8_t) kRight;
1900 node->dir = node->children[(uint_least8_t) kLeft] ? (uint_least8_t) kLeft : (uint_least8_t) kRight;
1909 if (balance->children[balance->dir] == ETL_NULLPTR)
1916 if (balance->weight == (uint_least8_t) kNeither)
1918 balance->weight = 1 - balance->dir;
1922 else if (balance->weight == balance->dir)
1924 balance->weight = (uint_least8_t) kNeither;
1929 int weight = balance->children[1 - balance->dir]->weight;
1931 if (weight == balance->dir)
1934 if (balance->parent == ETL_NULLPTR)
1937 balance->children[1 - balance->dir]->children[balance->dir]->weight);
1941 rotate_3node(balance->parent->children[balance->parent->dir], 1 - balance->dir,
1942 balance->children[1 - balance->dir]->children[balance->dir]->weight);
1947 else if (weight == (uint_least8_t) kNeither)
1950 if (balance->parent == ETL_NULLPTR)
1960 Node* old_parent = balance->parent;
1961 rotate_2node(balance->parent->children[balance->parent->dir], 1 - balance->dir);
1962 old_parent->children[old_parent->dir]->weight = balance->dir;
1965 balance->weight = 1 - balance->dir;
1971 if (balance->parent == ETL_NULLPTR)
1977 rotate_2node(balance->parent->children[balance->parent->dir], 1 - balance->dir);
1983 balance = balance->children[balance->dir];
1990 detach_node(found->parent->children[found->parent->dir],
1991 node->parent->children[node->parent->dir]);
2012 destroy_data_node(data_node);
2022 #if defined(ETL_POLYMORPHIC_MULTIMAP) || defined(ETL_POLYMORPHIC_CONTAINERS)
2038 template <
typename TKey,
typename TValue, const
size_t MAX_SIZE_,
typename TCompare = etl::less<TKey> >
2043 static const size_t MAX_SIZE = MAX_SIZE_;
2049 :
etl::
imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
2058 :
etl::
imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
2066 #if ETL_CPP11_SUPPORTED
2071 :
etl::
imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
2077 while (from != other.end())
2079 this->
insert(etl::move(*from++));
2091 template <
typename TIterator>
2093 :
etl::
imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
2095 this->
assign(first, last);
2098 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
2102 multimap(std::initializer_list<
typename etl::imultimap<TKey, TValue, TCompare>::value_type> init)
2103 :
etl::
imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
2105 this->
assign(init.begin(), init.end());
2131 #if ETL_CPP11_SUPPORTED
2141 while (from != rhs.end())
2143 this->
insert(etl::move(*from++));
2160 #if ETL_CPP17_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
2161 template <
typename T,
typename... Ts>
2163 ->multimap<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...),
typename T::first_type>,
2164 typename T::second_type,
2165 1U +
sizeof...(Ts)>;
2175 template <
typename TKey,
typename TMapped,
typename TKeyCompare>
2188 template <
typename TKey,
typename TMapped,
typename TKeyCompare>
2191 return !(lhs == rhs);
2201 template <
typename TKey,
typename TMapped,
typename TKeyCompare>
2204 return etl::lexicographical_compare(lhs.
begin(), lhs.
end(), rhs.
begin(), rhs.
end());
2214 template <
typename TKey,
typename TMapped,
typename TKeyCompare>
2227 template <
typename TKey,
typename TMapped,
typename TKeyCompare>
2230 return !(lhs > rhs);
2240 template <
typename TKey,
typename TMapped,
typename TKeyCompare>
2243 return !(lhs < rhs);
const_iterator
Definition: multimap.h:859
iterator.
Definition: multimap.h:738
Definition: multimap.h:644
A templated multimap implementation that uses a fixed size buffer.
Definition: multimap.h:2040
multimap(TIterator first, TIterator last)
Definition: multimap.h:2092
multimap()
Default constructor.
Definition: multimap.h:2048
~multimap()
Destructor.
Definition: multimap.h:2112
multimap(const multimap &other)
Copy constructor.
Definition: multimap.h:2057
bitset< MAXN > operator&(const bitset< MAXN > &lhs, const bitset< MAXN > &rhs)
Definition: bitset.h:1157
#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
void assign(TIterator first, TIterator last)
Definition: multimap.h:1074
void attach_node(Node *parent, Node *&position, Node &node)
Attach the provided node to the position provided.
Definition: multimap.h:562
reverse_iterator rend()
Gets the reverse end of the list.
Definition: multimap.h:1037
reverse_iterator rbegin()
Gets the reverse beginning of the list.
Definition: multimap.h:1021
imultimap & operator=(const imultimap &rhs)
Assignment operator.
Definition: multimap.h:1375
size_type size() const
Gets the size of the map.
Definition: multimap.h:137
size_type current_size
The number of the used nodes.
Definition: multimap.h:615
void next_node(const Node *&position) const
Find the next node in sequence from the node provided.
Definition: multimap.h:437
Node * find_limit_node(Node *position, const int8_t dir) const
Definition: multimap.h:546
iterator lower_bound(key_parameter_t key)
Definition: multimap.h:1334
ETL_OR_STD::pair< const_iterator, const_iterator > equal_range(key_parameter_t key) const
Definition: multimap.h:1113
const_reverse_iterator rbegin() const
Gets the reverse beginning of the list.
Definition: multimap.h:1029
const_iterator upper_bound(key_parameter_t key) const
Definition: multimap.h:1367
iterator erase(iterator first, iterator last)
Erases a range of elements.
Definition: multimap.h:1171
ETL_OR_STD::pair< iterator, iterator > equal_range(key_parameter_t key)
Definition: multimap.h:1102
multimap_base(size_type max_size_)
The constructor that is called from derived classes.
Definition: multimap.h:228
iterator insert(const_reference value)
Definition: multimap.h:1221
bool node_comp(const Data_Node &node1, const Data_Node &node2) const
How to compare node elements.
Definition: multimap.h:678
iterator erase(const_iterator first, const_iterator last)
Erases a range of elements.
Definition: multimap.h:1185
~multimap_base()
The constructor that is called from derived classes.
Definition: multimap.h:238
void prev_node(const Node *&position) const
Find the previous node in sequence from the node provided.
Definition: multimap.h:507
size_t available() const
Definition: multimap.h:179
iterator end()
Gets the end of the multimap.
Definition: multimap.h:989
void clear()
Clears the multimap.
Definition: multimap.h:1083
void rotate_2node(Node *&position, uint_least8_t dir)
Rotate two nodes at the position provided the to balance the tree.
Definition: multimap.h:308
const size_type CAPACITY
The maximum size of the map.
Definition: multimap.h:616
void detach_node(Node *&position, Node *&replacement)
Detach the node at the position provided.
Definition: multimap.h:580
const_iterator find(key_parameter_t key) const
Definition: multimap.h:1211
const_reverse_iterator rend() const
Gets the reverse end of the list.
Definition: multimap.h:1045
const_iterator end() const
Gets the end of the multimap.
Definition: multimap.h:997
key_compare key_comp() const
How to compare two key elements.
Definition: multimap.h:1412
const_iterator cend() const
Gets the end of the multimap.
Definition: multimap.h:1013
iterator insert(const_iterator, const_reference value)
Definition: multimap.h:1280
iterator upper_bound(key_parameter_t key)
Definition: multimap.h:1356
bool empty() const
Checks to see if the map is empty.
Definition: multimap.h:153
void next_node(Node *&position) const
Find the next node in sequence from the node provided.
Definition: multimap.h:405
size_type capacity() const
Definition: multimap.h:170
void prev_node(Node *&position) const
Find the previous node in sequence from the node provided.
Definition: multimap.h:469
iterator insert(iterator, const_reference value)
Definition: multimap.h:1268
Node * root_node
The node that acts as the multimap root.
Definition: multimap.h:617
size_t size_type
The type used for determining the size of map.
Definition: multimap.h:132
const_reverse_iterator crbegin() const
Gets the reverse beginning of the list.
Definition: multimap.h:1053
iterator begin()
Gets the beginning of the multimap.
Definition: multimap.h:973
void insert(TIterator first, TIterator last)
Definition: multimap.h:1320
size_type max_size() const
Gets the maximum possible size of the map.
Definition: multimap.h:145
const_iterator cbegin() const
Gets the beginning of the multimap.
Definition: multimap.h:1005
const_reverse_iterator crend() const
Gets the reverse end of the list.
Definition: multimap.h:1061
void initialise()
Initialise the multimap.
Definition: multimap.h:1439
iterator find(key_parameter_t key)
Definition: multimap.h:1201
imultimap(etl::ipool &node_pool, size_t max_size_)
Constructor.
Definition: multimap.h:1430
value_compare value_comp() const
How to compare two value elements.
Definition: multimap.h:1420
const_iterator lower_bound(key_parameter_t key) const
Definition: multimap.h:1345
void rotate_3node(Node *&position, uint_least8_t dir, uint_least8_t third)
Rotate three nodes at the position provided the to balance the tree.
Definition: multimap.h:349
etl::parameter_type< TKey >::type key_parameter_t
Defines the key value parameter type.
Definition: multimap.h:673
const_iterator begin() const
Gets the beginning of the multimap.
Definition: multimap.h:981
void erase(iterator position)
Erases the value at the specified position.
Definition: multimap.h:1123
size_type count(key_parameter_t key) const
Definition: multimap.h:1093
bool full() const
Checks to see if the map is full.
Definition: multimap.h:161
~imultimap()
Destructor.
Definition: multimap.h:2029
iterator erase(const_iterator position)
Erases the value at the specified position.
Definition: multimap.h:1132
void balance_node(Node *&critical_node)
Balance the critical node at the position provided as needed.
Definition: multimap.h:245
Definition: multimap.h:627
Definition: multimap.h:129
Definition: multimap.h:73
Definition: multimap.h:87
Definition: multimap.h:115
Definition: multimap.h:101
Definition: absolute.h:37
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:645
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:594
bool operator==(const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
Template deduction guides.
Definition: multimap.h:2176
void swap(etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
Template deduction guides.
Definition: array.h:570
bool operator!=(const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
Definition: multimap.h:2189
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:582
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:606
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:621
The data node element in the multimap.
Definition: multimap.h:663
iterator
Definition: iterator.h:422
The node element in the multimap.
Definition: multimap.h:197
Node()
Constructor.
Definition: multimap.h:201
void mark_as_leaf()
Marks the node as a leaf.
Definition: multimap.h:210
etl::conditional< etl::is_fundamental< T >::value||etl::is_pointer< T >::value, T, const T & >::type type
By default fundamental and pointer types are passed by value.
Definition: parameter_type.h:48