Embedded Template Library 1.0
Loading...
Searching...
No Matches
reference_flat_set.h
Go to the documentation of this file.
1
2
3/******************************************************************************
4The MIT License(MIT)
5
6Embedded Template Library.
7https://github.com/ETLCPP/etl
8https://www.etlcpp.com
9
10Copyright(c) 2017 John Wellbelove
11
12Permission is hereby granted, free of charge, to any person obtaining a copy
13of this software and associated documentation files(the "Software"), to deal
14in the Software without restriction, including without limitation the rights
15to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16copies of the Software, and to permit persons to whom the Software is
17furnished to do so, subject to the following conditions :
18
19The above copyright notice and this permission notice shall be included in all
20copies or substantial portions of the Software.
21
22THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28SOFTWARE.
29******************************************************************************/
30
31#ifndef ETL_REFERENCE_FLAT_SET_INCLUDED
32#define ETL_REFERENCE_FLAT_SET_INCLUDED
33
34#include "platform.h"
35#include "algorithm.h"
36#include "iterator.h"
37#include "functional.h"
38#include "utility.h"
39#include "type_traits.h"
40#include "nth_type.h"
41#include "pool.h"
42#include "error_handler.h"
43#include "exception.h"
44#include "vector.h"
45#include "iterator.h"
46
48
49#include <stddef.h>
50
51namespace etl
52{
53 //***************************************************************************
56 //***************************************************************************
66
67 //***************************************************************************
70 //***************************************************************************
72 {
73 public:
74
76 : flat_set_exception(ETL_ERROR_TEXT("flat_set:full", ETL_REFERENCE_FLAT_SET_FILE_ID"A"), file_name_, line_number_)
77 {
78 }
79 };
80
81 //***************************************************************************
84 //***************************************************************************
86 {
87 public:
88
90 : flat_set_exception(ETL_ERROR_TEXT("flat_set:iterator", ETL_REFERENCE_FLAT_SET_FILE_ID"C"), file_name_, line_number_)
91 {
92 }
93 };
94
95 //***************************************************************************
99 //***************************************************************************
100 template <typename T, typename TKeyCompare = etl::less<T> >
102 {
103 public:
104
105 typedef T key_type;
106 typedef T value_type;
107 typedef TKeyCompare key_compare;
108 typedef value_type& reference;
109 typedef const value_type& const_reference;
110 typedef value_type* pointer;
111 typedef const value_type* const_pointer;
112 typedef size_t size_type;
113
114 protected:
115
117
118 public:
119
120 //*************************************************************************
121 class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
122 {
123 public:
124
125 friend class ireference_flat_set;
126 friend class const_iterator;
127
128 iterator()
129 {
130 }
131
132 iterator(typename lookup_t::iterator ilookup_)
133 : ilookup(ilookup_)
134 {
135 }
136
137 iterator(const iterator& other)
138 : ilookup(other.ilookup)
139 {
140 }
141
143 {
144 ilookup = other.ilookup;
145 return *this;
146 }
147
149 {
150 ++ilookup;
151 return *this;
152 }
153
155 {
156 iterator temp(*this);
157 ++ilookup;
158 return temp;
159 }
160
162 {
163 --ilookup;
164 return *this;
165 }
166
168 {
169 iterator temp(*this);
170 --ilookup;
171 return temp;
172 }
173
174 reference operator *() const
175 {
176 return *(*ilookup);
177 }
178
179 pointer operator &() const
180 {
181 return etl::addressof(*(*ilookup));
182 }
183
184 pointer operator ->() const
185 {
186 return etl::addressof(*(*ilookup));
187 }
188
189 friend bool operator == (const iterator& lhs, const iterator& rhs)
190 {
191 return lhs.ilookup == rhs.ilookup;
192 }
193
194 friend bool operator != (const iterator& lhs, const iterator& rhs)
195 {
196 return !(lhs == rhs);
197 }
198
199 private:
200
201 typename lookup_t::iterator ilookup;
202 };
203
204 //*************************************************************************
205 class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
206 {
207 public:
208
209 friend class ireference_flat_set;
210
212 {
213 }
214
215 const_iterator(typename lookup_t::const_iterator ilookup_)
216 : ilookup(ilookup_)
217 {
218 }
219
221 : ilookup(other.ilookup)
222 {
223 }
224
226 : ilookup(other.ilookup)
227 {
228 }
229
231 {
232 ilookup = other.ilookup;
233 return *this;
234 }
235
237 {
238 ilookup = other.ilookup;
239 return *this;
240 }
241
243 {
244 ++ilookup;
245 return *this;
246 }
247
249 {
250 const_iterator temp(*this);
251 ++ilookup;
252 return temp;
253 }
254
256 {
257 --ilookup;
258 return *this;
259 }
260
262 {
263 const_iterator temp(*this);
264 --ilookup;
265 return temp;
266 }
267
269 {
270 return *(*ilookup);
271 }
272
274 {
275 return etl::addressof(*(*ilookup));
276 }
277
279 {
280 return etl::addressof(*(*ilookup));
281 }
282
283 friend bool operator == (const const_iterator& lhs, const const_iterator& rhs)
284 {
285 return lhs.ilookup == rhs.ilookup;
286 }
287
288 friend bool operator != (const const_iterator& lhs, const const_iterator& rhs)
289 {
290 return !(lhs == rhs);
291 }
292
293 private:
294
295 typename lookup_t::const_iterator ilookup;
296 };
297
298 protected:
299
300 typedef typename etl::parameter_type<T>::type parameter_t;
301
302 public:
303
304 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
305 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
306 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
307
308 //*********************************************************************
311 //*********************************************************************
313 {
314 return iterator(lookup.begin());
315 }
316
317 //*********************************************************************
320 //*********************************************************************
322 {
323 return const_iterator(lookup.begin());
324 }
325
326 //*********************************************************************
329 //*********************************************************************
331 {
332 return iterator(lookup.end());
333 }
334
335 //*********************************************************************
338 //*********************************************************************
340 {
341 return const_iterator(lookup.end());
342 }
343
344 //*********************************************************************
347 //*********************************************************************
349 {
350 return const_iterator(lookup.cbegin());
351 }
352
353 //*********************************************************************
356 //*********************************************************************
358 {
359 return const_iterator(lookup.cend());
360 }
361
362 //*********************************************************************
365 //*********************************************************************
366 reverse_iterator rbegin()
367 {
368 return reverse_iterator(lookup.rbegin());
369 }
370
371 //*********************************************************************
374 //*********************************************************************
375 const_reverse_iterator rbegin() const
376 {
377 return const_reverse_iterator(lookup.rbegin());
378 }
379
380 //*********************************************************************
383 //*********************************************************************
384 reverse_iterator rend()
385 {
386 return reverse_iterator(lookup.rend());
387 }
388
389 //*********************************************************************
392 //*********************************************************************
393 const_reverse_iterator rend() const
394 {
395 return const_reverse_iterator(lookup.rend());
396 }
397
398 //*********************************************************************
401 //*********************************************************************
402 const_reverse_iterator crbegin() const
403 {
404 return const_reverse_iterator(lookup.crbegin());
405 }
406
407 //*********************************************************************
410 //*********************************************************************
411 const_reverse_iterator crend() const
412 {
413 return const_reverse_iterator(lookup.crend());
414 }
415
416 //*********************************************************************
422 //*********************************************************************
423 template <typename TIterator>
424 void assign(TIterator first, TIterator last)
425 {
426#if ETL_IS_DEBUG_BUILD
427 difference_type d = etl::distance(first, last);
428 ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full));
429#endif
430
431 clear();
432
433 while (first != last)
434 {
435 insert(*first);
436 ++first;
437 }
438 }
439
440 //*********************************************************************
444 //*********************************************************************
445 ETL_OR_STD::pair<iterator, bool> insert(reference value)
446 {
448
449 return insert_at(i_element, value);
450 }
451
452 //*********************************************************************
457 //*********************************************************************
458 iterator insert(const_iterator /*position*/, reference value)
459 {
460 return insert(value).first;
461 }
462
463 //*********************************************************************
469 //*********************************************************************
470 template <class TIterator>
471 void insert(TIterator first, TIterator last)
472 {
473 while (first != last)
474 {
475 insert(*first);
476 ++first;
477 }
478 }
479
480 //*********************************************************************
484 //*********************************************************************
485 size_t erase(parameter_t key)
486 {
487 iterator i_element = find(key);
488
489 if (i_element == end())
490 {
491 return 0;
492 }
493 else
494 {
495 lookup.erase(i_element.ilookup);
496 return 1;
497 }
498 }
499
500 //*********************************************************************
501#if ETL_USING_CPP11
503 size_t erase(K&& key)
504 {
506
507 if (i_element == end())
508 {
509 return 0;
510 }
511 else
512 {
513 lookup.erase(i_element.ilookup);
514 return 1;
515 }
516 }
517#endif
518
519 //*********************************************************************
522 //*********************************************************************
524 {
525 return lookup.erase(i_element.ilookup);
526 }
527
528 //*********************************************************************
531 //*********************************************************************
533 {
534 return lookup.erase(i_element.ilookup);
535 }
536
537 //*********************************************************************
543 //*********************************************************************
545 {
546 return lookup.erase(first.ilookup, last.ilookup);
547 }
548
549 //*************************************************************************
551 //*************************************************************************
552 void clear()
553 {
554 lookup.clear();
555 }
556
557 //*********************************************************************
561 //*********************************************************************
562 iterator find(parameter_t key)
563 {
564 iterator itr = etl::lower_bound(begin(), end(), key, compare);
565
566 if (itr != end())
567 {
568 if (!key_compare()(*itr, key) && !key_compare()(key, *itr))
569 {
570 return itr;
571 }
572 else
573 {
574 return end();
575 }
576 }
577
578 return end();
579 }
580
581#if ETL_USING_CPP11
582 //*********************************************************************
584 iterator find(const K& key)
585 {
586 iterator itr = etl::lower_bound(begin(), end(), key, compare);
587
588 if (itr != end())
589 {
590 if (!key_compare()(*itr, key) && !key_compare()(key, *itr))
591 {
592 return itr;
593 }
594 else
595 {
596 return end();
597 }
598 }
599
600 return end();
601 }
602#endif
603
604 //*********************************************************************
608 //*********************************************************************
609 const_iterator find(parameter_t key) const
610 {
611 const_iterator itr = etl::lower_bound(begin(), end(), key, compare);
612
613 if (itr != end())
614 {
615 if (!key_compare()(*itr, key) && !key_compare()(key, *itr))
616 {
617 return itr;
618 }
619 else
620 {
621 return end();
622 }
623 }
624
625 return end();
626 }
627
628#if ETL_USING_CPP11
629 //*********************************************************************
631 const_iterator find(const K& key) const
632 {
633 const_iterator itr = etl::lower_bound(begin(), end(), key, compare);
634
635 if (itr != end())
636 {
637 if (!key_compare()(*itr, key) && !key_compare()(key, *itr))
638 {
639 return itr;
640 }
641 else
642 {
643 return end();
644 }
645 }
646
647 return end();
648 }
649#endif
650
651 //*********************************************************************
655 //*********************************************************************
656 size_t count(parameter_t key) const
657 {
658 return (find(key) == end()) ? 0 : 1;
659 }
660
661#if ETL_USING_CPP11
662 //*********************************************************************
664 size_t count(const K& key) const
665 {
666 return (find(key) == end()) ? 0 : 1;
667 }
668#endif
669
670 //*********************************************************************
674 //*********************************************************************
675 iterator lower_bound(parameter_t key)
676 {
677 return etl::lower_bound(begin(), end(), key, compare);
678 }
679
680#if ETL_USING_CPP11
681 //*********************************************************************
683 iterator lower_bound(const K& key)
684 {
685 return etl::lower_bound(begin(), end(), key, compare);
686 }
687#endif
688
689 //*********************************************************************
693 //*********************************************************************
694 const_iterator lower_bound(parameter_t key) const
695 {
696 return etl::lower_bound(cbegin(), cend(), key, compare);
697 }
698
699#if ETL_USING_CPP11
700 //*********************************************************************
702 const_iterator lower_bound(const K& key) const
703 {
704 return etl::lower_bound(cbegin(), cend(), key, compare);
705 }
706#endif
707
708 //*********************************************************************
712 //*********************************************************************
713 iterator upper_bound(parameter_t key)
714 {
715 return etl::upper_bound(begin(), end(), key, compare);
716 }
717
718#if ETL_USING_CPP11
719 //*********************************************************************
721 iterator upper_bound(const K& key)
722 {
723 return etl::upper_bound(begin(), end(), key, compare);
724 }
725#endif
726
727 //*********************************************************************
731 //*********************************************************************
732 const_iterator upper_bound(parameter_t key) const
733 {
734 return etl::upper_bound(cbegin(), cend(), key, compare);
735 }
736
737#if ETL_USING_CPP11
738 //*********************************************************************
740 const_iterator upper_bound(const K& key) const
741 {
742 return etl::upper_bound(cbegin(), cend(), key, compare);
743 }
744#endif
745
746 //*********************************************************************
750 //*********************************************************************
751 ETL_OR_STD::pair<iterator, iterator> equal_range(parameter_t key)
752 {
753 return etl::equal_range(begin(), end(), key, compare);
754 }
755
756#if ETL_USING_CPP11
757 //*********************************************************************
759 ETL_OR_STD::pair<iterator, iterator> equal_range(const K& key)
760 {
761 return etl::equal_range(begin(), end(), key, compare);
762 }
763#endif
764
765 //*********************************************************************
769 //*********************************************************************
770 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(parameter_t key) const
771 {
772 return etl::upper_bound(cbegin(), cend(), key, compare);
773 }
774
775#if ETL_USING_CPP11
776 //*********************************************************************
778 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const K& key) const
779 {
780 return etl::upper_bound(cbegin(), cend(), key, compare);
781 }
782#endif
783
784 //*************************************************************************
786 //*************************************************************************
787 bool contains(parameter_t key) const
788 {
789 return find(key) != end();
790 }
791
792#if ETL_USING_CPP11
793 //*************************************************************************
795 bool contains(const K& k) const
796 {
797 return find(k) != end();
798 }
799#endif
800
801 //*************************************************************************
804 //*************************************************************************
806 {
807 return lookup.size();
808 }
809
810 //*************************************************************************
813 //*************************************************************************
814 bool empty() const
815 {
816 return lookup.empty();
817 }
818
819 //*************************************************************************
822 //*************************************************************************
823 bool full() const
824 {
825 return lookup.full();
826 }
827
828 //*************************************************************************
831 //*************************************************************************
833 {
834 return lookup.capacity();
835 }
836
837 //*************************************************************************
840 //*************************************************************************
842 {
843 return lookup.max_size();
844 }
845
846 //*************************************************************************
849 //*************************************************************************
850 size_t available() const
851 {
852 return lookup.available();
853 }
854
855 protected:
856
857 //*********************************************************************
859 //*********************************************************************
861 : lookup(lookup_)
862 {
863 }
864
865 //*********************************************************************
869 //*********************************************************************
870 ETL_OR_STD::pair<iterator, bool> insert_at(iterator i_element, reference value)
871 {
872 ETL_OR_STD::pair<iterator, bool> result(end(), false);
873
874 if (i_element == end())
875 {
876 // At the end.
877 ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_set_full));
878
879 lookup.push_back(&value);
880 result.first = --end();
881 result.second = true;
882 }
883 else
884 {
885 // Not at the end.
886 result.first = i_element;
887
888 // Existing element?
889 if (compare(value, *i_element) || compare(*i_element, value))
890 {
891 // A new one.
892 ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_set_full));
893 lookup.insert(i_element.ilookup, &value);
894 result.second = true;
895 }
896 }
897
898 return result;
899 }
900
901 private:
902
903 // Disable copy construction.
906
907 lookup_t& lookup;
908
910
911 //*************************************************************************
913 //*************************************************************************
914#if defined(ETL_POLYMORPHIC_REFERENCE_FLAT_SET) || defined(ETL_POLYMORPHIC_CONTAINERS)
915 public:
916 virtual ~ireference_flat_set()
917 {
918 }
919#else
920 protected:
922 {
923 }
924#endif
925 };
926
927 //***************************************************************************
930 //***************************************************************************
931 template <typename TKey, const size_t MAX_SIZE_, typename TKeyCompare = etl::less<TKey> >
932 class reference_flat_set : public ireference_flat_set<TKey, TKeyCompare>
933 {
934 public:
935
936 static ETL_CONSTANT size_t MAX_SIZE = MAX_SIZE_;
937
939
940 //*************************************************************************
942 //*************************************************************************
947
948 //*************************************************************************
950 //*************************************************************************
956
957 //*************************************************************************
962 //*************************************************************************
963 template <typename TIterator>
969
970 //*************************************************************************
972 //*************************************************************************
977
978 private:
979
980 // The vector that stores pointers to the nodes.
982 };
983
984 template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
985 ETL_CONSTANT size_t reference_flat_set<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
986
987 //*************************************************************************
989 //*************************************************************************
990#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
991 template <typename... T>
992 reference_flat_set(T...) -> reference_flat_set<etl::nth_type_t<0, T...>, sizeof...(T)>;
993#endif
994
995 //*************************************************************************
997 //*************************************************************************
998#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
999 template <typename TKey, typename TKeyCompare = etl::less<TKey>, typename... T>
1000 constexpr auto make_reference_flat_set(T&&... keys) -> etl::reference_flat_set<TKey, sizeof...(T), TKeyCompare>
1001 {
1002 return { etl::forward<T>(keys)... };
1003 }
1004#endif
1005
1006 //***************************************************************************
1012 //***************************************************************************
1013 template <typename T, typename TKeyCompare>
1015 {
1016 return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
1017 }
1018
1019 //***************************************************************************
1025 //***************************************************************************
1026 template <typename T, typename TKeyCompare>
1031}
1032
1033#endif
Definition reference_flat_set.h:58
Definition reference_flat_set.h:72
Definition reference_flat_set.h:86
Definition reference_flat_set.h:206
Definition reference_flat_set.h:122
Definition reference_flat_set.h:102
const_iterator lower_bound(parameter_t key) const
Definition reference_flat_set.h:694
~ireference_flat_set()
Destructor.
Definition reference_flat_set.h:921
size_type capacity() const
Definition reference_flat_set.h:832
ETL_OR_STD::pair< iterator, bool > insert_at(iterator i_element, reference value)
Definition reference_flat_set.h:870
size_t available() const
Definition reference_flat_set.h:850
ETL_OR_STD::pair< iterator, bool > insert(reference value)
Definition reference_flat_set.h:445
const_iterator begin() const
Definition reference_flat_set.h:321
iterator upper_bound(parameter_t key)
Definition reference_flat_set.h:713
const_iterator find(parameter_t key) const
Definition reference_flat_set.h:609
iterator erase(iterator i_element)
Definition reference_flat_set.h:523
void assign(TIterator first, TIterator last)
Definition reference_flat_set.h:424
iterator erase(const_iterator first, const_iterator last)
Definition reference_flat_set.h:544
const_reverse_iterator rend() const
Definition reference_flat_set.h:393
const_reverse_iterator crbegin() const
Definition reference_flat_set.h:402
const_iterator end() const
Definition reference_flat_set.h:339
iterator begin()
Definition reference_flat_set.h:312
size_t erase(parameter_t key)
Definition reference_flat_set.h:485
bool contains(parameter_t key) const
Check if the set contains the key.
Definition reference_flat_set.h:787
iterator insert(const_iterator, reference value)
Definition reference_flat_set.h:458
iterator end()
Definition reference_flat_set.h:330
ETL_OR_STD::pair< const_iterator, const_iterator > equal_range(parameter_t key) const
Definition reference_flat_set.h:770
ETL_OR_STD::pair< iterator, iterator > equal_range(parameter_t key)
Definition reference_flat_set.h:751
const_iterator upper_bound(parameter_t key) const
Definition reference_flat_set.h:732
const_iterator cend() const
Definition reference_flat_set.h:357
const_iterator cbegin() const
Definition reference_flat_set.h:348
iterator find(parameter_t key)
Definition reference_flat_set.h:562
const_reverse_iterator rbegin() const
Definition reference_flat_set.h:375
size_type max_size() const
Definition reference_flat_set.h:841
const_reverse_iterator crend() const
Definition reference_flat_set.h:411
bool empty() const
Definition reference_flat_set.h:814
size_type size() const
Definition reference_flat_set.h:805
reverse_iterator rbegin()
Definition reference_flat_set.h:366
ireference_flat_set(lookup_t &lookup_)
Constructor.
Definition reference_flat_set.h:860
size_t count(parameter_t key) const
Definition reference_flat_set.h:656
void insert(TIterator first, TIterator last)
Definition reference_flat_set.h:471
bool full() const
Definition reference_flat_set.h:823
void clear()
Clears the reference_flat_set.
Definition reference_flat_set.h:552
iterator erase(const_iterator i_element)
Definition reference_flat_set.h:532
iterator lower_bound(parameter_t key)
Definition reference_flat_set.h:675
reverse_iterator rend()
Definition reference_flat_set.h:384
Definition reference_flat_set.h:933
reference_flat_set(TIterator first, TIterator last)
Definition reference_flat_set.h:964
reference_flat_set(const reference_flat_set &other)
Copy constructor.
Definition reference_flat_set.h:951
reference_flat_set()
Constructor.
Definition reference_flat_set.h:943
~reference_flat_set()
Destructor.
Definition reference_flat_set.h:973
ETL_CONSTEXPR14 bool operator==(const etl::expected< TValue, TError > &lhs, const etl::expected< TValue2, TError2 > &rhs)
Equivalence operators.
Definition expected.h:966
#define ETL_ASSERT(b, e)
Definition error_handler.h:316
Definition exception.h:47
ETL_CONSTEXPR17 etl::enable_if<!etl::is_same< T, etl::nullptr_t >::value, T >::type * addressof(T &t)
Definition addressof.h:52
iterator begin()
Definition vector.h:100
size_type max_size() const
Definition vector_base.h:140
void push_back(const_reference value)
Definition vector.h:435
const_reverse_iterator crbegin() const
Definition vector.h:190
reverse_iterator rend()
Definition vector.h:172
size_type capacity() const
Definition vector_base.h:131
const_iterator cend() const
Definition vector.h:145
void clear()
Clears the vector.
Definition vector.h:417
iterator end()
Definition vector.h:118
const_reverse_iterator crend() const
Definition vector.h:199
const_iterator cbegin() const
Definition vector.h:136
bool full() const
Definition vector.h:996
size_type size() const
Definition vector.h:978
iterator erase(iterator i_element)
Definition vector.h:884
bool empty() const
Definition vector.h:987
size_t available() const
Definition vector.h:1005
reverse_iterator rbegin()
Definition vector.h:154
iterator insert(const_iterator position, const_reference value)
Definition vector.h:579
bitset_ext
Definition absolute.h:38
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:654
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:642
Definition compare.h:51
iterator
Definition iterator.h:399
pair holds two objects of arbitrary type
Definition utility.h:164
T1 first
first is a copy of the first object
Definition utility.h:168
etl::conditional< etl::is_fundamental< T >::value||etl::is_pointer< T >::value, T, constT & >::type type
By default fundamental and pointer types are passed by value.
Definition parameter_type.h:48