Embedded Template Library 1.0
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) 2015 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_FLAT_SET_INCLUDED
32#define ETL_FLAT_SET_INCLUDED
33
34#include "platform.h"
35#include "reference_flat_set.h"
36#include "pool.h"
37#include "placement_new.h"
38#include "nth_type.h"
39#include "type_traits.h"
40#include "initializer_list.h"
41
43
44//*****************************************************************************
50//*****************************************************************************
51
52namespace etl
53{
54 //***************************************************************************
58 //***************************************************************************
59 template <typename T, typename TKeyCompare = etl::less<T> >
60 class iflat_set : private etl::ireference_flat_set<T, TKeyCompare>
61 {
62 private:
63
65 typedef typename refset_t::lookup_t lookup_t;
66 typedef etl::ipool storage_t;
67
68 typedef const T& key_parameter_t;
69
70 public:
71
72 typedef T key_type;
73 typedef T value_type;
74 typedef TKeyCompare key_compare;
75 typedef value_type& reference;
76 typedef const value_type& const_reference;
77#if ETL_USING_CPP11
78 typedef value_type&& rvalue_reference;
79#endif
80 typedef value_type* pointer;
81 typedef const value_type* const_pointer;
82 typedef size_t size_type;
83
84 typedef typename refset_t::iterator iterator;
86
87 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
88 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
89 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
90
91 public:
92
93 //*********************************************************************
96 //*********************************************************************
98 {
99 return refset_t::begin();
100 }
101
102 //*********************************************************************
105 //*********************************************************************
107 {
108 return refset_t::begin();
109 }
110
111 //*********************************************************************
114 //*********************************************************************
116 {
117 return refset_t::end();
118 }
119
120 //*********************************************************************
123 //*********************************************************************
125 {
126 return refset_t::end();
127 }
128
129 //*********************************************************************
132 //*********************************************************************
134 {
135 return refset_t::cbegin();
136 }
137
138 //*********************************************************************
141 //*********************************************************************
143 {
144 return refset_t::cend();
145 }
146
147 //*********************************************************************
150 //*********************************************************************
151 reverse_iterator rbegin()
152 {
153 return refset_t::rbegin();
154 }
155
156 //*********************************************************************
159 //*********************************************************************
160 const_reverse_iterator rbegin() const
161 {
162 return refset_t::rbegin();
163 }
164
165 //*********************************************************************
168 //*********************************************************************
169 reverse_iterator rend()
170 {
171 return refset_t::rend();
172 }
173
174 //*********************************************************************
177 //*********************************************************************
178 const_reverse_iterator rend() const
179 {
180 return refset_t::rend();
181 }
182
183 //*********************************************************************
186 //*********************************************************************
187 const_reverse_iterator crbegin() const
188 {
189 return refset_t::crbegin();
190 }
191
192 //*********************************************************************
195 //*********************************************************************
196 const_reverse_iterator crend() const
197 {
198 return refset_t::crend();
199 }
200
201 //*********************************************************************
207 //*********************************************************************
208 template <typename TIterator>
209 void assign(TIterator first, TIterator last)
210 {
211#if ETL_IS_DEBUG_BUILD
212 difference_type d = etl::distance(first, last);
213 ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full));
214#endif
215
216 clear();
217
218 while (first != last)
219 {
220 insert(*first);
221 ++first;
222 }
223 }
224
225 //*********************************************************************
229 //*********************************************************************
230 ETL_OR_STD::pair<iterator, bool> insert(const_reference value)
231 {
232 iterator i_element = lower_bound(value);
233
234 ETL_OR_STD::pair<iterator, bool> result(i_element, false);
235
236 // Doesn't already exist?
237 if ((i_element == end()) || compare(value, *i_element))
238 {
240
241 value_type* pvalue = storage.allocate<value_type>();
242 ::new (pvalue) value_type(value);
243 ETL_INCREMENT_DEBUG_COUNT
244 result = refset_t::insert_at(i_element, *pvalue);
245 }
246
247 return result;
248 }
249
250#if ETL_USING_CPP11
251 //*********************************************************************
255 //*********************************************************************
256 ETL_OR_STD::pair<iterator, bool> insert(rvalue_reference value)
257 {
258 iterator i_element = lower_bound(value);
259
260 ETL_OR_STD::pair<iterator, bool> result(i_element, false);
261
262 // Doesn't already exist?
263 if ((i_element == end()) || compare(value, *i_element))
264 {
266
267 value_type* pvalue = storage.allocate<value_type>();
268 ::new (pvalue) value_type(etl::move(value));
269 ETL_INCREMENT_DEBUG_COUNT
270 result = refset_t::insert_at(i_element, *pvalue);
271 }
272
273 return result;
274 }
275#endif
276
277 //*********************************************************************
282 //*********************************************************************
283 iterator insert(const_iterator /*position*/, const_reference value)
284 {
285 return insert(value).first;
286 }
287
288#if ETL_USING_CPP11
289 //*********************************************************************
294 //*********************************************************************
295 iterator insert(const_iterator /*position*/, rvalue_reference value)
296 {
297 return insert(etl::move(value)).first;
298 }
299#endif
300
301 //*********************************************************************
307 //*********************************************************************
308 template <class TIterator>
309 void insert(TIterator first, TIterator last)
310 {
311 while (first != last)
312 {
313 insert(*first);
314 ++first;
315 }
316 }
317
318 //*************************************************************************
320 //*************************************************************************
321 ETL_OR_STD::pair<iterator, bool> emplace(const_reference value)
322 {
323 return insert(value);
324 }
325
326 //*************************************************************************
328 //*************************************************************************
329#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
330 template <typename ... Args>
331 ETL_OR_STD::pair<iterator, bool> emplace(Args && ... args)
332 {
333 ETL_ASSERT(!full(), ETL_ERROR(flat_set_full));
334
335 ETL_OR_STD::pair<iterator, bool> result;
336
337 // Create it.
338 value_type* pvalue = storage.allocate<value_type>();
339 ::new (pvalue) value_type(etl::forward<Args>(args)...);
340
341 iterator i_element = lower_bound(*pvalue);
342
343 // Doesn't already exist?
344 if ((i_element == end()) || compare(*pvalue, *i_element))
345 {
346 ETL_INCREMENT_DEBUG_COUNT
347 result = refset_t::insert_at(i_element, *pvalue);
348 }
349 else
350 {
351 // Destroy it.
352 pvalue->~value_type();
353 storage.release(pvalue);
354 result = ETL_OR_STD::pair<iterator, bool>(end(), false);
355 }
356
357 return result;
358 }
359#else
360 //*************************************************************************
362 //*************************************************************************
363 template <typename T1>
364 ETL_OR_STD::pair<iterator, bool> emplace(const T1& value1)
365 {
366 ETL_ASSERT(!full(), ETL_ERROR(flat_set_full));
367
368 ETL_OR_STD::pair<iterator, bool> result;
369
370 // Create it.
371 value_type* pvalue = storage.allocate<value_type>();
372 ::new (pvalue) value_type(value1);
373
374 iterator i_element = lower_bound(*pvalue);
375
376 // Doesn't already exist?
377 if ((i_element == end()) || compare(*pvalue, *i_element))
378 {
379 ETL_INCREMENT_DEBUG_COUNT
380 result = refset_t::insert_at(i_element, *pvalue);
381 }
382 else
383 {
384 // Destroy it.
385 pvalue->~value_type();
386 storage.release(pvalue);
387 result = ETL_OR_STD::pair<iterator, bool>(end(), false);
388 }
389
390 return result;
391 }
392
393 //*************************************************************************
395 //*************************************************************************
396 template <typename T1, typename T2>
397 ETL_OR_STD::pair<iterator, bool> emplace(const T1& value1, const T2& value2)
398 {
399 ETL_ASSERT(!full(), ETL_ERROR(flat_set_full));
400
401 ETL_OR_STD::pair<iterator, bool> result;
402
403 // Create it.
404 value_type* pvalue = storage.allocate<value_type>();
405 ::new (pvalue) value_type(value1, value2);
406
407 iterator i_element = lower_bound(*pvalue);
408
409 // Doesn't already exist?
410 if ((i_element == end()) || compare(*pvalue, *i_element))
411 {
412 ETL_INCREMENT_DEBUG_COUNT
413 result = refset_t::insert_at(i_element, *pvalue);
414 }
415 else
416 {
417 // Destroy it.
418 pvalue->~value_type();
419 storage.release(pvalue);
420 result = ETL_OR_STD::pair<iterator, bool>(end(), false);
421 }
422
423 return result;
424 }
425
426 //*************************************************************************
428 //*************************************************************************
429 template <typename T1, typename T2, typename T3>
430 ETL_OR_STD::pair<iterator, bool> emplace(const T1& value1, const T2& value2, const T3& value3)
431 {
432 ETL_ASSERT(!full(), ETL_ERROR(flat_set_full));
433
434 ETL_OR_STD::pair<iterator, bool> result;
435
436 // Create it.
437 value_type* pvalue = storage.allocate<value_type>();
438 ::new (pvalue) value_type(value1, value2, value3);
439
440 iterator i_element = lower_bound(*pvalue);
441
442 // Doesn't already exist?
443 if ((i_element == end()) || compare(*pvalue, *i_element))
444 {
445 ETL_INCREMENT_DEBUG_COUNT
446 result = refset_t::insert_at(i_element, *pvalue);
447 }
448 else
449 {
450 // Destroy it.
451 pvalue->~value_type();
452 storage.release(pvalue);
453 result = ETL_OR_STD::pair<iterator, bool>(end(), false);
454 }
455
456 return result;
457 }
458
459 //*************************************************************************
461 //*************************************************************************
462 template <typename T1, typename T2, typename T3, typename T4>
463 ETL_OR_STD::pair<iterator, bool> emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
464 {
465 ETL_ASSERT(!full(), ETL_ERROR(flat_set_full));
466
467 ETL_OR_STD::pair<iterator, bool> result;
468
469 // Create it.
470 value_type* pvalue = storage.allocate<value_type>();
471 ::new (pvalue) value_type(value1, value2, value3, value4);
472
473 iterator i_element = lower_bound(*pvalue);
474
475 // Doesn't already exist?
476 if ((i_element == end()) || compare(*pvalue, *i_element))
477 {
478 ETL_INCREMENT_DEBUG_COUNT
479 result = refset_t::insert_at(i_element, *pvalue);
480 }
481 else
482 {
483 // Destroy it.
484 pvalue->~value_type();
485 storage.release(pvalue);
486 result = ETL_OR_STD::pair<iterator, bool>(end(), false);
487 }
488
489 return result;
490 }
491#endif
492
493 //*********************************************************************
497 //*********************************************************************
498 size_t erase(key_parameter_t key)
499 {
500 iterator i_element = find(key);
501
502 if (i_element == end())
503 {
504 return 0;
505 }
506 else
507 {
508 etl::destroy_at(etl::addressof(*i_element));
509 storage.release(etl::addressof(*i_element));
510 refset_t::erase(i_element);
511 ETL_DECREMENT_DEBUG_COUNT
512 return 1;
513 }
514 }
515
516#if ETL_USING_CPP11
517 //*********************************************************************
518 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
519 size_t erase(K&& key)
520 {
521 iterator i_element = find(etl::forward<K>(key));
522
523 if (i_element == end())
524 {
525 return 0;
526 }
527 else
528 {
529 etl::destroy_at(etl::addressof(*i_element));
530 storage.release(etl::addressof(*i_element));
531 refset_t::erase(i_element);
532 ETL_DECREMENT_DEBUG_COUNT
533 return 1;
534 }
535 }
536#endif
537
538 //*********************************************************************
541 //*********************************************************************
543 {
544 etl::destroy_at(etl::addressof(*i_element));
545 storage.release(etl::addressof(*i_element));
546 ETL_DECREMENT_DEBUG_COUNT
547 return refset_t::erase(i_element);
548 }
549
550 //*********************************************************************
553 //*********************************************************************
555 {
556 etl::destroy_at(etl::addressof(*i_element));
557 storage.release(etl::addressof(*i_element));
558 ETL_DECREMENT_DEBUG_COUNT
559 return refset_t::erase(i_element);
560 }
561
562 //*********************************************************************
568 //*********************************************************************
570 {
571 const_iterator itr = first;
572
573 while (itr != last)
574 {
576 storage.release(etl::addressof(*itr));
577 ++itr;
578 ETL_DECREMENT_DEBUG_COUNT
579 }
580
581 return refset_t::erase(first, last);
582 }
583
584 //*************************************************************************
586 //*************************************************************************
587 void clear()
588 {
590 {
591 storage.release_all();
592 }
593 else
594 {
595 iterator itr = begin();
596
597 while (itr != end())
598 {
600 storage.release(etl::addressof(*itr));
601 ++itr;
602 ETL_DECREMENT_DEBUG_COUNT
603 }
604 }
605
606 ETL_RESET_DEBUG_COUNT
608 }
609
610 //*********************************************************************
614 //*********************************************************************
615 iterator find(key_parameter_t key)
616 {
617 return refset_t::find(key);
618 }
619
620#if ETL_USING_CPP11
621 //*********************************************************************
622 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
623 iterator find(const K& key)
624 {
625 return refset_t::find(key);
626 }
627#endif
628
629 //*********************************************************************
633 //*********************************************************************
634 const_iterator find(key_parameter_t key) const
635 {
636 return refset_t::find(key);
637 }
638
639#if ETL_USING_CPP11
640 //*********************************************************************
641 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
642 const_iterator find(const K& key) const
643 {
644 return refset_t::find(key);
645 }
646#endif
647
648 //*********************************************************************
652 //*********************************************************************
653 size_t count(key_parameter_t key) const
654 {
655 return refset_t::count(key);
656 }
657
658#if ETL_USING_CPP11
659 //*********************************************************************
660 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
661 size_t count(const K& key) const
662 {
663 return refset_t::count(key);
664 }
665#endif
666
667 //*********************************************************************
671 //*********************************************************************
672 iterator lower_bound(key_parameter_t key)
673 {
674 return refset_t::lower_bound(key);
675 }
676
677#if ETL_USING_CPP11
678 //*********************************************************************
679 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
680 iterator lower_bound(const K& key)
681 {
682 return refset_t::lower_bound(key);
683 }
684#endif
685
686 //*********************************************************************
690 //*********************************************************************
691 const_iterator lower_bound(key_parameter_t key) const
692 {
693 return refset_t::lower_bound(key);
694 }
695
696#if ETL_USING_CPP11
697 //*********************************************************************
698 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
699 const_iterator lower_bound(const K& key) const
700 {
701 return refset_t::lower_bound(key);
702 }
703#endif
704
705 //*********************************************************************
709 //*********************************************************************
710 iterator upper_bound(key_parameter_t key)
711 {
712 return refset_t::upper_bound(key);
713 }
714
715#if ETL_USING_CPP11
716 //*********************************************************************
717 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
718 iterator upper_bound(const K& key)
719 {
720 return refset_t::upper_bound(key);
721 }
722#endif
723
724 //*********************************************************************
728 //*********************************************************************
729 const_iterator upper_bound(key_parameter_t key) const
730 {
731 return refset_t::upper_bound(key);
732 }
733
734#if ETL_USING_CPP11
735 //*********************************************************************
736 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
737 const_iterator upper_bound(const K& key) const
738 {
739 return refset_t::upper_bound(key);
740 }
741#endif
742
743 //*********************************************************************
747 //*********************************************************************
748 ETL_OR_STD::pair<iterator, iterator> equal_range(key_parameter_t key)
749 {
750 return refset_t::equal_range(key);
751 }
752
753#if ETL_USING_CPP11
754 //*********************************************************************
755 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
756 ETL_OR_STD::pair<iterator, iterator> equal_range(const K& key)
757 {
758 return refset_t::equal_range(key);
759 }
760#endif
761
762 //*********************************************************************
766 //*********************************************************************
767 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(key_parameter_t key) const
768 {
769 return refset_t::upper_bound(key);
770 }
771
772#if ETL_USING_CPP11
773 //*********************************************************************
774 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
775 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const K& key) const
776 {
777 return refset_t::upper_bound(key);
778 }
779#endif
780
781 //*************************************************************************
783 //*************************************************************************
784 bool contains(key_parameter_t key) const
785 {
786 return find(key) != end();
787 }
788
789#if ETL_USING_CPP11
790 //*************************************************************************
791 template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
792 bool contains(const K& k) const
793 {
794 return find(k) != end();
795 }
796#endif
797
798 //*************************************************************************
800 //*************************************************************************
802 {
803 if (&rhs != this)
804 {
805 assign(rhs.cbegin(), rhs.cend());
806 }
807
808 return *this;
809 }
810
811#if ETL_USING_CPP11
812 //*************************************************************************
814 //*************************************************************************
816 {
817 move_container(etl::move(rhs));
818
819 return *this;
820 }
821#endif
822
823 //*************************************************************************
826 //*************************************************************************
827 size_type size() const
828 {
829 return refset_t::size();
830 }
831
832 //*************************************************************************
835 //*************************************************************************
836 bool empty() const
837 {
838 return refset_t::empty();
839 }
840
841 //*************************************************************************
844 //*************************************************************************
845 bool full() const
846 {
847 return refset_t::full();
848 }
849
850 //*************************************************************************
853 //*************************************************************************
854 size_type capacity() const
855 {
856 return refset_t::capacity();
857 }
858
859 //*************************************************************************
862 //*************************************************************************
863 size_type max_size() const
864 {
865 return refset_t::max_size();
866 }
867
868 //*************************************************************************
871 //*************************************************************************
872 size_t available() const
873 {
874 return refset_t::available();
875 }
876
877 protected:
878
879 //*********************************************************************
881 //*********************************************************************
882 iflat_set(lookup_t& lookup_, storage_t& storage_)
883 : refset_t(lookup_),
884 storage(storage_)
885 {
886 }
887
888#if ETL_USING_CPP11
889 //*************************************************************************
892 //*************************************************************************
893 void move_container(iflat_set&& rhs)
894 {
895 if (&rhs != this)
896 {
897 this->clear();
898
901
902 // Move all of the elements.
903 while (first != last)
904 {
905 typename etl::iflat_set<T, TKeyCompare>::iterator temp = first;
906 ++temp;
907
908 this->insert(etl::move(*first));
909 first = temp;
910 }
911 }
912 }
913#endif
914
915 private:
916
917 // Disable copy construction.
918 iflat_set(const iflat_set&);
919
920 storage_t& storage;
921
922 TKeyCompare compare;
923
925 ETL_DECLARE_DEBUG_COUNT
926
927 //*************************************************************************
929 //*************************************************************************
930#if defined(ETL_POLYMORPHIC_FLAT_SET) || defined(ETL_POLYMORPHIC_CONTAINERS)
931 public:
932 virtual ~iflat_set()
933 {
934 }
935#else
936 protected:
938 {
939 }
940#endif
941 };
942
943 //***************************************************************************
949 //***************************************************************************
950 template <typename T, typename TKeyCompare>
952 {
953 return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
954 }
955
956 //***************************************************************************
962 //***************************************************************************
963 template <typename T, typename TKeyCompare>
965 {
966 return !(lhs == rhs);
967 }
968
969 //***************************************************************************
975 //***************************************************************************
976 template <typename T, const size_t MAX_SIZE_, typename TCompare = etl::less<T> >
977 class flat_set : public etl::iflat_set<T, TCompare>
978 {
979 public:
980
981 static ETL_CONSTANT size_t MAX_SIZE = MAX_SIZE_;
982
983 //*************************************************************************
985 //*************************************************************************
987 : etl::iflat_set<T, TCompare>(lookup, storage)
988 {
989 }
990
991 //*************************************************************************
993 //*************************************************************************
994 flat_set(const flat_set& other)
995 : etl::iflat_set<T, TCompare>(lookup, storage)
996 {
997 this->assign(other.cbegin(), other.cend());
998 }
999
1000#if ETL_USING_CPP11
1001 //*************************************************************************
1003 //*************************************************************************
1004 flat_set(flat_set&& other)
1005 : etl::iflat_set<T, TCompare>(lookup, storage)
1006 {
1007 if (&other != this)
1008 {
1009 this->move_container(etl::move(other));
1010 }
1011 }
1012#endif
1013
1014 //*************************************************************************
1019 //*************************************************************************
1020 template <typename TIterator>
1021 flat_set(TIterator first, TIterator last)
1022 : etl::iflat_set<T, TCompare>(lookup, storage)
1023 {
1024 this->assign(first, last);
1025 }
1026
1027#if ETL_HAS_INITIALIZER_LIST
1028 //*************************************************************************
1030 //*************************************************************************
1031 flat_set(std::initializer_list<T> init)
1032 : etl::iflat_set<T, TCompare>(lookup, storage)
1033 {
1034 this->assign(init.begin(), init.end());
1035 }
1036#endif
1037
1038 //*************************************************************************
1040 //*************************************************************************
1042 {
1043 this->clear();
1044 }
1045
1046 //*************************************************************************
1048 //*************************************************************************
1050 {
1051 if (&rhs != this)
1052 {
1053 this->assign(rhs.cbegin(), rhs.cend());
1054 }
1055
1056 return *this;
1057 }
1058
1059#if ETL_USING_CPP11
1060 //*************************************************************************
1062 //*************************************************************************
1064 {
1065 if (&rhs != this)
1066 {
1067 this->move_container(etl::move(rhs));
1068 }
1069
1070 return *this;
1071 }
1072#endif
1073
1074 private:
1075
1076 typedef typename etl::iflat_set<T, TCompare>::value_type node_t;
1077
1078 // The pool of nodes.
1080
1081 // The vector that stores pointers to the nodes.
1083 };
1084
1085 template <typename T, const size_t MAX_SIZE_, typename TCompare>
1086 ETL_CONSTANT size_t flat_set<T, MAX_SIZE_, TCompare>::MAX_SIZE;
1087
1088 //*************************************************************************
1090 //*************************************************************************
1091#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
1092 template <typename... T>
1093 flat_set(T...) -> flat_set<etl::nth_type_t<0, T...>, sizeof...(T)>;
1094#endif
1095
1096 //*************************************************************************
1098 //*************************************************************************
1099#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
1100 template <typename TKey, typename TKeyCompare = etl::less<TKey>, typename... T>
1101 constexpr auto make_flat_set(T&&... keys) -> etl::flat_set<TKey, sizeof...(T), TKeyCompare>
1102 {
1103 return { {etl::forward<T>(keys)...} };
1104 }
1105#endif
1106}
1107
1108#endif
Definition: reference_flat_set.h:72
Definition: reference_flat_set.h:206
Definition: reference_flat_set.h:122
Definition: reference_flat_set.h:102
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
iterator upper_bound(parameter_t key)
Definition: reference_flat_set.h:713
const_reverse_iterator crbegin() const
Definition: reference_flat_set.h:402
iterator begin()
Definition: reference_flat_set.h:312
size_t erase(parameter_t key)
Definition: reference_flat_set.h:485
iterator end()
Definition: reference_flat_set.h:330
ETL_OR_STD::pair< iterator, iterator > equal_range(parameter_t key)
Definition: reference_flat_set.h:751
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
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
size_t count(parameter_t key) const
Definition: reference_flat_set.h:656
bool full() const
Definition: reference_flat_set.h:823
void clear()
Clears the reference_flat_set.
Definition: reference_flat_set.h:552
iterator lower_bound(parameter_t key)
Definition: reference_flat_set.h:675
reverse_iterator rend()
Definition: reference_flat_set.h:384
#define ETL_ASSERT(b, e)
Definition: error_handler.h:316
const_iterator cbegin() const
Definition: flat_set.h:133
iterator insert(const_iterator, const_reference value)
Definition: flat_set.h:283
~iflat_set()
Internal debugging.
Definition: flat_set.h:937
iterator upper_bound(key_parameter_t key)
Definition: flat_set.h:710
size_t available() const
Definition: flat_set.h:872
flat_set()
Constructor.
Definition: flat_set.h:986
size_t erase(key_parameter_t key)
Definition: flat_set.h:498
iterator begin()
Definition: flat_set.h:97
iflat_set(lookup_t &lookup_, storage_t &storage_)
Constructor.
Definition: flat_set.h:882
const_iterator begin() const
Definition: flat_set.h:106
const_reverse_iterator crbegin() const
Definition: flat_set.h:187
iterator erase(iterator i_element)
Definition: flat_set.h:542
ETL_OR_STD::pair< iterator, bool > emplace(const T1 &value1)
Emplaces a value to the set.
Definition: flat_set.h:364
size_type max_size() const
Definition: flat_set.h:863
iterator find(key_parameter_t key)
Definition: flat_set.h:615
ETL_OR_STD::pair< iterator, iterator > equal_range(key_parameter_t key)
Definition: flat_set.h:748
size_type capacity() const
Definition: flat_set.h:854
ETL_OR_STD::pair< iterator, bool > emplace(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Emplaces a value to the set.
Definition: flat_set.h:463
size_t count(key_parameter_t key) const
Definition: flat_set.h:653
ETL_OR_STD::pair< iterator, bool > emplace(const_reference value)
Emplaces a value to the set.
Definition: flat_set.h:321
iterator erase(const_iterator first, const_iterator last)
Definition: flat_set.h:569
iterator lower_bound(key_parameter_t key)
Definition: flat_set.h:672
bool empty() const
Definition: flat_set.h:836
const_iterator find(key_parameter_t key) const
Definition: flat_set.h:634
~flat_set()
Destructor.
Definition: flat_set.h:1041
iflat_set & operator=(const iflat_set &rhs)
Assignment operator.
Definition: flat_set.h:801
const_iterator end() const
Definition: flat_set.h:124
bool full() const
Definition: flat_set.h:845
iterator end()
Definition: flat_set.h:115
bool contains(key_parameter_t key) const
Check if the map contains the key.
Definition: flat_set.h:784
iterator erase(const_iterator i_element)
Definition: flat_set.h:554
ETL_OR_STD::pair< iterator, bool > insert(const_reference value)
Definition: flat_set.h:230
const_reverse_iterator rbegin() const
Definition: flat_set.h:160
ETL_OR_STD::pair< iterator, bool > emplace(const T1 &value1, const T2 &value2)
Emplaces a value to the set.
Definition: flat_set.h:397
void insert(TIterator first, TIterator last)
Definition: flat_set.h:309
const_reverse_iterator crend() const
Definition: flat_set.h:196
void assign(TIterator first, TIterator last)
Definition: flat_set.h:209
reverse_iterator rend()
Definition: flat_set.h:169
flat_set & operator=(const flat_set &rhs)
Assignment operator.
Definition: flat_set.h:1049
flat_set(const flat_set &other)
Copy constructor.
Definition: flat_set.h:994
size_type size() const
Definition: flat_set.h:827
const_iterator lower_bound(key_parameter_t key) const
Definition: flat_set.h:691
reverse_iterator rbegin()
Definition: flat_set.h:151
const_iterator upper_bound(key_parameter_t key) const
Definition: flat_set.h:729
const_reverse_iterator rend() const
Definition: flat_set.h:178
const_iterator cend() const
Definition: flat_set.h:142
ETL_OR_STD::pair< const_iterator, const_iterator > equal_range(key_parameter_t key) const
Definition: flat_set.h:767
ETL_OR_STD::pair< iterator, bool > emplace(const T1 &value1, const T2 &value2, const T3 &value3)
Emplaces a value to the set.
Definition: flat_set.h:430
flat_set(TIterator first, TIterator last)
Definition: flat_set.h:1021
void clear()
Clears the flat_set.
Definition: flat_set.h:587
Definition: flat_set.h:978
Definition: flat_set.h:61
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at(T *)
Definition: memory.h:1006
ETL_CONSTEXPR17 T * addressof(T &t)
Definition: addressof.h:51
void release_all()
Release all objects in the pool.
Definition: ipool.h:248
T * allocate()
Definition: ipool.h:113
void release(const void *const p_object)
Definition: ipool.h:239
Definition: ipool.h:102
bitset_ext
Definition: absolute.h:38
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
Definition: compare.h:52
Definition: type_traits_generator.h:2055
iterator
Definition: iterator.h:399