31 #ifndef ETL_SET_INCLUDED
32 #define ETL_SET_INCLUDED
52 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
53 #include <initializer_list>
77 set_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
91 set_full(string_type file_name_, numeric_type line_number_)
92 :
etl::set_exception(ETL_ERROR_TEXT(
"set:full", ETL_FILE
"A"), file_name_, line_number_)
106 :
etl::set_exception(ETL_ERROR_TEXT(
"set:bounds", ETL_FILE
"B"), file_name_, line_number_)
119 set_iterator(string_type file_name_, numeric_type line_number_)
120 :
etl::set_exception(ETL_ERROR_TEXT(
"set:iterator problem", ETL_FILE
"C"), file_name_, line_number_)
215 children[0] = ETL_NULLPTR;
216 children[1] = ETL_NULLPTR;
220 uint_least8_t weight;
265 Node* detached = position;
273 replacement =
swap->children[1 -
swap->dir];
276 swap->children[kLeft] = detached->children[kLeft];
277 swap->children[kRight] = detached->children[kRight];
278 swap->weight = detached->weight;
289 Node* weight_node = critical_node->children[critical_node->dir];
293 if (uint_least8_t(kNeither) != weight_node->dir)
296 if (weight_node->weight == 1 - weight_node->dir)
298 weight_node->weight = uint_least8_t(kNeither);
302 weight_node->weight = weight_node->dir;
306 weight_node = weight_node->children[weight_node->dir];
316 if (uint_least8_t(kNeither) == critical_node->weight)
318 critical_node->weight = critical_node->dir;
321 else if (critical_node->dir != critical_node->weight)
323 critical_node->weight = uint_least8_t(kNeither);
330 if (critical_node->weight == critical_node->children[critical_node->dir]->dir)
339 critical_node->children[critical_node->dir]->children[1 - critical_node->dir]->dir);
351 Node* limit_node = position;
352 while (limit_node && limit_node->children[dir])
354 limit_node = limit_node->children[dir];
368 const Node* limit_node = position;
369 while (limit_node && limit_node->children[dir])
371 limit_node = limit_node->children[dir];
395 Node* new_root = position->children[dir];
397 position->children[dir] = new_root->children[1 - dir];
399 new_root->children[1 - dir] = position;
401 position->weight = uint_least8_t(kNeither);
405 position->weight = uint_least8_t(kNeither);
426 Node* new_root = position->children[dir]->children[1 - dir];
428 position->children[dir]->weight = third != uint_least8_t(kNeither) && third != dir ? dir : uint_least8_t(kNeither);
431 position->children[dir]->children[1 - dir] =
432 new_root->children[dir];
434 new_root->children[dir] = position->children[dir];
436 position->weight = third != uint_least8_t(kNeither) && third == dir ? 1 - dir : uint_least8_t(kNeither);
439 position->children[dir] = new_root->children[1 - dir];
441 new_root->children[1 - dir] = position;
445 position->weight = uint_least8_t(kNeither);
451 ETL_DECLARE_DEBUG_COUNT
459 template <
typename TKey,
typename TCompare = etl::less<TKey> >
464 typedef TKey key_type;
465 typedef TKey value_type;
466 typedef TCompare key_compare;
467 typedef TCompare value_compare;
468 typedef value_type& reference;
469 typedef const value_type& const_reference;
470 #if ETL_CPP11_SUPPORTED
471 typedef value_type&& rvalue_reference;
473 typedef value_type* pointer;
474 typedef const value_type* const_pointer;
500 return compare(node1.value, node2.value);
505 return compare(node.value, key);
511 return compare(key, node.value);
524 static Data_Node* data_cast(Node* p_node)
526 return static_cast<Data_Node*
>(p_node);
532 static Data_Node& data_cast(Node& node)
534 return static_cast<Data_Node&
>(node);
540 static const Data_Node* data_cast(
const Node* p_node)
542 return static_cast<const Data_Node*
>(p_node);
548 static const Data_Node& data_cast(
const Node& node)
550 return static_cast<const Data_Node&
>(node);
566 , p_node(ETL_NULLPTR)
572 , p_node(ETL_NULLPTR)
584 , p_node(other.p_node)
594 p_set->next_node(p_node);
601 p_set->next_node(p_node);
607 p_set->prev_node(p_node);
614 p_set->prev_node(p_node);
621 p_node = other.p_node;
625 reference operator *()
627 return iset::data_cast(p_node)->value;
630 const_reference operator *()
const
632 return iset::data_cast(p_node)->value;
637 return &(iset::data_cast(p_node)->value);
642 return &(iset::data_cast(p_node)->value);
645 pointer operator ->()
647 return &(iset::data_cast(p_node)->value);
650 const_pointer operator ->()
const
652 return &(iset::data_cast(p_node)->value);
657 return lhs.p_set == rhs.p_set && lhs.p_node == rhs.p_node;
662 return !(lhs == rhs);
686 , p_node(ETL_NULLPTR)
692 , p_node(ETL_NULLPTR)
704 , p_node(other.p_node)
710 , p_node(other.p_node)
720 p_set->next_node(p_node);
727 p_set->next_node(p_node);
733 p_set->prev_node(p_node);
740 p_set->prev_node(p_node);
747 p_node = other.p_node;
751 const_reference operator *()
const
753 return iset::data_cast(p_node)->value;
758 return iset::data_cast(p_node)->value;
761 const_pointer operator ->()
const
763 return &(iset::data_cast(p_node)->value);
768 return lhs.p_set == rhs.p_set && lhs.p_node == rhs.p_node;
773 return !(lhs == rhs);
785 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
787 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
788 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
804 #if ETL_CPP11_SUPPORTED
815 while (from != rhs.end())
817 insert(etl::move(*from++));
878 return reverse_iterator(
iterator(*
this));
900 const_reverse_iterator
rend()
const
916 const_reverse_iterator
crend()
const
928 template <
typename TIterator>
929 void assign(TIterator first, TIterator last)
950 return find_node(
root_node, key) ? 1 : 0;
957 ETL_OR_STD::pair<iterator, iterator>
equal_range(const_reference value)
959 return ETL_OR_STD::make_pair<iterator, iterator>(
968 ETL_OR_STD::pair<const_iterator, const_iterator>
equal_range(const_reference value)
const
970 return ETL_OR_STD::make_pair<const_iterator, const_iterator>(
990 Node*& reference_node = find_node(
root_node, position.p_node);
991 iterator next(*
this, reference_node);
1005 return remove_node(
root_node, key_value) ? 1 : 0;
1014 while (first != last)
1028 while (first != last)
1030 next =
erase(first++);
1061 ETL_OR_STD::pair<iterator, bool>
insert(const_reference value)
1064 Node* inserted_node = ETL_NULLPTR;
1065 bool inserted =
false;
1070 Data_Node& node = allocate_data_node(value);
1073 inserted_node = insert_node(
root_node, node);
1074 inserted = inserted_node == &node;
1077 return ETL_OR_STD::make_pair(
iterator(*
this, inserted_node), inserted);
1080 #if ETL_CPP11_SUPPORTED
1086 ETL_OR_STD::pair<iterator, bool>
insert(rvalue_reference value)
1089 Node* inserted_node = ETL_NULLPTR;
1090 bool inserted =
false;
1095 Data_Node& node = allocate_data_node(etl::move(value));
1098 inserted_node = insert_node(
root_node, node);
1099 inserted = inserted_node == &node;
1102 return ETL_OR_STD::make_pair(
iterator(*
this, inserted_node), inserted);
1115 Node* inserted_node = ETL_NULLPTR;
1120 Data_Node& node = allocate_data_node(value);
1123 inserted_node = insert_node(
root_node, node);
1126 return iterator(*
this, inserted_node);
1129 #if ETL_CPP11_SUPPORTED
1139 Node* inserted_node = ETL_NULLPTR;
1144 Data_Node& node = allocate_data_node(etl::move(value));
1147 inserted_node = insert_node(
root_node, node);
1150 return iterator(*
this, inserted_node);
1163 Node* inserted_node = ETL_NULLPTR;
1168 Data_Node& node = allocate_data_node(value);
1171 inserted_node = insert_node(
root_node, node);
1174 return iterator(*
this, inserted_node);
1177 #if ETL_CPP11_SUPPORTED
1187 Node* inserted_node = ETL_NULLPTR;
1192 Data_Node& node = allocate_data_node(etl::move(value));
1195 inserted_node = insert_node(
root_node, node);
1198 return iterator(*
this, inserted_node);
1209 template <
class TIterator>
1212 while (first != last)
1285 , p_node_pool(&node_pool)
1296 while (item !=
end())
1307 Data_Node& allocate_data_node(const_reference value)
1309 Data_Node& node = create_data_node();
1310 ::new ((
void*)&node.value) value_type(value);
1311 ETL_INCREMENT_DEBUG_COUNT
1315 #if ETL_CPP11_SUPPORTED
1319 Data_Node& allocate_data_node(rvalue_reference value)
1321 Data_Node& node = create_data_node();
1322 ::new ((
void*)&node.value) value_type(etl::move(value));
1323 ETL_INCREMENT_DEBUG_COUNT
1331 Data_Node& create_data_node()
1333 Data_Node* (
etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
1334 return *(p_node_pool->*func)();
1340 void destroy_data_node(Data_Node& node)
1342 node.value.~value_type();
1344 ETL_DECREMENT_DEBUG_COUNT
1352 Node* found = position;
1356 Data_Node& found_data_node = iset::data_cast(*found);
1362 found = found->children[kLeft];
1364 else if (
node_comp(found_data_node, key))
1367 found = found->children[kRight];
1383 const Node* find_node(
const Node* position,
key_parameter_t key)
const
1385 const Node* found = position;
1389 const Data_Node& found_data_node = iset::data_cast(*found);
1395 found = found->children[kLeft];
1397 else if (
node_comp(found_data_node, key))
1400 found = found->children[kRight];
1416 Node*& find_node(Node*& position,
const Node* node)
1418 Node* found = position;
1421 if (found->children[kLeft] == node)
1423 return found->children[kLeft];
1425 else if (found->children[kRight] == node)
1427 return found->children[kRight];
1432 Data_Node& found_data_node = iset::data_cast(*found);
1433 const Data_Node& data_node = iset::data_cast(*node);
1436 if (
node_comp(data_node, found_data_node))
1439 found = found->children[kLeft];
1441 else if (
node_comp(found_data_node, data_node))
1444 found = found->children[kRight];
1462 Node* find_parent_node(Node* position,
const Node* node)
1465 Node* found = ETL_NULLPTR;
1468 if (position && node && position != node)
1473 if (position->children[kLeft] != node &&
1474 position->children[kRight] != node)
1477 const Data_Node& node_data_node = iset::data_cast(*node);
1478 Data_Node& position_data_node = iset::data_cast(*position);
1480 if (
node_comp(node_data_node, position_data_node))
1483 position = position->children[kLeft];
1485 else if (
node_comp(position_data_node, node_data_node))
1488 position = position->children[kRight];
1510 const Node* find_parent_node(
const Node* position,
const Node* node)
const
1513 const Node* found = ETL_NULLPTR;
1516 if (position && node && position != node)
1521 if (position->children[kLeft] != node &&
1522 position->children[kRight] != node)
1525 const Data_Node& node_data_node = iset::data_cast(*node);
1526 const Data_Node& position_data_node = iset::data_cast(*position);
1528 if (
node_comp(node_data_node, position_data_node))
1531 position = position->children[kLeft];
1533 else if (
node_comp(position_data_node, node_data_node))
1536 position = position->children[kRight];
1560 Node* lower_node = ETL_NULLPTR;
1564 Data_Node& data_node = iset::data_cast(*position);
1568 lower_node = position;
1569 if (position->children[kLeft])
1571 position = position->children[kLeft];
1581 position = position->children[kRight];
1586 lower_node = position;
1587 position = position->children[kLeft];
1601 Node* upper_node = ETL_NULLPTR;
1603 Node* node = position;
1607 Data_Node& data_node = iset::data_cast(*node);
1612 node = node->children[kLeft];
1616 node = node->children[kRight];
1618 else if (node->children[kRight])
1636 Node* insert_node(Node*& position, Data_Node& node)
1639 Node* found = position;
1645 Node* critical_parent_node = ETL_NULLPTR;
1652 if (kNeither != found->weight)
1654 critical_node = found;
1658 Data_Node& found_data_node = iset::data_cast(*found);
1667 else if (
node_comp(found_data_node, node))
1670 found->dir = kRight;
1675 found->dir = kNeither;
1678 critical_node = ETL_NULLPTR;
1681 destroy_data_node(node);
1688 if (found->children[found->dir])
1692 if (kNeither != found->children[found->dir]->weight)
1694 critical_parent_node = found;
1698 found = found->children[found->dir];
1706 found = found->children[found->dir];
1716 if (critical_parent_node == ETL_NULLPTR && critical_node ==
root_node)
1720 else if (critical_parent_node == ETL_NULLPTR && critical_node == position)
1726 if (critical_parent_node != ETL_NULLPTR)
1728 balance_node(critical_parent_node->children[critical_parent_node->dir]);
1749 void next_node(Node*&position)
1754 if (position->children[kRight])
1763 Node* parent = position;
1768 parent = find_parent_node(
root_node, position);
1770 }
while (parent && parent->children[kRight] == position);
1781 void next_node(
const Node*& position)
const
1786 if (position->children[kRight])
1795 const Node* parent = position;
1800 parent = find_parent_node(
root_node, position);
1802 }
while (parent && parent->children[kRight] == position);
1813 void prev_node(Node*&position)
1824 if (position->children[kLeft])
1833 Node* parent = position;
1838 parent = find_parent_node(
root_node, position);
1840 }
while (parent && parent->children[kLeft] == position);
1851 void prev_node(
const Node*& position)
const
1862 if (position->children[kLeft])
1871 const Node* parent = position;
1876 parent = find_parent_node(
root_node, position);
1878 }
while (parent && parent->children[kLeft] == position);
1895 Node* found_parent = ETL_NULLPTR;
1896 Node* found = ETL_NULLPTR;
1897 Node* replace_parent = ETL_NULLPTR;
1898 Node* replace = position;
1899 Node* balance_parent = ETL_NULLPTR;
1904 Data_Node& replace_data_node = iset::data_cast(*replace);
1910 replace->dir = kLeft;
1912 else if (
node_comp(replace_data_node, key))
1915 replace->dir = kRight;
1920 replace->dir = replace->children[kLeft] ? kLeft : kRight;
1923 found_parent = replace_parent;
1928 if (replace->children[replace->dir] == ETL_NULLPTR)
1938 if ((replace->weight == kNeither) ||
1939 (replace->weight == (1 - replace->dir) &&
1940 replace->children[1 - replace->dir]->weight == kNeither))
1943 balance_parent = replace_parent;
1948 replace_parent = replace;
1949 replace = replace->children[replace->dir];
1958 if (balance->children[balance->dir] == ETL_NULLPTR)
1963 if (balance->weight == kNeither)
1965 balance->weight = 1 - balance->dir;
1967 else if (balance->weight == balance->dir)
1969 balance->weight = kNeither;
1973 int weight = balance->children[1 - balance->dir]->weight;
1975 if (weight == balance->dir)
1978 if (balance_parent == ETL_NULLPTR)
1981 balance->children[1 - balance->dir]->children[balance->dir]->weight);
1985 rotate_3node(balance_parent->children[balance_parent->dir], 1 - balance->dir,
1986 balance->children[1 - balance->dir]->children[balance->dir]->weight);
1991 else if (weight == kNeither)
1994 if (balance_parent == ETL_NULLPTR)
2001 rotate_2node(balance_parent->children[balance_parent->dir], 1 - balance->dir);
2002 balance_parent->children[balance_parent->dir]->weight = balance->dir;
2005 balance->weight = 1 - balance->dir;
2011 if (balance_parent == ETL_NULLPTR)
2017 rotate_2node(balance_parent->children[balance_parent->dir], 1 - balance->dir);
2023 if (balance == found)
2027 found_parent = balance_parent->children[balance_parent->dir];
2029 found_parent->dir = found_parent->children[kLeft] == found ? kLeft : kRight;
2040 balance_parent = balance;
2041 balance = balance->children[balance->dir];
2048 detach_node(found_parent->children[found_parent->dir],
2049 replace_parent->children[replace_parent->dir]);
2067 Data_Node& found_data_node = iset::data_cast(*found);
2073 destroy_data_node(found_data_node);
2086 #if defined(ETL_POLYMORPHIC_SET) || defined(ETL_POLYMORPHIC_CONTAINERS)
2102 template <
typename TKey, const
size_t MAX_SIZE_,
typename TCompare = etl::less<TKey> >
2107 static const size_t MAX_SIZE = MAX_SIZE_;
2113 :
etl::
iset<TKey, TCompare>(node_pool, MAX_SIZE)
2122 :
etl::
iset<TKey, TCompare>(node_pool, MAX_SIZE)
2130 #if ETL_CPP11_SUPPORTED
2135 :
etl::
iset<TKey, TCompare>(node_pool, MAX_SIZE)
2141 while (from != other.end())
2143 this->
insert(etl::move(*from++));
2155 template <
typename TIterator>
2156 set(TIterator first, TIterator last)
2157 :
etl::
iset<TKey, TCompare>(node_pool, MAX_SIZE)
2159 this->
assign(first, last);
2162 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
2166 set(std::initializer_list<
typename etl::iset<TKey, TCompare>::value_type> init)
2167 :
etl::
iset<TKey, TCompare>(node_pool, MAX_SIZE)
2169 this->
assign(init.begin(), init.end());
2195 #if ETL_CPP11_SUPPORTED
2206 while (from != rhs.end())
2208 this->
insert(etl::move(*from++));
2225 #if ETL_CPP17_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
2226 template <
typename T,
typename... Ts>
2228 ->set<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T>, 1U +
sizeof...(Ts)>;
2238 template <
typename TKey,
typename TCompare>
2251 template <
typename TKey,
typename TCompare>
2254 return !(lhs == rhs);
2264 template <
typename TKey,
typename TCompare>
2267 return etl::lexicographical_compare(lhs.
begin(), lhs.
end(), rhs.
begin(), rhs.
end());
2277 template <
typename TKey,
typename TCompare>
2290 template <
typename TKey,
typename TCompare>
2293 return !(lhs > rhs);
2303 template <
typename TKey,
typename TCompare>
2306 return !(lhs < rhs);
const_iterator
Definition: set.h:679
iterator.
Definition: set.h:558
A templated set implementation that uses a fixed size buffer.
Definition: set.h:2104
set(const set &other)
Copy constructor.
Definition: set.h:2121
set()
Default constructor.
Definition: set.h:2112
set(TIterator first, TIterator last)
Definition: set.h:2156
~set()
Destructor.
Definition: set.h:2176
set & operator=(const set &rhs)
Assignment operator.
Definition: set.h:2184
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
Definition: exception.h:47
void release(const void *const p_object)
Definition: pool.h:255
size_type current_size
The number of the used nodes.
Definition: set.h:448
set_base(size_type max_size_)
The constructor that is called from derived classes.
Definition: set.h:227
~iset()
Destructor.
Definition: set.h:2093
void balance_node(Node *&critical_node)
Balance the critical node at the position provided as needed.
Definition: set.h:284
size_type count(key_parameter_t key) const
Definition: set.h:948
bool node_comp(const Data_Node &node1, const Data_Node &node2) const
How to compare node elements.
Definition: set.h:498
const_reverse_iterator crbegin() const
Gets the reverse beginning of the list.
Definition: set.h:908
ETL_OR_STD::pair< const_iterator, const_iterator > equal_range(const_reference value) const
Definition: set.h:968
size_type capacity() const
Definition: set.h:171
size_type size() const
Gets the size of the set.
Definition: set.h:138
const_reverse_iterator crend() const
Gets the reverse end of the list.
Definition: set.h:916
iterator erase(const_iterator first, const_iterator last)
Erases a range of elements.
Definition: set.h:1025
const_iterator find(key_parameter_t key_value) const
Definition: set.h:1051
iterator upper_bound(key_parameter_t key)
Definition: set.h:1246
const_iterator begin() const
Gets the beginning of the set.
Definition: set.h:836
size_type max_size() const
Gets the maximum possible size of the set.
Definition: set.h:146
void detach_node(Node *&position, Node *&replacement)
Detach the node at the position provided.
Definition: set.h:260
ETL_OR_STD::pair< iterator, iterator > equal_range(const_reference value)
Definition: set.h:957
iterator end()
Gets the end of the set.
Definition: set.h:844
const_iterator cbegin() const
Gets the beginning of the set.
Definition: set.h:860
bool empty() const
Checks to see if the set is empty.
Definition: set.h:154
void insert(TIterator first, TIterator last)
Definition: set.h:1210
value_compare value_comp() const
How to compare two value elements.
Definition: set.h:1273
const_iterator end() const
Gets the end of the set.
Definition: set.h:852
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: set.h:411
void assign(TIterator first, TIterator last)
Definition: set.h:929
key_compare key_comp() const
How to compare two key elements.
Definition: set.h:1265
reverse_iterator rbegin()
Gets the reverse beginning of the list.
Definition: set.h:876
const_reverse_iterator rbegin() const
Gets the reverse beginning of the list.
Definition: set.h:884
bool full() const
Checks to see if the set is full.
Definition: set.h:162
iterator lower_bound(key_parameter_t key)
Definition: set.h:1224
reverse_iterator rend()
Gets the reverse end of the list.
Definition: set.h:892
const_iterator upper_bound(key_parameter_t key) const
Definition: set.h:1257
const_iterator lower_bound(key_parameter_t key) const
Definition: set.h:1235
void rotate_2node(Node *&position, uint_least8_t dir)
Rotate two nodes at the position provided the to balance the tree.
Definition: set.h:381
~set_base()
The constructor that is called from derived classes.
Definition: set.h:238
const Node * find_limit_node(const Node *position, const int8_t dir) const
Definition: set.h:365
iset(etl::ipool &node_pool, size_t max_size_)
Constructor.
Definition: set.h:1283
iterator insert(iterator, const_reference value)
Definition: set.h:1112
size_t size_type
The type used for determining the size of set.
Definition: set.h:133
iterator begin()
Gets the beginning of the set.
Definition: set.h:828
void initialise()
Initialise the set.
Definition: set.h:1292
void attach_node(Node *&position, Node &node)
Attach the provided node to the position provided.
Definition: set.h:245
size_t available() const
Definition: set.h:180
void clear()
Clears the set.
Definition: set.h:938
iterator erase(const_iterator position)
Erases the value at the specified position.
Definition: set.h:987
iterator find(key_parameter_t key_value)
Definition: set.h:1041
iset & operator=(const iset &rhs)
Assignment operator.
Definition: set.h:793
iterator insert(const_iterator, const_reference value)
Definition: set.h:1160
iterator erase(iterator first, iterator last)
Erases a range of elements.
Definition: set.h:1011
const_reverse_iterator rend() const
Gets the reverse end of the list.
Definition: set.h:900
Node * root_node
The node that acts as the set root.
Definition: set.h:450
ETL_OR_STD::pair< iterator, bool > insert(const_reference value)
Definition: set.h:1061
const_iterator cend() const
Gets the end of the set.
Definition: set.h:868
void erase(iterator position)
Erases the value at the specified position.
Definition: set.h:978
const size_type CAPACITY
The maximum size of the set.
Definition: set.h:449
Node * find_limit_node(Node *position, const int8_t dir) const
Definition: set.h:348
etl::parameter_type< TKey >::type key_parameter_t
Defines the key value parameter type.
Definition: set.h:493
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
void swap(etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
Template deduction guides.
Definition: array.h:570
bool operator==(const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
Template deduction guides.
Definition: set.h:2239
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:582
bool operator!=(const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
Definition: set.h:2252
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 set.
Definition: set.h:483
iterator
Definition: iterator.h:422
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
The node element in the set.
Definition: set.h:198
Node()
Constructor.
Definition: set.h:202
void mark_as_leaf()
Marks the node as a leaf.
Definition: set.h:211