Embedded Template Library 1.0
Loading...
Searching...
No Matches
iterator.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_ITERATOR_INCLUDED
32#define ETL_ITERATOR_INCLUDED
33
34#include "platform.h"
35#include "type_traits.h"
36#include "utility.h"
37#include "private/addressof.h"
38
39#if ETL_USING_STL || defined(ETL_IN_UNIT_TEST)
40 #include <iterator>
41#endif
42
45
46namespace etl
47{
48 //***************************************************************************
49 // iterator tags
55 //struct contiguous_iterator_tag : public random_access_iterator_tag {};
56
57 //***************************************************************************
58 // iterator_traits
59
60 // For anything not a fundamental type.
63 {
64 typedef typename TIterator::iterator_category iterator_category;
65 typedef typename TIterator::value_type value_type;
66 typedef typename TIterator::difference_type difference_type;
67 typedef typename TIterator::pointer pointer;
68 typedef typename TIterator::reference reference;
69 };
70
71 // For pointers.
72 template <typename T>
73 struct iterator_traits<T*, void>
74 {
75 typedef ETL_OR_STD::random_access_iterator_tag iterator_category;
76 typedef T value_type;
78 typedef typename etl::remove_cv<T>::type* pointer;
79 typedef T& reference;
80 };
81
82 // For const pointers.
83 template <typename T>
84 struct iterator_traits<const T*, void>
85 {
86 typedef ETL_OR_STD::random_access_iterator_tag iterator_category;
87 typedef T value_type;
89 typedef const typename etl::remove_cv<T>::type* pointer;
90 typedef const T& reference;
91 };
92
93 //***************************************************************************
94 // advance
95 template <typename TIterator, typename TDistance>
96 ETL_CONSTEXPR14 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::output_iterator_tag)
97 {
98 while (n--)
99 {
100 ++itr;
101 }
102 }
103
104 template <typename TIterator, typename TDistance>
105 ETL_CONSTEXPR14 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::forward_iterator_tag)
106 {
107 while (n--)
108 {
109 ++itr;
110 }
111 }
112
113 template <typename TIterator, typename TDistance>
114 ETL_CONSTEXPR14 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::bidirectional_iterator_tag)
115 {
116 if (n > 0)
117 {
118 while (n--)
119 {
120 ++itr;
121 }
122 }
123 else
124 {
125 while (n++)
126 {
127 --itr;
128 }
129 }
130 }
131
132 template <typename TIterator, typename TDistance>
133 ETL_CONSTEXPR14 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::random_access_iterator_tag)
134 {
135 itr += n;
136 }
137
138 template <typename TIterator, typename TDistance>
139 ETL_CONSTEXPR14 void advance(TIterator& itr, TDistance n)
140 {
141 typedef typename etl::iterator_traits<TIterator>::iterator_category tag;
142
143 advance_helper(itr, n, tag());
144 }
145
146 //***************************************************************************
147 // distance
148 template<typename TIterator>
149 ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::input_iterator_tag)
150 {
151 typename etl::iterator_traits<TIterator>::difference_type d = 0;
152
153 while (first != last)
154 {
155 ++d;
156 ++first;
157 }
158
159 return d;
160 }
161
162 template<typename TIterator>
163 ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::forward_iterator_tag)
164 {
165 typename etl::iterator_traits<TIterator>::difference_type d = 0;
166
167 while (first != last)
168 {
169 ++d;
170 ++first;
171 }
172
173 return d;
174 }
175
176 template<typename TIterator>
177 ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::bidirectional_iterator_tag)
178 {
179 typename etl::iterator_traits<TIterator>::difference_type d = 0;
180
181 while (first != last)
182 {
183 ++d;
184 ++first;
185 }
186
187 return d;
188 }
189
190 template<typename TIterator>
191 ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::random_access_iterator_tag)
192 {
193 return last - first;
194 }
195
196 template<typename TIterator>
197 ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type distance(TIterator first, TIterator last)
198 {
199 typedef typename etl::iterator_traits<TIterator>::iterator_category tag;
200
201 return distance_helper(first, last, tag());
202 }
203
204 //***************************************************************************
205 // Previous
206 template<typename TIterator>
207 ETL_CONSTEXPR14 TIterator prev(TIterator itr, typename etl::iterator_traits<TIterator>::difference_type n = 1)
208 {
209 etl::advance(itr, -n);
210
211 return itr;
212 }
213
214 //***************************************************************************
215 // Next
216 template<typename TIterator>
217 ETL_CONSTEXPR14 TIterator next(TIterator itr, typename etl::iterator_traits<TIterator>::difference_type n = 1)
218 {
219 etl::advance(itr, n);
220
221 return itr;
222 }
223
224 //***************************************************************************
225 // reverse_iterator
226 template <typename TIterator>
228 {
229 public:
230
231 typedef typename iterator_traits<TIterator>::iterator_category iterator_category;
232 typedef typename iterator_traits<TIterator>::value_type value_type;
233 typedef typename iterator_traits<TIterator>::difference_type difference_type;
234 typedef typename iterator_traits<TIterator>::pointer pointer;
235 typedef typename iterator_traits<TIterator>::reference reference;
236
237 typedef TIterator iterator_type;
238
239 ETL_CONSTEXPR14 reverse_iterator()
240 : current()
241 {
242 }
243
244 ETL_CONSTEXPR14 explicit reverse_iterator(TIterator itr)
245 : current(itr)
246 {
247 }
248
249 template <typename TOther>
250 ETL_CONSTEXPR14 reverse_iterator(const reverse_iterator<TOther>& other)
251 : current(other.base())
252 {
253 }
254
255 template<class TOther>
257 {
258 current = other.base();
259
260 return (*this);
261 }
262
263 ETL_CONSTEXPR14 TIterator base() const
264 {
265 return current;
266 }
267
268 ETL_NODISCARD ETL_CONSTEXPR14 reference operator*() const
269 {
270 TIterator temp = current;
271
272 return *(--temp);
273 }
274
275 ETL_NODISCARD ETL_CONSTEXPR14 pointer operator->() const
276 {
277 TIterator temp = current;
278
279 return &(*--temp);
280 }
281
282 ETL_CONSTEXPR14 reverse_iterator& operator++()
283 {
284 --current;
285
286 return *this;
287 }
288
289 ETL_CONSTEXPR14 reverse_iterator operator++(int)
290 {
291 reverse_iterator temp = *this;
292 --current;
293
294 return temp;
295 }
296
297 ETL_CONSTEXPR14 reverse_iterator& operator--()
298 {
299 ++current;
300
301 return (*this);
302 }
303
304 ETL_CONSTEXPR14 reverse_iterator operator--(int)
305 {
306 reverse_iterator temp = *this;
307 ++current;
308
309 return temp;
310 }
311
312 ETL_CONSTEXPR14 reverse_iterator& operator+=(const difference_type offset)
313 {
314 current -= offset;
315
316 return (*this);
317 }
318
319 ETL_CONSTEXPR14 reverse_iterator& operator-=(const difference_type offset)
320 {
321 current += offset;
322
323 return (*this);
324 }
325
326 ETL_NODISCARD ETL_CONSTEXPR14 reverse_iterator operator+(const difference_type offset) const
327 {
328 return reverse_iterator(current - offset);
329 }
330
331 ETL_NODISCARD ETL_CONSTEXPR14 reverse_iterator operator-(const difference_type offset) const
332 {
333 return (reverse_iterator(current + offset));
334 }
335
336 ETL_NODISCARD ETL_CONSTEXPR14 reference operator[](const difference_type offset) const
337 {
338 return (*(*this + offset));
339 }
340
341 protected:
342
343 TIterator current;
344 };
345
346 template <typename TIterator>
348 {
349 return lhs.base() == rhs.base();
350 }
351
352 template <typename TIterator>
353 ETL_CONSTEXPR14 bool operator !=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
354 {
355 return !(lhs == rhs);
356 }
357
358 template <typename TIterator>
359 ETL_CONSTEXPR14 bool operator <(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
360 {
361 return rhs.base() < lhs.base();
362 }
363
364 template <typename TIterator>
365 ETL_CONSTEXPR14 bool operator >(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
366 {
367 return rhs < lhs;
368 }
369
370 template <typename TIterator>
371 ETL_CONSTEXPR14 bool operator <=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
372 {
373 return !(rhs < lhs);
374 }
375
376 template <typename TIterator>
377 ETL_CONSTEXPR14 bool operator >=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
378 {
379 return !(lhs < rhs);
380 }
381
382 template <typename TIterator>
383 ETL_CONSTEXPR14 typename reverse_iterator<TIterator>::difference_type operator -(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
384 {
385 return rhs.base() - lhs.base();
386 }
387
388 template <typename TIterator, class TDifference>
389 ETL_CONSTEXPR14 reverse_iterator<TIterator> operator +(TDifference n, const reverse_iterator<TIterator>& itr)
390 {
391 return itr.operator +(n);
392 }
393
394 //***************************************************************************
396 //***************************************************************************
397 template <typename TCategory, typename T, typename TDistance = ptrdiff_t, typename TPointer = T* , typename TReference = T& >
398 struct iterator
399 {
400 typedef T value_type;
402 typedef TPointer pointer;
403 typedef TReference reference;
405 };
406
407#if ETL_USING_CPP11
408 //***************************************************************************
409 // move_iterator
410 template <typename TIterator>
411 class move_iterator
412 {
413 public:
414
415 typedef typename iterator_traits<TIterator>::iterator_category iterator_category;
416 typedef typename iterator_traits<TIterator>::value_type value_type;
417 typedef typename iterator_traits<TIterator>::difference_type difference_type;
418 typedef TIterator iterator_type;
419 typedef TIterator pointer;
420 typedef value_type&& reference;
421
423 {
424 }
425
426 explicit move_iterator(TIterator itr)
427 : current(itr)
428 {
429 }
430
431 template <typename U>
433 : current(itr.base())
434 {
435 }
436
437 template <typename U>
438 move_iterator& operator =(const move_iterator<U>& itr)
439 {
440 current = itr.current;
441 return *this;
442 }
443
444 iterator_type base() const
445 {
446 return current;
447 }
448
449 pointer operator ->() const
450 {
451 return current;
452 }
453
454 reference operator *() const
455 {
456 return etl::move(*current);
457 }
458
459 move_iterator& operator++()
460 {
461 ++current;
462 return *this;
463 }
464
465 move_iterator& operator--()
466 {
467 --current;
468 return *this;
469 }
470
471 move_iterator operator++(int)
472 {
473 move_iterator temp = *this;
474 ++current;
475 return temp;
476 }
477
478 move_iterator operator--(int)
479 {
480 move_iterator temp = *this;
481 --current;
482 return temp;
483 }
484
485 move_iterator operator +(difference_type n) const
486 {
487 return move_iterator(current + n);
488 }
489
490 move_iterator operator -(difference_type n) const
491 {
492 return move_iterator(current - n);
493 }
494
495 move_iterator operator +=(difference_type n)
496 {
497 current += n;
498 return *this;
499 }
500
501 move_iterator operator -=(difference_type n)
502 {
503 current -= n;
504 return *this;
505 }
506
507 reference operator [](difference_type n) const
508 {
509 return etl::move(current[n]);
510 }
511
512 private:
513
514 TIterator current;
515 };
516
517 template <typename TIterator>
520 {
521 return lhs.base() == rhs.base();
522 }
523
524 template <typename TIterator>
527 {
528 return !(lhs == rhs);
529 }
530
531 template <typename TIterator>
534 {
535 return lhs.base() < rhs.base();
536 }
537
538 template <typename TIterator>
541 {
542 return !(rhs < lhs);
543 }
544
545 template <typename TIterator>
548 {
549 return (rhs < lhs);
550 }
551
552 template <typename TIterator>
555 {
556 return !(lhs < rhs);
557 }
558
559 template <typename TIterator>
560 move_iterator<TIterator> operator +(typename move_iterator<TIterator>::difference_type n,
561 const move_iterator<TIterator>& rhs)
562 {
563 return rhs + n;
564 }
565
566 template <typename TIterator1, typename TIterator2 >
567 auto operator -(const move_iterator<TIterator1>& lhs,
568 const move_iterator<TIterator2>& rhs) -> decltype(lhs.base() - rhs.base())
569 {
570 return lhs.base() - rhs.base();
571 }
572
573 template <typename TIterator>
574 etl::move_iterator<TIterator> make_move_iterator(TIterator itr)
575 {
577 }
578
579#endif //ETL_USING_CPP11
580
581 //***************************************************************************
582 // back_insert_iterator
583 //***************************************************************************
584
585 //***************************************************************************
587 //***************************************************************************
588 template <typename TContainer>
589 class back_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
590 {
591 public:
592
594
595 //***************************************************************************
597 //***************************************************************************
598 explicit ETL_CONSTEXPR14 back_insert_iterator(TContainer& c)
599 : container(etl::addressof(c))
600 {
601 }
602
603 //***************************************************************************
605 //***************************************************************************
606 ETL_CONSTEXPR14 back_insert_iterator& operator =(const typename TContainer::value_type& value)
607 {
608 container->push_back(value);
609
610 return (*this);
611 }
612
613#if ETL_USING_CPP11
614 //***************************************************************************
616 //***************************************************************************
617 ETL_CONSTEXPR14 back_insert_iterator& operator =(typename TContainer::value_type&& value)
618 {
619 container->push_back(etl::move(value));
620
621 return (*this);
622 }
623#endif // ETL_USING_CPP11
624
625 //***************************************************************************
627 //***************************************************************************
628 ETL_NODISCARD ETL_CONSTEXPR14 back_insert_iterator& operator *()
629 {
630 return (*this);
631 }
632
633 //***************************************************************************
635 //***************************************************************************
637 {
638 return (*this);
639 }
640
641 //***************************************************************************
643 //***************************************************************************
645 {
646 return (*this);
647 }
648
649 protected:
650
651 TContainer* container;
652 };
653
654 //***************************************************************************
656 //***************************************************************************
657 template <typename TContainer>
658 ETL_NODISCARD
659 ETL_CONSTEXPR14
664
665 //***************************************************************************
666 // front_insert_iterator
667 //***************************************************************************
668
669 //***************************************************************************
671 //***************************************************************************
672 template <typename TContainer>
673 class front_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
674 {
675 public:
676
678
679 //***************************************************************************
681 //***************************************************************************
682 explicit ETL_CONSTEXPR14 front_insert_iterator(TContainer& c)
683 : container(etl::addressof(c))
684 {
685 }
686
687 //***************************************************************************
689 //***************************************************************************
690 ETL_CONSTEXPR14 front_insert_iterator& operator =(const typename TContainer::value_type& value)
691 {
692 container->push_front(value);
693 return (*this);
694 }
695
696#if ETL_USING_CPP11
697 //***************************************************************************
699 //***************************************************************************
700 ETL_CONSTEXPR14 front_insert_iterator& operator =(typename TContainer::value_type&& value)
701 {
702 container->push_front(etl::move(value));
703 return (*this);
704 }
705#endif // ETL_USING_CPP11
706
707 //***************************************************************************
709 //***************************************************************************
710 ETL_NODISCARD ETL_CONSTEXPR14 front_insert_iterator& operator *()
711 {
712 return (*this);
713 }
714
715 //***************************************************************************
717 //***************************************************************************
719 {
720 return (*this);
721 }
722
723 //***************************************************************************
725 //***************************************************************************
727 {
728 return (*this);
729 }
730
731 protected:
732
733 TContainer* container;
734 };
735
736 //***************************************************************************
738 //***************************************************************************
739 template <typename TContainer>
740 ETL_NODISCARD
741 ETL_CONSTEXPR14
746
747 //***************************************************************************
748 // push_insert_iterator
749 //***************************************************************************
750
751 //***************************************************************************
753 //***************************************************************************
754 template <typename TContainer>
755 class push_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
756 {
757 public:
758
760
761 //***************************************************************************
763 //***************************************************************************
764 explicit ETL_CONSTEXPR14 push_insert_iterator(TContainer& c)
765 : container(etl::addressof(c))
766 {
767 }
768
769 //***************************************************************************
771 //***************************************************************************
772 ETL_CONSTEXPR14 push_insert_iterator& operator =(const typename TContainer::value_type& value)
773 {
774 container->push(value);
775
776 return (*this);
777 }
778
779#if ETL_USING_CPP11
780 //***************************************************************************
782 //***************************************************************************
783 ETL_CONSTEXPR14 push_insert_iterator& operator =(typename TContainer::value_type&& value)
784 {
785 container->push(etl::move(value));
786
787 return (*this);
788 }
789#endif // ETL_USING_CPP11
790
791 //***************************************************************************
793 //***************************************************************************
794 ETL_NODISCARD ETL_CONSTEXPR14 push_insert_iterator& operator *()
795 {
796 return (*this);
797 }
798
799 //***************************************************************************
801 //***************************************************************************
803 {
804 return (*this);
805 }
806
807 //***************************************************************************
809 //***************************************************************************
811 {
812 return (*this);
813 }
814
815 protected:
816
817 TContainer* container;
818 };
819
820 //***************************************************************************
822 //***************************************************************************
823 template <typename TContainer>
824 ETL_NODISCARD
825 ETL_CONSTEXPR14
830
831 //***************************************************************************
832 // Helper templates.
833 //***************************************************************************
834 template <typename T>
836 {
837 static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::input_iterator_tag>::value;
838 };
839
840 template <typename T>
841 ETL_CONSTANT bool is_input_iterator<T>::value;
842
843 template <typename T>
845 {
846 static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::output_iterator_tag>::value;
847 };
848
849 template <typename T>
850 ETL_CONSTANT bool is_output_iterator<T>::value;
851
852 template <typename T>
854 {
855 static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::forward_iterator_tag>::value;
856 };
857
858 template <typename T>
859 ETL_CONSTANT bool is_forward_iterator<T>::value;
860
861 template <typename T>
863 {
864 static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value;
865 };
866
867 template <typename T>
868 ETL_CONSTANT bool is_bidirectional_iterator<T>::value;
869
870 // Deprecated
871 template <typename T>
873 {
874 static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value;
875 };
876
877 template <typename T>
878 ETL_CONSTANT bool is_random_iterator<T>::value;
879
880 template <typename T>
882 {
883 static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value;
884 };
885
886 template <typename T>
887 ETL_CONSTANT bool is_random_access_iterator<T>::value;
888
889 template <typename T>
897
898 template <typename T>
899 ETL_CONSTANT bool is_input_iterator_concept<T>::value;
900
901 template <typename T>
909
910 template <typename T>
911 ETL_CONSTANT bool is_output_iterator_concept<T>::value;
912
913 template <typename T>
920
921 template <typename T>
923
924 template <typename T>
930
931 template <typename T>
933
934 // Deprecated
935 template <typename T>
937 {
938 static ETL_CONSTANT bool value = etl::is_random_iterator<T>::value;
939 };
940
941 // Deprecated
942 template <typename T>
943 ETL_CONSTANT bool is_random_iterator_concept<T>::value;
944
945 // Deprecated
946 template <typename T>
948 {
949 static ETL_CONSTANT bool value = etl::is_random_access_iterator<T>::value;
950 };
951
952 // Deprecated
953 template <typename T>
955
956#if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
957 //*****************************************************************************
960 //*****************************************************************************
961 template<typename TContainer>
962 ETL_CONSTEXPR typename TContainer::iterator begin(TContainer& container)
963 {
964 return container.begin();
965 }
966
967 //*****************************************************************************
970 //*****************************************************************************
971 template<typename TContainer>
972 ETL_CONSTEXPR typename TContainer::const_iterator begin(const TContainer& container)
973 {
974 return container.begin();
975 }
976
977 //*****************************************************************************
980 //*****************************************************************************
981 template<typename TContainer>
982 ETL_CONSTEXPR typename TContainer::const_iterator cbegin(const TContainer& container)
983 {
984 return container.cbegin();
985 }
986
987 //*****************************************************************************
990 //*****************************************************************************
991 template<typename TContainer>
992 ETL_CONSTEXPR typename TContainer::iterator end(TContainer& container)
993 {
994 return container.end();
995 }
996
997 //*****************************************************************************
1000 //*****************************************************************************
1001 template<typename TContainer>
1002 ETL_CONSTEXPR typename TContainer::const_iterator end(const TContainer& container)
1003 {
1004 return container.end();
1005 }
1006
1007 //*****************************************************************************
1010 //*****************************************************************************
1011 template<typename TContainer>
1012 ETL_CONSTEXPR typename TContainer::const_iterator cend(const TContainer& container)
1013 {
1014 return container.cend();
1015 }
1016
1017 //*****************************************************************************
1020 //*****************************************************************************
1021 template<typename TValue, size_t Array_Size>
1022 ETL_CONSTEXPR TValue* begin(TValue(&data)[Array_Size])
1023 {
1024 return &data[0];
1025 }
1026
1027 //*****************************************************************************
1030 //*****************************************************************************
1031 template<typename TValue, size_t Array_Size>
1032 ETL_CONSTEXPR const TValue* begin(const TValue(&data)[Array_Size])
1033 {
1034 return &data[0];
1035 }
1036
1037 //*****************************************************************************
1040 //*****************************************************************************
1041 template<typename TValue, size_t Array_Size>
1042 ETL_CONSTEXPR const TValue* cbegin(const TValue(&data)[Array_Size])
1043 {
1044 return &data[0];
1045 }
1046
1047 //*****************************************************************************
1050 //*****************************************************************************
1051 template<typename TValue, size_t Array_Size>
1052 ETL_CONSTEXPR TValue* end(TValue(&data)[Array_Size])
1053 {
1054 return &data[Array_Size];
1055 }
1056
1057 //*****************************************************************************
1060 //*****************************************************************************
1061 template<typename TValue, size_t Array_Size>
1062 ETL_CONSTEXPR const TValue* end(const TValue(&data)[Array_Size])
1063 {
1064 return &data[Array_Size];
1065 }
1066
1067 //*****************************************************************************
1070 //*****************************************************************************
1071 template<typename TValue, size_t Array_Size>
1072 ETL_CONSTEXPR const TValue* cend(const TValue(&data)[Array_Size])
1073 {
1074 return &data[Array_Size];
1075 }
1076#endif
1077
1078#if ETL_NOT_USING_STL || ETL_CPP14_NOT_SUPPORTED
1079 //*****************************************************************************
1082 //*****************************************************************************
1083 template<typename TContainer>
1084 ETL_CONSTEXPR typename TContainer::reverse_iterator rbegin(TContainer& container)
1085 {
1086 return container.rbegin();
1087 }
1088
1089 //*****************************************************************************
1092 //*****************************************************************************
1093 template<typename TContainer>
1094 ETL_CONSTEXPR typename TContainer::const_reverse_iterator rbegin(const TContainer& container)
1095 {
1096 return container.rbegin();
1097 }
1098
1099 //*****************************************************************************
1102 //*****************************************************************************
1103 template<typename TContainer>
1104 ETL_CONSTEXPR typename TContainer::const_reverse_iterator crbegin(const TContainer& container)
1105 {
1106 return container.crbegin();
1107 }
1108
1109 //*****************************************************************************
1112 //*****************************************************************************
1113 template<typename TContainer>
1114 ETL_CONSTEXPR typename TContainer::reverse_iterator rend(TContainer& container)
1115 {
1116 return container.rend();
1117 }
1118
1119 //*****************************************************************************
1122 //*****************************************************************************
1123 template<typename TContainer>
1124 ETL_CONSTEXPR typename TContainer::const_reverse_iterator rend(const TContainer& container)
1125 {
1126 return container.rend();
1127 }
1128
1129 //*****************************************************************************
1132 //*****************************************************************************
1133 template<typename TContainer>
1134 ETL_CONSTEXPR typename TContainer::const_reverse_iterator crend(const TContainer& container)
1135 {
1136 return container.crend();
1137 }
1138
1139 //*****************************************************************************
1142 //*****************************************************************************
1143 template<typename TValue, size_t Array_Size>
1144 ETL_OR_STD::reverse_iterator<TValue*> rbegin(TValue(&data)[Array_Size])
1145 {
1146 return ETL_OR_STD::reverse_iterator<TValue*>(&data[Array_Size]);
1147 }
1148
1149 //*****************************************************************************
1152 //*****************************************************************************
1153 template<typename TValue, size_t Array_Size>
1154 ETL_CONSTEXPR ETL_OR_STD::reverse_iterator<const TValue*> crbegin(const TValue(&data)[Array_Size])
1155 {
1156 return ETL_OR_STD::reverse_iterator<const TValue*>(&data[Array_Size]);
1157 }
1158
1159 //*****************************************************************************
1162 //*****************************************************************************
1163 template<typename TValue, size_t Array_Size>
1164 ETL_CONSTEXPR ETL_OR_STD::reverse_iterator<TValue*> rend(TValue(&data)[Array_Size])
1165 {
1166 return ETL_OR_STD::reverse_iterator<TValue*>(&data[0]);
1167 }
1168
1169 //*****************************************************************************
1172 //*****************************************************************************
1173 template<typename TValue, size_t Array_Size>
1174 ETL_CONSTEXPR ETL_OR_STD::reverse_iterator<const TValue*> crend(const TValue(&data)[Array_Size])
1175 {
1176 return ETL_OR_STD::reverse_iterator<const TValue*>(&data[0]);
1177 }
1178#endif
1179
1180#if ETL_NOT_USING_STL || ETL_CPP17_NOT_SUPPORTED
1181 //**************************************************************************
1185 //**************************************************************************
1186 template<typename TContainer>
1187 ETL_CONSTEXPR typename TContainer::size_type size(const TContainer& container)
1188 {
1189 return container.size();
1190 }
1191
1196 template<typename TValue, size_t Array_Size>
1197 ETL_CONSTEXPR size_t size(TValue(&)[Array_Size])
1198 {
1199 return Array_Size;
1200 }
1201#endif
1202
1203 //**************************************************************************
1209 //**************************************************************************
1210 template <typename T, size_t Array_Size>
1211 char(&array_size(T(&array)[Array_Size]))[Array_Size];
1212
1213#define ETL_ARRAY_SIZE(a) sizeof(etl::array_size(a))
1214}
1215
1216#endif
1217
Turns assignment into push_back.
Definition iterator.h:590
ETL_CONSTEXPR14 back_insert_iterator & operator++()
Pre-increment operator.
Definition iterator.h:636
ETL_CONSTEXPR14 back_insert_iterator(TContainer &c)
Constructor.
Definition iterator.h:598
ETL_CONSTEXPR14 back_insert_iterator & operator=(const typename TContainer::value_type &value)
Assignment operator.
Definition iterator.h:606
ETL_NODISCARD ETL_CONSTEXPR14 back_insert_iterator & operator*()
Dereference operator.
Definition iterator.h:628
Turns assignment into a push_front.
Definition iterator.h:674
ETL_CONSTEXPR14 front_insert_iterator(TContainer &c)
Constructor.
Definition iterator.h:682
ETL_CONSTEXPR14 front_insert_iterator & operator++()
Pre-increment operator.
Definition iterator.h:718
ETL_NODISCARD ETL_CONSTEXPR14 front_insert_iterator & operator*()
Dereference operator.
Definition iterator.h:710
ETL_CONSTEXPR14 front_insert_iterator & operator=(const typename TContainer::value_type &value)
Assignment operator.
Definition iterator.h:690
Turns assignment into a push.
Definition iterator.h:756
ETL_NODISCARD ETL_CONSTEXPR14 push_insert_iterator & operator*()
Dereference operator.
Definition iterator.h:794
ETL_CONSTEXPR14 push_insert_iterator & operator=(const typename TContainer::value_type &value)
Assignment operator.
Definition iterator.h:772
ETL_CONSTEXPR14 push_insert_iterator & operator++()
Pre-increment operator.
Definition iterator.h:802
ETL_CONSTEXPR14 push_insert_iterator(TContainer &c)
Constructor.
Definition iterator.h:764
Definition iterator.h:228
Definition array.h:88
ETL_CONSTEXPR17 etl::enable_if<!etl::is_same< T, etl::nullptr_t >::value, T >::type * addressof(T &t)
Definition addressof.h:52
bitset_ext
Definition absolute.h:38
ETL_CONSTEXPR TContainer::reverse_iterator rend(TContainer &container)
Definition iterator.h:1114
ETL_CONSTEXPR TContainer::const_reverse_iterator crbegin(const TContainer &container)
Definition iterator.h:1104
ETL_CONSTEXPR14 etl::circular_iterator< TIterator > operator-(etl::circular_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type offset)
Definition circular_iterator.h:672
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:693
ETL_NODISCARD ETL_CONSTEXPR14 etl::push_insert_iterator< TContainer > push_inserter(TContainer &container)
Creates a push_insert_iterator from a container.
Definition iterator.h:826
ETL_NODISCARD ETL_CONSTEXPR14 etl::front_insert_iterator< TContainer > front_inserter(TContainer &container)
Creates a front_insert_iterator from a container.
Definition iterator.h:742
char(& array_size(T(&array)[Array_Size]))[Array_Size]
ETL_CONSTEXPR TContainer::reverse_iterator rbegin(TContainer &container)
Definition iterator.h:1084
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:705
ETL_CONSTEXPR TContainer::const_iterator cbegin(const TContainer &container)
Definition iterator.h:982
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:654
ETL_NODISCARD ETL_CONSTEXPR14 etl::back_insert_iterator< TContainer > back_inserter(TContainer &container)
Creates a back_insert_iterator from a container.
Definition iterator.h:660
ETL_CONSTEXPR TContainer::size_type size(const TContainer &container)
Definition iterator.h:1187
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:642
ETL_CONSTEXPR TContainer::iterator begin(TContainer &container)
Definition iterator.h:962
ETL_CONSTEXPR14 etl::circular_iterator< TIterator > operator+(etl::circular_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type offset)
Definition circular_iterator.h:659
ETL_CONSTEXPR TContainer::const_reverse_iterator crend(const TContainer &container)
Definition iterator.h:1134
ETL_CONSTEXPR TContainer::const_iterator cend(const TContainer &container)
Definition iterator.h:1012
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:666
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:681
ETL_CONSTEXPR TContainer::iterator end(TContainer &container)
Definition iterator.h:992
Definition iterator.h:53
Definition iterator.h:52
Definition iterator.h:50
Definition iterator.h:863
Definition iterator.h:915
Definition iterator.h:854
Definition iterator.h:891
Definition iterator.h:836
Definition iterator.h:903
Definition iterator.h:845
Definition iterator.h:882
Definition iterator.h:937
Definition iterator.h:873
Definition iterator.h:63
iterator
Definition iterator.h:399
Definition iterator.h:51
pair holds two objects of arbitrary type
Definition utility.h:164
ETL_CONSTEXPR pair()
Default constructor.
Definition utility.h:176
Definition iterator.h:54