Embedded Template Library 1.0
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 //***************************************************************************
58 {
59 public:
60
61 flat_set_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
62 : exception(reason_, file_name_, line_number_)
63 {
64 }
65 };
66
67 //***************************************************************************
70 //***************************************************************************
72 {
73 public:
74
75 flat_set_full(string_type file_name_, numeric_type line_number_)
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
89 flat_set_iterator(string_type file_name_, numeric_type line_number_)
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
142 iterator& operator =(const iterator& other)
143 {
144 ilookup = other.ilookup;
145 return *this;
146 }
147
148 iterator& operator ++()
149 {
150 ++ilookup;
151 return *this;
152 }
153
154 iterator operator ++(int)
155 {
156 iterator temp(*this);
157 ++ilookup;
158 return temp;
159 }
160
161 iterator& operator --()
162 {
163 --ilookup;
164 return *this;
165 }
166
167 iterator operator --(int)
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
220 const_iterator(const typename ireference_flat_set::iterator& other)
221 : ilookup(other.ilookup)
222 {
223 }
224
225 const_iterator(const const_iterator& other)
226 : ilookup(other.ilookup)
227 {
228 }
229
230 const_iterator& operator =(const iterator& other)
231 {
232 ilookup = other.ilookup;
233 return *this;
234 }
235
236 const_iterator& operator =(const const_iterator& other)
237 {
238 ilookup = other.ilookup;
239 return *this;
240 }
241
242 const_iterator& operator ++()
243 {
244 ++ilookup;
245 return *this;
246 }
247
248 const_iterator operator ++(int)
249 {
250 const_iterator temp(*this);
251 ++ilookup;
252 return temp;
253 }
254
255 const_iterator& operator --()
256 {
257 --ilookup;
258 return *this;
259 }
260
261 const_iterator operator --(int)
262 {
263 const_iterator temp(*this);
264 --ilookup;
265 return temp;
266 }
267
268 const_reference operator *() const
269 {
270 return *(*ilookup);
271 }
272
273 const_pointer operator &() const
274 {
275 return etl::addressof(*(*ilookup));
276 }
277
278 const_pointer operator ->() const
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 {
447 iterator i_element = lower_bound(value);
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
502 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
503 size_t erase(K&& key)
504 {
505 iterator i_element = find(etl::forward<K>(key));
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 //*********************************************************************
583 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
630 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
663 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
682 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
701 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
720 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
739 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
758 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*********************************************************************
777 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
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 //*************************************************************************
794 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
795 bool contains(const K& k) const
796 {
797 return find(k) != end();
798 }
799#endif
800
801 //*************************************************************************
804 //*************************************************************************
805 size_type size() const
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 //*************************************************************************
832 size_type capacity() const
833 {
834 return lookup.capacity();
835 }
836
837 //*************************************************************************
840 //*************************************************************************
841 size_type max_size() const
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.
905 ireference_flat_set& operator =(const ireference_flat_set&);
906
907 lookup_t& lookup;
908
909 TKeyCompare compare;
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
938 using typename ireference_flat_set<TKey, TKeyCompare>::value_type;
939
940 //*************************************************************************
942 //*************************************************************************
944 : ireference_flat_set<TKey, TKeyCompare>(lookup)
945 {
946 }
947
948 //*************************************************************************
950 //*************************************************************************
952 : ireference_flat_set<TKey, TKeyCompare>(lookup)
953 {
955 }
956
957 //*************************************************************************
962 //*************************************************************************
963 template <typename TIterator>
964 reference_flat_set(TIterator first, TIterator last)
965 : ireference_flat_set<TKey, TKeyCompare>(lookup)
966 {
968 }
969
970 //*************************************************************************
972 //*************************************************************************
974 {
976 }
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>
1028 {
1029 return !(lhs == rhs);
1030 }
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
#define ETL_ASSERT(b, e)
Definition: error_handler.h:316
ETL_CONSTEXPR exception(string_type reason_, string_type, numeric_type line_)
Constructor.
Definition: exception.h:69
Definition: exception.h:47
ETL_CONSTEXPR17 T * addressof(T &t)
Definition: addressof.h:51
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:432
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:414
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:977
size_type size() const
Definition: vector.h:959
iterator erase(iterator i_element)
Definition: vector.h:865
bool empty() const
Definition: vector.h:968
size_t available() const
Definition: vector.h:986
reverse_iterator rbegin()
Definition: vector.h:154
iterator insert(const_iterator position, const_reference value)
Definition: vector.h:560
bitset_ext
Definition: absolute.h:38
bool operator==(const etl::ireference_flat_set< T, TKeyCompare > &lhs, const etl::ireference_flat_set< T, TKeyCompare > &rhs)
Template deduction guides.
Definition: reference_flat_set.h:1014
etl::byte operator&(etl::byte lhs, etl::byte rhs)
And.
Definition: byte.h:273
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:633
bool operator!=(const etl::ireference_flat_set< T, TKeyCompare > &lhs, const etl::ireference_flat_set< T, TKeyCompare > &rhs)
Definition: reference_flat_set.h:1027
Definition: compare.h:52
iterator
Definition: iterator.h:399
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