Embedded Template Library 1.0
Loading...
Searching...
No Matches
ivectorpointer.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) 2016 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_IVECTOR_POINTER_INCLUDED
32#define ETL_IVECTOR_POINTER_INCLUDED
33
34#ifndef ETL_IN_VECTOR_H
35#error This header is a private element of etl::ivector
36#endif
37
38#include "pvoidvector.h"
39
40namespace etl
41{
42 //***************************************************************************
46 //***************************************************************************
47 template <typename T>
48 class ivector<T*> : public pvoidvector
49 {
50 public:
51
52 typedef T* value_type;
53 typedef value_type& reference;
54 typedef const value_type& const_reference;
55 typedef value_type* pointer;
56 typedef const value_type* const_pointer;
57 typedef value_type* iterator;
58 typedef const value_type* const_iterator;
59 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
60 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
61 typedef size_t size_type;
62 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
63
64 protected:
65
66 typedef value_type parameter_t;
67
68 private:
69
70 typedef pvoidvector base_t;
71
72 public:
73
74 //*********************************************************************
77 //*********************************************************************
78 iterator begin()
79 {
80 return iterator(base_t::begin());
81 }
82
83 //*********************************************************************
86 //*********************************************************************
87 const_iterator begin() const
88 {
89 return const_iterator(base_t::begin());
90 }
91
92 //*********************************************************************
95 //*********************************************************************
96 iterator end()
97 {
98 return iterator(base_t::end());
99 }
100
101 //*********************************************************************
104 //*********************************************************************
105 const_iterator end() const
106 {
107 return const_iterator(base_t::end());
108 }
109
110 //*********************************************************************
113 //*********************************************************************
114 const_iterator cbegin() const
115 {
116 return const_iterator(base_t::cbegin());
117 }
118
119 //*********************************************************************
122 //*********************************************************************
123 const_iterator cend() const
124 {
125 return const_iterator(base_t::cend());
126 }
127
128 //*********************************************************************
131 //*********************************************************************
132 reverse_iterator rbegin()
133 {
134 return reverse_iterator(iterator(base_t::end()));
135 }
136
137 //*********************************************************************
140 //*********************************************************************
141 const_reverse_iterator rbegin() const
142 {
143 return const_reverse_iterator(const_iterator(base_t::end()));
144 }
145
146 //*********************************************************************
149 //*********************************************************************
150 reverse_iterator rend()
151 {
152 return reverse_iterator(iterator(base_t::begin()));
153 }
154
155 //*********************************************************************
158 //*********************************************************************
159 const_reverse_iterator rend() const
160 {
161 return const_reverse_iterator(const_iterator(base_t::begin()));
162 }
163
164 //*********************************************************************
167 //*********************************************************************
168 const_reverse_iterator crbegin() const
169 {
170 return const_reverse_iterator(const_iterator(base_t::cend()));
171 }
172
173 //*********************************************************************
176 //*********************************************************************
177 const_reverse_iterator crend() const
178 {
179 return const_reverse_iterator(const_iterator(base_t::cbegin()));
180 }
181
182 //*********************************************************************
187 //*********************************************************************
188 void resize(size_t new_size)
189 {
190 base_t::resize(new_size);
191 }
192
193 //*********************************************************************
199 //*********************************************************************
200 void resize(size_t new_size, value_type value)
201 {
202 base_t::resize(new_size, value);
203 }
204
205 //*********************************************************************
208 //*********************************************************************
210 {
211 base_t::uninitialized_resize(new_size);
212 }
213
214 //*********************************************************************
218 //*********************************************************************
220 {
221 return reference(base_t::operator[](i));
222 }
223
224 //*********************************************************************
228 //*********************************************************************
230 {
231 return const_reference(base_t::operator[](i));
232 }
233
234 //*********************************************************************
239 //*********************************************************************
240 reference at(size_t i)
241 {
242 return reference(base_t::at(i));
243 }
244
245 //*********************************************************************
250 //*********************************************************************
251 const_reference at(size_t i) const
252 {
253 return const_reference(base_t::at(i));
254 }
255
256 //*********************************************************************
259 //*********************************************************************
261 {
262 return reference(base_t::front());
263 }
264
265 //*********************************************************************
268 //*********************************************************************
270 {
271 return const_reference(base_t::front());
272 }
273
274 //*********************************************************************
277 //*********************************************************************
279 {
280 return reference(base_t::back());
281 }
282
283 //*********************************************************************
286 //*********************************************************************
288 {
289 return const_reference(base_t::back());
290 }
291
292 //*********************************************************************
295 //*********************************************************************
297 {
298 return pointer(base_t::data());
299 }
300
301 //*********************************************************************
304 //*********************************************************************
306 {
307 return const_pointer(base_t::data());
308 }
309
310 //*********************************************************************
316 //*********************************************************************
317 template <typename TIterator>
318 void assign(TIterator first, TIterator last)
319 {
320 base_t::assign(first, last);
321 }
322
323 //*********************************************************************
328 //*********************************************************************
329 void assign(size_t n, parameter_t value)
330 {
331 base_t::assign(n, value);
332 }
333
334 //*************************************************************************
336 //*************************************************************************
337 void clear()
338 {
339 base_t::clear();
340 }
341
342 //*********************************************************************
346 //*********************************************************************
347 void push_back(parameter_t value)
348 {
349 base_t::push_back(value);
350 }
351
352 //*********************************************************************
356 //*********************************************************************
358 {
359 base_t::emplace_back(ETL_NULLPTR);
360
361 return back();
362 }
363
364 //*********************************************************************
368 //*********************************************************************
369 reference emplace_back(parameter_t value)
370 {
371 base_t::emplace_back(value);
372
373 return back();
374 }
375
376 //*************************************************************************
379 //*************************************************************************
380 void pop_back()
381 {
382 base_t::pop_back();
383 }
384
385 //*********************************************************************
390 //*********************************************************************
391 iterator insert(const_iterator position, parameter_t value)
392 {
393 return iterator(base_t::insert(base_t::iterator(position), value));
394 }
395
396 //*************************************************************************
398 //*************************************************************************
399 iterator emplace(const_iterator position)
400 {
401 return iterator(base_t::emplace(base_t::iterator(position), ETL_NULLPTR));
402 }
403
404 //*************************************************************************
406 //*************************************************************************
407 iterator emplace(const_iterator position, parameter_t value)
408 {
409 return iterator(base_t::emplace(base_t::iterator(position), value));
410 }
411
412 //*********************************************************************
418 //*********************************************************************
419 void insert(const_iterator position, size_t n, parameter_t value)
420 {
421 base_t::insert(base_t::iterator(position), n, value);
422 }
423
424 //*********************************************************************
430 //*********************************************************************
431 template <class TIterator>
432 void insert(const_iterator position, TIterator first, TIterator last)
433 {
434 base_t::insert(base_t::iterator(position), first, last);
435 }
436
437 //*********************************************************************
441 //*********************************************************************
442 iterator erase(iterator i_element)
443 {
444 return iterator(base_t::erase(base_t::iterator(i_element)));
445 }
446
447 //*********************************************************************
451 //*********************************************************************
452 iterator erase(const_iterator i_element)
453 {
454 return iterator(base_t::erase(base_t::const_iterator(i_element)));
455 }
456
457 //*********************************************************************
464 //*********************************************************************
465 iterator erase(const_iterator first, const_iterator last)
466 {
467 return iterator(base_t::erase(base_t::const_iterator(first), base_t::const_iterator(last)));
468 }
469
470 //*************************************************************************
472 //*************************************************************************
474 {
475 base_t::operator = (rhs);
476
477 return *this;
478 }
479
480#if ETL_USING_CPP11
481 //*************************************************************************
483 //*************************************************************************
485 {
486 (void)base_t::operator = (etl::move(rhs));
487
488 return *this;
489 }
490#endif
491
492#ifdef ETL_IVECTOR_REPAIR_ENABLE
493 //*************************************************************************
495 //*************************************************************************
496 virtual void repair() = 0;
497#endif
498
499 protected:
500
501 //*********************************************************************
503 //*********************************************************************
508 };
509
510 template <typename T>
511 class ivector<const T*> : public pvoidvector
512 {
513 public:
514
515 typedef const T* value_type;
516 typedef value_type& reference;
517 typedef const value_type& const_reference;
518 typedef value_type* pointer;
519 typedef const value_type* const_pointer;
520 typedef value_type* iterator;
521 typedef const value_type* const_iterator;
522 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
523 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
524 typedef size_t size_type;
525 typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
526
527 protected:
528
529 typedef value_type parameter_t;
530
531 private:
532
533 typedef pvoidvector base_t;
534
535 public:
536
537 //*********************************************************************
540 //*********************************************************************
541 iterator begin()
542 {
543 return iterator(base_t::begin());
544 }
545
546 //*********************************************************************
549 //*********************************************************************
550 const_iterator begin() const
551 {
552 return const_iterator(base_t::begin());
553 }
554
555 //*********************************************************************
558 //*********************************************************************
559 iterator end()
560 {
561 return iterator(base_t::end());
562 }
563
564 //*********************************************************************
567 //*********************************************************************
568 const_iterator end() const
569 {
570 return const_iterator(base_t::end());
571 }
572
573 //*********************************************************************
576 //*********************************************************************
577 const_iterator cbegin() const
578 {
579 return const_iterator(base_t::cbegin());
580 }
581
582 //*********************************************************************
585 //*********************************************************************
586 const_iterator cend() const
587 {
588 return const_iterator(base_t::cend());
589 }
590
591 //*********************************************************************
594 //*********************************************************************
595 reverse_iterator rbegin()
596 {
597 return reverse_iterator(iterator(base_t::end()));
598 }
599
600 //*********************************************************************
603 //*********************************************************************
604 const_reverse_iterator rbegin() const
605 {
606 return const_reverse_iterator(const_iterator(base_t::end()));
607 }
608
609 //*********************************************************************
612 //*********************************************************************
613 reverse_iterator rend()
614 {
615 return reverse_iterator(iterator(base_t::begin()));
616 }
617
618 //*********************************************************************
621 //*********************************************************************
622 const_reverse_iterator rend() const
623 {
624 return const_reverse_iterator(const_iterator(base_t::begin()));
625 }
626
627 //*********************************************************************
630 //*********************************************************************
631 const_reverse_iterator crbegin() const
632 {
633 return const_reverse_iterator(const_iterator(base_t::cend()));
634 }
635
636 //*********************************************************************
639 //*********************************************************************
640 const_reverse_iterator crend() const
641 {
642 return const_reverse_iterator(const_iterator(base_t::cbegin()));
643 }
644
645 //*********************************************************************
650 //*********************************************************************
651 void resize(size_t new_size)
652 {
653 base_t::resize(new_size);
654 }
655
656 //*********************************************************************
662 //*********************************************************************
663 void resize(size_t new_size, value_type value)
664 {
665 base_t::resize(new_size, const_cast<T*>(value));
666 }
667
668 //*********************************************************************
671 //*********************************************************************
673 {
674 base_t::uninitialized_resize(new_size);
675 }
676
677 //*********************************************************************
681 //*********************************************************************
683 {
684 return reference(base_t::operator[](i));
685 }
686
687 //*********************************************************************
691 //*********************************************************************
693 {
694 return const_reference(base_t::operator[](i));
695 }
696
697 //*********************************************************************
702 //*********************************************************************
703 reference at(size_t i)
704 {
705 return reference(base_t::at(i));
706 }
707
708 //*********************************************************************
713 //*********************************************************************
714 const_reference at(size_t i) const
715 {
716 return const_reference(base_t::at(i));
717 }
718
719 //*********************************************************************
722 //*********************************************************************
724 {
725 return reference(base_t::front());
726 }
727
728 //*********************************************************************
731 //*********************************************************************
733 {
734 return const_reference(base_t::front());
735 }
736
737 //*********************************************************************
740 //*********************************************************************
742 {
743 return reference(base_t::back());
744 }
745
746 //*********************************************************************
749 //*********************************************************************
751 {
752 return const_reference(base_t::back());
753 }
754
755 //*********************************************************************
758 //*********************************************************************
760 {
761 return pointer(base_t::data());
762 }
763
764 //*********************************************************************
767 //*********************************************************************
769 {
770 return const_pointer(base_t::data());
771 }
772
773 //*********************************************************************
779 //*********************************************************************
780 template <typename TIterator>
781 void assign(TIterator first, TIterator last)
782 {
783 base_t::assign(first, last);
784 }
785
786 //*********************************************************************
791 //*********************************************************************
792 void assign(size_t n, parameter_t value)
793 {
794 base_t::assign(n, const_cast<T*>(value));
795 }
796
797 //*************************************************************************
799 //*************************************************************************
800 void clear()
801 {
802 base_t::clear();
803 }
804
805 //*********************************************************************
809 //*********************************************************************
810 void push_back(parameter_t value)
811 {
812 base_t::push_back(const_cast<T*>(value));
813 }
814
815 //*************************************************************************
818 //*************************************************************************
819 void pop_back()
820 {
821 base_t::pop_back();
822 }
823
824 //*********************************************************************
829 //*********************************************************************
830 iterator insert(const_iterator position, parameter_t value)
831 {
832 return iterator(base_t::insert(base_t::iterator(position), const_cast<T*>(value)));
833 }
834
835 //*********************************************************************
841 //*********************************************************************
842 void insert(const_iterator position, size_t n, parameter_t value)
843 {
844 base_t::insert(base_t::iterator(position), n, const_cast<T*>(value));
845 }
846
847 //*********************************************************************
853 //*********************************************************************
854 template <class TIterator>
855 void insert(const_iterator position, TIterator first, TIterator last)
856 {
857 base_t::insert(base_t::iterator(position), first, last);
858 }
859
860 //*********************************************************************
864 //*********************************************************************
865 iterator erase(iterator i_element)
866 {
867 return iterator(base_t::erase(base_t::iterator(i_element)));
868 }
869
870 //*********************************************************************
874 //*********************************************************************
875 iterator erase(const_iterator i_element)
876 {
877 return iterator(base_t::erase(base_t::iterator(i_element)));
878 }
879
880 //*********************************************************************
887 //*********************************************************************
888 iterator erase(const_iterator first, const_iterator last)
889 {
890 return iterator(base_t::erase(base_t::iterator(first), base_t::iterator(last)));
891 }
892
893 //*************************************************************************
895 //*************************************************************************
897 {
898 base_t::operator = (rhs);
899
900 return *this;
901 }
902
903#if ETL_USING_CPP11
904 //*************************************************************************
906 //*************************************************************************
908 {
909 (void)base_t::operator = (etl::move(rhs));
910
911 return *this;
912 }
913#endif
914
915#ifdef ETL_IVECTOR_REPAIR_ENABLE
916 //*************************************************************************
918 //*************************************************************************
919 virtual void repair() = 0;
920#endif
921
922 protected:
923
924 //*********************************************************************
926 //*********************************************************************
931 };
932
933 //***************************************************************************
939 //***************************************************************************
940 template <typename T>
942 {
943 return pvoidvector_equal(lhs, rhs);
944 }
945
946 //***************************************************************************
952 //***************************************************************************
953 template <typename T>
955 {
956 return pvoidvector_not_equal(lhs, rhs);
957 }
958
959 //***************************************************************************
965 //***************************************************************************
966 template <typename T>
968 {
969 return pvoidvector_less_than(lhs, rhs);
970 }
971
972 //***************************************************************************
978 //***************************************************************************
979 template <typename T>
981 {
982 return pvoidvector_greater_than(lhs, rhs);
983 }
984
985 //***************************************************************************
991 //***************************************************************************
992 template <typename T>
994 {
995 return pvoidvector_less_than_equal(lhs, rhs);
996 }
997
998 //***************************************************************************
1004 //***************************************************************************
1005 template <typename T>
1007 {
1008 return pvoidvector_greater_than_equal(lhs, rhs);
1009 }
1010
1011 //***************************************************************************
1012 // Helper functions
1013 //***************************************************************************
1014 inline bool pvoidvector_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1015 {
1016 return operator ==(lhs, rhs);
1017 }
1018
1019 inline bool pvoidvector_not_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1020 {
1021 return operator !=(lhs, rhs);
1022 }
1023
1024 inline bool pvoidvector_less_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1025 {
1026 return operator <(lhs, rhs);
1027 }
1028
1029 inline bool pvoidvector_greater_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1030 {
1031 return operator >(lhs, rhs);
1032 }
1033
1034 inline bool pvoidvector_less_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1035 {
1036 return operator <=(lhs, rhs);
1037 }
1038
1039 inline bool pvoidvector_greater_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
1040 {
1041 return operator >=(lhs, rhs);
1042 }
1043}
1044
1045#endif
const_reference front() const
Definition ivectorpointer.h:732
const_reverse_iterator rbegin() const
Definition ivectorpointer.h:604
void resize(size_t new_size, value_type value)
Definition ivectorpointer.h:663
reference front()
Definition ivectorpointer.h:723
void resize(size_t new_size)
Definition ivectorpointer.h:651
void insert(const_iterator position, TIterator first, TIterator last)
Definition ivectorpointer.h:855
const_reference back() const
Definition ivectorpointer.h:750
iterator erase(iterator i_element)
Definition ivectorpointer.h:865
iterator insert(const_iterator position, parameter_t value)
Definition ivectorpointer.h:830
reverse_iterator rbegin()
Definition ivectorpointer.h:595
ivector(const T **p_buffer_, size_t MAX_SIZE_)
Constructor.
Definition ivectorpointer.h:927
void uninitialized_resize(size_t new_size)
Definition ivectorpointer.h:672
const_iterator cbegin() const
Definition ivectorpointer.h:577
iterator erase(const_iterator first, const_iterator last)
Definition ivectorpointer.h:888
pointer data()
Definition ivectorpointer.h:759
void push_back(parameter_t value)
Definition ivectorpointer.h:810
reference at(size_t i)
Definition ivectorpointer.h:703
iterator erase(const_iterator i_element)
Definition ivectorpointer.h:875
const_iterator cend() const
Definition ivectorpointer.h:586
const_pointer data() const
Definition ivectorpointer.h:768
iterator end()
Definition ivectorpointer.h:559
reference back()
Definition ivectorpointer.h:741
void insert(const_iterator position, size_t n, parameter_t value)
Definition ivectorpointer.h:842
const_reverse_iterator crbegin() const
Definition ivectorpointer.h:631
const_reverse_iterator crend() const
Definition ivectorpointer.h:640
const_reference at(size_t i) const
Definition ivectorpointer.h:714
void pop_back()
Definition ivectorpointer.h:819
void assign(TIterator first, TIterator last)
Definition ivectorpointer.h:781
void clear()
Clears the vector.
Definition ivectorpointer.h:800
const_iterator end() const
Definition ivectorpointer.h:568
const_reverse_iterator rend() const
Definition ivectorpointer.h:622
void assign(size_t n, parameter_t value)
Definition ivectorpointer.h:792
reverse_iterator rend()
Definition ivectorpointer.h:613
const_iterator begin() const
Definition ivectorpointer.h:550
iterator begin()
Definition ivectorpointer.h:541
reference front()
Definition ivectorpointer.h:260
reverse_iterator rend()
Definition ivectorpointer.h:150
const_reverse_iterator rbegin() const
Definition ivectorpointer.h:141
void assign(TIterator first, TIterator last)
Definition ivectorpointer.h:318
void push_back(parameter_t value)
Definition ivectorpointer.h:347
const_iterator begin() const
Definition ivectorpointer.h:87
const_iterator cbegin() const
Definition ivectorpointer.h:114
void insert(const_iterator position, TIterator first, TIterator last)
Definition ivectorpointer.h:432
void pop_back()
Definition ivectorpointer.h:380
const_reference front() const
Definition ivectorpointer.h:269
void assign(size_t n, parameter_t value)
Definition ivectorpointer.h:329
reference back()
Definition ivectorpointer.h:278
const_reference at(size_t i) const
Definition ivectorpointer.h:251
const_reverse_iterator crend() const
Definition ivectorpointer.h:177
iterator emplace(const_iterator position, parameter_t value)
Emplaces a value to the vector at the specified position.
Definition ivectorpointer.h:407
const_reference back() const
Definition ivectorpointer.h:287
void resize(size_t new_size, value_type value)
Definition ivectorpointer.h:200
const_reverse_iterator rend() const
Definition ivectorpointer.h:159
const_iterator end() const
Definition ivectorpointer.h:105
const_iterator cend() const
Definition ivectorpointer.h:123
void uninitialized_resize(size_t new_size)
Definition ivectorpointer.h:209
reverse_iterator rbegin()
Definition ivectorpointer.h:132
reference at(size_t i)
Definition ivectorpointer.h:240
void insert(const_iterator position, size_t n, parameter_t value)
Definition ivectorpointer.h:419
iterator erase(iterator i_element)
Definition ivectorpointer.h:442
iterator erase(const_iterator i_element)
Definition ivectorpointer.h:452
iterator end()
Definition ivectorpointer.h:96
reference emplace_back()
Definition ivectorpointer.h:357
ivector(T **p_buffer_, size_t MAX_SIZE_)
Constructor.
Definition ivectorpointer.h:504
const_reverse_iterator crbegin() const
Definition ivectorpointer.h:168
iterator emplace(const_iterator position)
Emplaces a value to the vector at the specified position.
Definition ivectorpointer.h:399
iterator begin()
Definition ivectorpointer.h:78
iterator insert(const_iterator position, parameter_t value)
Definition ivectorpointer.h:391
pointer data()
Definition ivectorpointer.h:296
reference emplace_back(parameter_t value)
Definition ivectorpointer.h:369
const_pointer data() const
Definition ivectorpointer.h:305
iterator erase(const_iterator first, const_iterator last)
Definition ivectorpointer.h:465
void clear()
Clears the vector.
Definition ivectorpointer.h:337
void resize(size_t new_size)
Definition ivectorpointer.h:188
Definition vector.h:72
Definition pvoidvector.h:55
bitset_ext
Definition absolute.h:38
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:693
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:705
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:654
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:642
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
pair holds two objects of arbitrary type
Definition utility.h:164