Embedded Template Library  1.0
vector.h
Go to the documentation of this file.
1 
3 /******************************************************************************
4 The MIT License(MIT)
5 
6 Embedded Template Library.
7 https://github.com/ETLCPP/etl
8 https://www.etlcpp.com
9 
10 Copyright(c) 2014 jwellbelove
11 
12 Permission is hereby granted, free of charge, to any person obtaining a copy
13 of this software and associated documentation files(the "Software"), to deal
14 in the Software without restriction, including without limitation the rights
15 to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16 copies of the Software, and to permit persons to whom the Software is
17 furnished to do so, subject to the following conditions :
18 
19 The above copyright notice and this permission notice shall be included in all
20 copies or substantial portions of the Software.
21 
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 SOFTWARE.
29 ******************************************************************************/
30 
31 #ifndef ETL_VECTOR_INCLUDED
32 #define ETL_VECTOR_INCLUDED
33 
34 #define ETL_IN_VECTOR_H
35 
36 #include <stddef.h>
37 #include <stdint.h>
38 #include <stddef.h>
39 
40 #include "platform.h"
41 #include "algorithm.h"
42 #include "type_traits.h"
43 #include "error_handler.h"
44 #include "memory.h"
45 #include "container.h"
46 #include "alignment.h"
47 #include "array.h"
48 #include "exception.h"
49 #include "debug_count.h"
50 #include "private/vector_base.h"
51 #include "iterator.h"
52 #include "functional.h"
53 #include "static_assert.h"
54 #include "placement_new.h"
55 
56 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
57  #include <initializer_list>
58 #endif
59 
60 #ifdef ETL_COMPILER_GCC
61 #pragma GCC diagnostic push
62 #pragma GCC diagnostic ignored "-Wunused-variable"
63 #endif
64 
65 //*****************************************************************************
69 //*****************************************************************************
70 
71 namespace etl
72 {
73  //***************************************************************************
77  //***************************************************************************
78  template <typename T>
79  class ivector : public etl::vector_base
80  {
81  public:
82 
83  typedef T value_type;
84  typedef T& reference;
85  typedef const T& const_reference;
86 #if ETL_CPP11_SUPPORTED
87  typedef T&& rvalue_reference;
88 #endif
89  typedef T* pointer;
90  typedef const T* const_pointer;
91  typedef T* iterator;
92  typedef const T* const_iterator;
93  typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
94  typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
95  typedef size_t size_type;
96  typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
97 
98  protected:
99 
100  typedef typename etl::parameter_type<T>::type parameter_t;
101 
102  public:
103 
104  //*********************************************************************
107  //*********************************************************************
108  iterator begin()
109  {
110  return p_buffer;
111  }
112 
113  //*********************************************************************
116  //*********************************************************************
117  const_iterator begin() const
118  {
119  return p_buffer;
120  }
121 
122  //*********************************************************************
125  //*********************************************************************
126  iterator end()
127  {
128  return p_end;
129  }
130 
131  //*********************************************************************
134  //*********************************************************************
135  const_iterator end() const
136  {
137  return p_end;
138  }
139 
140  //*********************************************************************
143  //*********************************************************************
144  const_iterator cbegin() const
145  {
146  return p_buffer;
147  }
148 
149  //*********************************************************************
152  //*********************************************************************
153  const_iterator cend() const
154  {
155  return p_end;
156  }
157 
158  //*********************************************************************
161  //*********************************************************************
162  reverse_iterator rbegin()
163  {
164  return reverse_iterator(end());
165  }
166 
167  //*********************************************************************
170  //*********************************************************************
171  const_reverse_iterator rbegin() const
172  {
173  return const_reverse_iterator(end());
174  }
175 
176  //*********************************************************************
179  //*********************************************************************
180  reverse_iterator rend()
181  {
182  return reverse_iterator(begin());
183  }
184 
185  //*********************************************************************
188  //*********************************************************************
189  const_reverse_iterator rend() const
190  {
191  return const_reverse_iterator(begin());
192  }
193 
194  //*********************************************************************
197  //*********************************************************************
198  const_reverse_iterator crbegin() const
199  {
200  return const_reverse_iterator(cend());
201  }
202 
203  //*********************************************************************
206  //*********************************************************************
207  const_reverse_iterator crend() const
208  {
209  return const_reverse_iterator(cbegin());
210  }
211 
212  //*********************************************************************
217  //*********************************************************************
218  void resize(size_t new_size)
219  {
220  resize(new_size, T());
221  }
222 
223  //*********************************************************************
229  //*********************************************************************
230  void resize(size_t new_size, T value)
231  {
232  ETL_ASSERT(new_size <= CAPACITY, ETL_ERROR(vector_full));
233 
234  const size_t current_size = size();
235  size_t delta = (current_size < new_size) ? new_size - current_size : current_size - new_size;
236 
237  if (current_size < new_size)
238  {
239  etl::uninitialized_fill_n(p_end, delta, value);
240  ETL_ADD_DEBUG_COUNT(delta)
241  }
242  else
243  {
244  etl::destroy_n(p_end - delta, delta);
245  ETL_SUBTRACT_DEBUG_COUNT(delta)
246  }
247 
248  p_end = p_buffer + new_size;
249  }
250 
251  //*********************************************************************
253  //*********************************************************************
254  void reserve(size_t)
255  {
256  }
257 
258  //*********************************************************************
262  //*********************************************************************
263  reference operator [](size_t i)
264  {
265  return p_buffer[i];
266  }
267 
268  //*********************************************************************
272  //*********************************************************************
273  const_reference operator [](size_t i) const
274  {
275  return p_buffer[i];
276  }
277 
278  //*********************************************************************
283  //*********************************************************************
284  reference at(size_t i)
285  {
286  ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
287  return p_buffer[i];
288  }
289 
290  //*********************************************************************
295  //*********************************************************************
296  const_reference at(size_t i) const
297  {
298  ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
299  return p_buffer[i];
300  }
301 
302  //*********************************************************************
305  //*********************************************************************
306  reference front()
307  {
308  return *p_buffer;
309  }
310 
311  //*********************************************************************
314  //*********************************************************************
315  const_reference front() const
316  {
317  return *p_buffer;
318  }
319 
320  //*********************************************************************
323  //*********************************************************************
324  reference back()
325  {
326  return *(p_end - 1);
327  }
328 
329  //*********************************************************************
332  //*********************************************************************
333  const_reference back() const
334  {
335  return *(p_end - 1);
336  }
337 
338  //*********************************************************************
341  //*********************************************************************
342  pointer data()
343  {
344  return p_buffer;
345  }
346 
347  //*********************************************************************
350  //*********************************************************************
351  const_pointer data() const
352  {
353  return p_buffer;
354  }
355 
356  //*********************************************************************
362  //*********************************************************************
363  template <typename TIterator>
364  void assign(TIterator first, TIterator last)
365  {
366  ETL_STATIC_ASSERT((etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<typename etl::iterator_traits<TIterator>::value_type>::type>::value), "Iterator type does not match container type");
367 
368 #if defined(ETL_DEBUG)
369  difference_type d = etl::distance(first, last);
370  ETL_ASSERT(static_cast<size_t>(d) <= CAPACITY, ETL_ERROR(vector_full));
371 #endif
372 
373  initialise();
374 
375  p_end = etl::uninitialized_copy(first, last, p_buffer);
376  ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last)))
377  }
378 
379  //*********************************************************************
384  //*********************************************************************
385  void assign(size_t n, parameter_t value)
386  {
387  ETL_ASSERT(n <= CAPACITY, ETL_ERROR(vector_full));
388 
389  initialise();
390 
392  ETL_ADD_DEBUG_COUNT(uint32_t(n))
393  }
394 
395  //*************************************************************************
397  //*************************************************************************
398  void clear()
399  {
400  initialise();
401  }
402 
403  //*********************************************************************
407  //*********************************************************************
408  void push_back(const_reference value)
409  {
410 #if defined(ETL_CHECK_PUSH_POP)
411  ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
412 #endif
413  create_back(value);
414  }
415 
416 #if ETL_CPP11_SUPPORTED
417  //*********************************************************************
421  //*********************************************************************
422  void push_back(rvalue_reference value)
423  {
424 #if defined(ETL_CHECK_PUSH_POP)
425  ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
426 #endif
427  create_back(etl::move(value));
428  }
429 #endif
430 
431 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && !defined(ETL_VECTOR_FORCE_CPP03)
432  //*********************************************************************
436  //*********************************************************************
437  template <typename ... Args>
438  void emplace_back(Args && ... args)
439  {
440 #if defined(ETL_CHECK_PUSH_POP)
441  ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
442 #endif
443  ::new (p_end) T(etl::forward<Args>(args)...);
444  ++p_end;
445  ETL_INCREMENT_DEBUG_COUNT
446  }
447 #else
448  //*********************************************************************
452  //*********************************************************************
453  template <typename T1>
454  void emplace_back(const T1& value1)
455  {
456 #if defined(ETL_CHECK_PUSH_POP)
457  ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
458 #endif
459  ::new (p_end) T(value1);
460  ++p_end;
461  ETL_INCREMENT_DEBUG_COUNT
462  }
463 
464  //*********************************************************************
468  //*********************************************************************
469  template <typename T1, typename T2>
470  void emplace_back(const T1& value1, const T2& value2)
471  {
472 #if defined(ETL_CHECK_PUSH_POP)
473  ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
474 #endif
475  ::new (p_end) T(value1, value2);
476  ++p_end;
477  ETL_INCREMENT_DEBUG_COUNT
478  }
479 
480  //*********************************************************************
484  //*********************************************************************
485  template <typename T1, typename T2, typename T3>
486  void emplace_back(const T1& value1, const T2& value2, const T3& value3)
487  {
488 #if defined(ETL_CHECK_PUSH_POP)
489  ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
490 #endif
491  ::new (p_end) T(value1, value2, value3);
492  ++p_end;
493  ETL_INCREMENT_DEBUG_COUNT
494  }
495 
496  //*********************************************************************
500  //*********************************************************************
501  template <typename T1, typename T2, typename T3, typename T4>
502  void emplace_back(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
503  {
504 #if defined(ETL_CHECK_PUSH_POP)
505  ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
506 #endif
507  ::new (p_end) T(value1, value2, value3, value4);
508  ++p_end;
509  ETL_INCREMENT_DEBUG_COUNT
510  }
511 #endif
512 
513  //*************************************************************************
516  //*************************************************************************
517  void pop_back()
518  {
519 #if defined(ETL_CHECK_PUSH_POP)
520  ETL_ASSERT(size() > 0, ETL_ERROR(vector_empty));
521 #endif
522  destroy_back();
523  }
524 
525  //*********************************************************************
530  //*********************************************************************
531  iterator insert(iterator position, const_reference value)
532  {
533  ETL_ASSERT(size() + 1 <= CAPACITY, ETL_ERROR(vector_full));
534 
535  if (position == end())
536  {
537  create_back(value);
538  }
539  else
540  {
541  create_back(back());
542  etl::move_backward(position, p_end - 2, p_end - 1);
543  *position = value;
544  }
545 
546  return position;
547  }
548 
549 #if ETL_CPP11_SUPPORTED
550  //*********************************************************************
555  //*********************************************************************
556  iterator insert(iterator position, rvalue_reference value)
557  {
558  ETL_ASSERT(size() + 1 <= CAPACITY, ETL_ERROR(vector_full));
559 
560  if (position == end())
561  {
562  create_back(etl::move(value));
563  }
564  else
565  {
566  create_back(etl::move(back()));
567  etl::move_backward(position, p_end - 2, p_end - 1);
568  *position = etl::move(value);
569  }
570 
571  return position;
572  }
573 #endif
574 
575  //*************************************************************************
577  //*************************************************************************
578 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT
579  template <typename ... Args>
580  iterator emplace(iterator position, Args && ... args)
581  {
582  ETL_ASSERT(!full(), ETL_ERROR(vector_full));
583 
584  void* p;
585 
586  if (position == end())
587  {
588  p = p_end++;
589  ETL_INCREMENT_DEBUG_COUNT
590  }
591  else
592  {
593  p = etl::addressof(*position);
594  create_back(back());
595  etl::move_backward(position, p_end - 2, p_end - 1);
596  (*position).~T();
597  }
598 
599  ::new (p) T(etl::forward<Args>(args)...);
600 
601  return position;
602  }
603 #else
604  template <typename T1>
605  iterator emplace(iterator position, const T1& value1)
606  {
607  ETL_ASSERT(!full(), ETL_ERROR(vector_full));
608 
609  void* p;
610 
611  if (position == end())
612  {
613  p = p_end++;
614  ETL_INCREMENT_DEBUG_COUNT
615  }
616  else
617  {
618  p = etl::addressof(*position);
619  create_back(back());
620  etl::move_backward(position, p_end - 2, p_end - 1);
621  (*position).~T();
622  }
623 
624  ::new (p) T(value1);
625 
626  return position;
627  }
628 
629  template <typename T1, typename T2>
630  iterator emplace(iterator position, const T1& value1, const T2& value2)
631  {
632  ETL_ASSERT(!full(), ETL_ERROR(vector_full));
633 
634  void* p;
635 
636  if (position == end())
637  {
638  p = p_end++;
639  ETL_INCREMENT_DEBUG_COUNT
640  }
641  else
642  {
643  p = etl::addressof(*position);
644  create_back(back());
645  etl::move_backward(position, p_end - 2, p_end - 1);
646  (*position).~T();
647  }
648 
649  ::new (p) T(value1, value2);
650 
651  return position;
652  }
653 
654  template <typename T1, typename T2, typename T3>
655  iterator emplace(iterator position, const T1& value1, const T2& value2, const T3& value3)
656  {
657  ETL_ASSERT(!full(), ETL_ERROR(vector_full));
658 
659  void* p;
660 
661  if (position == end())
662  {
663  p = p_end++;
664  ETL_INCREMENT_DEBUG_COUNT
665  }
666  else
667  {
668  p = etl::addressof(*position);
669  create_back(back());
670  etl::move_backward(position, p_end - 2, p_end - 1);
671  (*position).~T();
672  }
673 
674  ::new (p) T(value1, value2, value3);
675 
676  return position;
677  }
678 
679  template <typename T1, typename T2, typename T3, typename T4>
680  iterator emplace(iterator position, const T1& value1, const T2& value2, const T3& value3, const T4& value4)
681  {
682  ETL_ASSERT(!full(), ETL_ERROR(vector_full));
683 
684  void* p;
685 
686  if (position == end())
687  {
688  p = p_end++;
689  ETL_INCREMENT_DEBUG_COUNT
690  }
691  else
692  {
693  p = etl::addressof(*position);
694  create_back(back());
695  etl::move_backward(position, p_end - 2, p_end - 1);
696  (*position).~T();
697  }
698 
699  ::new (p) T(value1, value2, value3, value4);
700 
701  return position;
702  }
703 #endif
704 
705  //*********************************************************************
711  //*********************************************************************
712  void insert(iterator position, size_t n, parameter_t value)
713  {
714  ETL_ASSERT((size() + n) <= CAPACITY, ETL_ERROR(vector_full));
715 
716  size_t insert_n = n;
717  size_t insert_begin = etl::distance(begin(), position);
718  size_t insert_end = insert_begin + insert_n;
719 
720  // Copy old data.
721  size_t copy_old_n;
722  size_t construct_old_n;
723  iterator p_construct_old;
724 
725  if (insert_end > size())
726  {
727  copy_old_n = 0;
728  construct_old_n = size() - insert_begin;
729  p_construct_old = p_buffer + insert_end;
730  }
731  else
732  {
733  copy_old_n = size() - insert_begin - insert_n;
734  construct_old_n = insert_n;
735  p_construct_old = p_end;
736  }
737 
738  size_t copy_new_n = construct_old_n;
739  size_t construct_new_n = insert_n - copy_new_n;
740 
741  // Construct old.
742  etl::uninitialized_move(p_end - construct_old_n, p_end, p_construct_old);
743  ETL_ADD_DEBUG_COUNT(construct_old_n)
744 
745  // Copy old.
746  etl::move_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n);
747 
748  // Construct new.
749  etl::uninitialized_fill_n(p_end, construct_new_n, value);
750  ETL_ADD_DEBUG_COUNT(construct_new_n)
751 
752  // Copy new.
753  etl::fill_n(p_buffer + insert_begin, copy_new_n, value);
754 
755  p_end += n;
756  }
757 
758  //*********************************************************************
765  //*********************************************************************
766  template <class TIterator>
767  void insert(iterator position, TIterator first, TIterator last)
768  {
769  size_t count = etl::distance(first, last);
770 
771  ETL_ASSERT((size() + count) <= CAPACITY, ETL_ERROR(vector_full));
772 
773  size_t insert_n = count;
774  size_t insert_begin = etl::distance(begin(), position);
775  size_t insert_end = insert_begin + insert_n;
776 
777  // Move old data.
778  size_t copy_old_n;
779  size_t construct_old_n;
780  iterator p_construct_old;
781 
782  if (insert_end > size())
783  {
784  copy_old_n = 0;
785  construct_old_n = size() - insert_begin;
786  p_construct_old = p_buffer + insert_end;
787  }
788  else
789  {
790  copy_old_n = size() - insert_begin - insert_n;
791  construct_old_n = insert_n;
792  p_construct_old = p_end;
793  }
794 
795  size_t copy_new_n = construct_old_n;
796  size_t construct_new_n = insert_n - copy_new_n;
797 
798  // Move construct old.
799  etl::uninitialized_move(p_end - construct_old_n, p_end, p_construct_old);
800  ETL_ADD_DEBUG_COUNT(construct_old_n)
801 
802  // Move old.
803  etl::move_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n);
804 
805  // Copy construct new.
806  etl::uninitialized_copy(first + copy_new_n, first + copy_new_n + construct_new_n, p_end);
807  ETL_ADD_DEBUG_COUNT(construct_new_n)
808 
809  // Copy new.
810  etl::copy(first, first + copy_new_n, p_buffer + insert_begin);
811 
812  p_end += count;
813  }
814 
815  //*********************************************************************
819  //*********************************************************************
820  iterator erase(iterator i_element)
821  {
822  etl::move(i_element + 1, end(), i_element);
823  destroy_back();
824 
825  return i_element;
826  }
827 
828  //*********************************************************************
835  //*********************************************************************
836  iterator erase(iterator first, iterator last)
837  {
838  if (first == begin() && last == end())
839  {
840  clear();
841  }
842  else
843  {
844  etl::move(last, end(), first);
845  size_t n_delete = etl::distance(first, last);
846 
847  // Destroy the elements left over at the end.
848  etl::destroy(p_end - n_delete, p_end);
849  ETL_SUBTRACT_DEBUG_COUNT(n_delete)
850  p_end -= n_delete;
851  }
852 
853  return first;
854  }
855 
856  //*************************************************************************
858  //*************************************************************************
860  {
861  if (&rhs != this)
862  {
863  assign(rhs.cbegin(), rhs.cend());
864  }
865 
866  return *this;
867  }
868 
869 #if ETL_CPP11_SUPPORTED
870  //*************************************************************************
872  //*************************************************************************
873  ivector& operator = (ivector&& rhs)
874  {
875  if (&rhs != this)
876  {
877  clear();
878  iterator itr = rhs.begin();
879  while (itr != rhs.end())
880  {
881  push_back(etl::move(*itr));
882  ++itr;
883  }
884 
885  rhs.initialise();
886  }
887 
888  return *this;
889  }
890 #endif
891 
892  //*************************************************************************
895  //*************************************************************************
896  size_type size() const
897  {
898  return size_t(p_end - p_buffer);
899  }
900 
901  //*************************************************************************
904  //*************************************************************************
905  bool empty() const
906  {
907  return (p_end == p_buffer);
908  }
909 
910  //*************************************************************************
913  //*************************************************************************
914  bool full() const
915  {
916  return size() == CAPACITY;
917  }
918 
919  //*************************************************************************
922  //*************************************************************************
923  size_t available() const
924  {
925  return max_size() - size();
926  }
927 
928 #ifdef ETL_IVECTOR_REPAIR_ENABLE
929  //*************************************************************************
931  //*************************************************************************
932  virtual void repair() = 0;
933 #endif
934 
935  protected:
936 
937  //*********************************************************************
939  //*********************************************************************
940  ivector(T* p_buffer_, size_t MAX_SIZE)
941  : vector_base(MAX_SIZE)
942  , p_buffer(p_buffer_)
943  , p_end(p_buffer_)
944  {
945  }
946 
947  //*********************************************************************
949  //*********************************************************************
950  void initialise()
951  {
953  ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end)))
954 
955  p_end = p_buffer;
956  }
957 
958  //*************************************************************************
960  //*************************************************************************
961  void repair_buffer(T* p_buffer_)
962  {
963  uintptr_t length = p_end - p_buffer;
964  p_buffer = p_buffer_;
965  p_end = p_buffer_ + length;
966  }
967 
968  pointer p_buffer;
969  pointer p_end;
970 
971  private:
972 
973  //*********************************************************************
975  //*********************************************************************
976  inline void create_back()
977  {
979  ETL_INCREMENT_DEBUG_COUNT
980 
981  ++p_end;
982  }
983 
984  //*********************************************************************
986  //*********************************************************************
987  inline void create_back(const_reference value)
988  {
989  etl::create_copy_at(p_end, value);
990  ETL_INCREMENT_DEBUG_COUNT
991 
992  ++p_end;
993  }
994 
995 #if ETL_CPP11_SUPPORTED
996  //*********************************************************************
998  //*********************************************************************
999  inline void create_back(rvalue_reference value)
1000  {
1001  etl::create_copy_at(p_end, etl::move(value));
1002  ETL_INCREMENT_DEBUG_COUNT
1003 
1004  ++p_end;
1005  }
1006 #endif
1007 
1008  //*********************************************************************
1010  //*********************************************************************
1011  inline void destroy_back()
1012  {
1013  --p_end;
1014 
1016  ETL_DECREMENT_DEBUG_COUNT
1017  }
1018 
1019  // Disable copy construction.
1020  ivector(const ivector&);
1021 
1022  //*************************************************************************
1024  //*************************************************************************
1025 #if defined(ETL_POLYMORPHIC_VECTOR) || defined(ETL_POLYMORPHIC_CONTAINERS)
1026  public:
1027  virtual ~ivector()
1028  {
1029  }
1030 #else
1031  protected:
1033  {
1034  }
1035 #endif
1036  };
1037 
1038  //***************************************************************************
1044  //***************************************************************************
1045  template <typename T>
1046  bool operator ==(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1047  {
1048  return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
1049  }
1050 
1051  //***************************************************************************
1057  //***************************************************************************
1058  template <typename T>
1059  bool operator !=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1060  {
1061  return !(lhs == rhs);
1062  }
1063 
1064  //***************************************************************************
1070  //***************************************************************************
1071  template <typename T>
1072  bool operator <(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1073  {
1074  return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
1075  }
1076 
1077  //***************************************************************************
1083  //***************************************************************************
1084  template <typename T>
1085  bool operator >(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1086  {
1087  return (rhs < lhs);
1088  }
1089 
1090  //***************************************************************************
1096  //***************************************************************************
1097  template <typename T>
1098  bool operator <=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1099  {
1100  return !(lhs > rhs);
1101  }
1102 
1103  //***************************************************************************
1109  //***************************************************************************
1110  template <typename T>
1111  bool operator >=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
1112  {
1113  return !(lhs < rhs);
1114  }
1115 }
1116 
1117 #include "private/ivectorpointer.h"
1118 
1119 namespace etl
1120 {
1121  //***************************************************************************
1126  //***************************************************************************
1127  template <typename T, const size_t MAX_SIZE_>
1128  class vector : public etl::ivector<T>
1129  {
1130  public:
1131 
1132  ETL_STATIC_ASSERT((MAX_SIZE_ > 0U), "Zero capacity etl::vector is not valid");
1133 
1134  static const size_t MAX_SIZE = MAX_SIZE_;
1135 
1136  //*************************************************************************
1138  //*************************************************************************
1140  : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1141  {
1142  this->initialise();
1143  }
1144 
1145  //*************************************************************************
1148  //*************************************************************************
1149  explicit vector(size_t initial_size)
1150  : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1151  {
1152  this->initialise();
1153  this->resize(initial_size);
1154  }
1155 
1156  //*************************************************************************
1160  //*************************************************************************
1161  vector(size_t initial_size, typename etl::ivector<T>::parameter_t value)
1162  : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1163  {
1164  this->initialise();
1165  this->resize(initial_size, value);
1166  }
1167 
1168  //*************************************************************************
1173  //*************************************************************************
1174  template <typename TIterator>
1175  vector(TIterator first, TIterator last)
1176  : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1177  {
1178  this->assign(first, last);
1179  }
1180 
1181 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1182  //*************************************************************************
1184  //*************************************************************************
1185  vector(std::initializer_list<T> init)
1186  : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1187  {
1188  this->assign(init.begin(), init.end());
1189  }
1190 #endif
1191 
1192  //*************************************************************************
1194  //*************************************************************************
1195  vector(const vector& other)
1196  : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1197  {
1198  this->assign(other.begin(), other.end());
1199  }
1200 
1201  //*************************************************************************
1203  //*************************************************************************
1205  {
1206  if (&rhs != this)
1207  {
1208  this->assign(rhs.cbegin(), rhs.cend());
1209  }
1210 
1211  return *this;
1212  }
1213 
1214 #if ETL_CPP11_SUPPORTED
1215  //*************************************************************************
1217  //*************************************************************************
1218  vector(vector&& other)
1219  : etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
1220  {
1221  if (this != &other)
1222  {
1223  this->initialise();
1224 
1225  typename etl::ivector<T>::iterator itr = other.begin();
1226  while (itr != other.end())
1227  {
1228  this->push_back(etl::move(*itr));
1229  ++itr;
1230  }
1231 
1232  other.initialise();
1233  }
1234  }
1235 
1236  //*************************************************************************
1238  //*************************************************************************
1239  vector& operator = (vector&& rhs)
1240  {
1241  if (&rhs != this)
1242  {
1243  this->clear();
1244  typename etl::ivector<T>::iterator itr = rhs.begin();
1245  while (itr != rhs.end())
1246  {
1247  this->push_back(etl::move(*itr));
1248  ++itr;
1249  }
1250 
1251  rhs.initialise();
1252  }
1253 
1254  return *this;
1255  }
1256 #endif
1257 
1258  //*************************************************************************
1260  //*************************************************************************
1262  {
1263  this->clear();
1264  }
1265 
1266  //*************************************************************************
1268  //*************************************************************************
1269 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1270  virtual
1271 #endif
1272  void repair()
1273 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1274  ETL_OVERRIDE
1275 #endif
1276  {
1277  #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1279  #endif
1280 
1282  }
1283 
1284  private:
1285 
1286  typename etl::aligned_storage<sizeof(T) * MAX_SIZE, etl::alignment_of<T>::value>::type buffer;
1287  };
1288 
1289  //*************************************************************************
1291  //*************************************************************************
1292 #if ETL_CPP17_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1293  template <typename T, typename... Ts>
1294  vector(T, Ts...)
1295  ->vector<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T>, 1U + sizeof...(Ts)>;
1296 #endif
1297 
1298  //***************************************************************************
1303  //***************************************************************************
1304  template <typename T>
1305  class vector_ext : public etl::ivector<T>
1306  {
1307  public:
1308 
1309  //*************************************************************************
1311  //*************************************************************************
1312  vector_ext(void* buffer, size_t max_size)
1313  : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1314  {
1315  this->initialise();
1316  }
1317 
1318  //*************************************************************************
1321  //*************************************************************************
1322  explicit vector_ext(size_t initial_size, void* buffer, size_t max_size)
1323  : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1324  {
1325  this->initialise();
1326  this->resize(initial_size);
1327  }
1328 
1329  //*************************************************************************
1333  //*************************************************************************
1334  vector_ext(size_t initial_size, typename etl::ivector<T>::parameter_t value, void* buffer, size_t max_size)
1335  : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1336  {
1337  this->initialise();
1338  this->resize(initial_size, value);
1339  }
1340 
1341  //*************************************************************************
1346  //*************************************************************************
1347  template <typename TIterator>
1348  vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size)
1349  : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1350  {
1351  this->assign(first, last);
1352  }
1353 
1354 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1355  //*************************************************************************
1357  //*************************************************************************
1358  vector_ext(std::initializer_list<T> init, void* buffer, size_t max_size)
1359  : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1360  {
1361  this->assign(init.begin(), init.end());
1362  }
1363 #endif
1364 
1365  //*************************************************************************
1367  //*************************************************************************
1368  vector_ext(const vector_ext& other, void* buffer, size_t max_size)
1369  : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1370  {
1371  this->assign(other.begin(), other.end());
1372  }
1373 
1374  //*************************************************************************
1376  //*************************************************************************
1378  {
1379  if (&rhs != this)
1380  {
1381  this->assign(rhs.cbegin(), rhs.cend());
1382  }
1383 
1384  return *this;
1385  }
1386 
1387 #if ETL_CPP11_SUPPORTED
1388  //*************************************************************************
1390  //*************************************************************************
1391  vector_ext(vector_ext&& other, void* buffer, size_t max_size)
1392  : etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
1393  {
1394  if (this != &other)
1395  {
1396  this->initialise();
1397 
1398  typename etl::ivector<T>::iterator itr = other.begin();
1399  while (itr != other.end())
1400  {
1401  this->push_back(etl::move(*itr));
1402  ++itr;
1403  }
1404 
1405  other.initialise();
1406  }
1407  }
1408 
1409  //*************************************************************************
1411  //*************************************************************************
1413  {
1414  if (&rhs != this)
1415  {
1416  this->clear();
1417 
1418  typename etl::ivector<T>::iterator itr = rhs.begin();
1419  while (itr != rhs.end())
1420  {
1421  this->push_back(etl::move(*itr));
1422  ++itr;
1423  }
1424 
1425  rhs.initialise();
1426  }
1427 
1428  return *this;
1429  }
1430 #endif
1431 
1432  //*************************************************************************
1434  //*************************************************************************
1436  {
1437  this->clear();
1438  }
1439 
1440  //*************************************************************************
1442  //*************************************************************************
1443  void repair()
1444 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1445  ETL_OVERRIDE
1446 #endif
1447  {
1448 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1450 #endif
1451 
1453  }
1454  };
1455 
1456  //***************************************************************************
1461  //***************************************************************************
1462  template <typename T, const size_t MAX_SIZE_>
1463  class vector<T*, MAX_SIZE_> : public etl::ivector<T*>
1464  {
1465  public:
1466 
1467  ETL_STATIC_ASSERT((MAX_SIZE_ > 0U), "Zero capacity etl::vector is not valid");
1468 
1469  static const size_t MAX_SIZE = MAX_SIZE_;
1470 
1471  //*************************************************************************
1473  //*************************************************************************
1475  : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1476  {
1477  this->initialise();
1478  }
1479 
1480  //*************************************************************************
1483  //*************************************************************************
1484  explicit vector(size_t initial_size)
1485  : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1486  {
1487  this->initialise();
1488  this->resize(initial_size);
1489  }
1490 
1491  //*************************************************************************
1495  //*************************************************************************
1496  vector(size_t initial_size, typename etl::ivector<T*>::parameter_t value)
1497  : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1498  {
1499  this->initialise();
1500  this->resize(initial_size, value);
1501  }
1502 
1503  //*************************************************************************
1508  //*************************************************************************
1509  template <typename TIterator>
1510  vector(TIterator first, TIterator last)
1511  : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1512  {
1513  this->assign(first, last);
1514  }
1515 
1516 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1517  //*************************************************************************
1519  //*************************************************************************
1520  vector(std::initializer_list<T*> init)
1521  : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1522  {
1523  this->assign(init.begin(), init.end());
1524  }
1525 #endif
1526 
1527  //*************************************************************************
1529  //*************************************************************************
1530  vector(const vector& other)
1531  : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1532  {
1533  (void)etl::ivector<T*>::operator = (other);
1534  }
1535 
1536  //*************************************************************************
1538  //*************************************************************************
1539  vector& operator = (const vector& rhs)
1540  {
1541  (void)etl::ivector<T*>::operator = (rhs);
1542 
1543  return *this;
1544  }
1545 
1546 #if ETL_CPP11_SUPPORTED
1547  //*************************************************************************
1549  //*************************************************************************
1550  vector(vector&& other)
1551  : etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
1552  {
1553  (void)etl::ivector<T*>::operator = (etl::move(other));
1554  }
1555 
1556  //*************************************************************************
1558  //*************************************************************************
1559  vector& operator = (vector&& rhs)
1560  {
1561  (void)etl::ivector<T*>::operator = (etl::move(rhs));
1562 
1563  return *this;
1564  }
1565 #endif
1566 
1567  //*************************************************************************
1569  //*************************************************************************
1570  void repair()
1571 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1572  ETL_OVERRIDE
1573 #endif
1574  {
1576  }
1577 
1578  private:
1579 
1580  typename etl::aligned_storage<sizeof(T*) * MAX_SIZE, etl::alignment_of<T*>::value>::type buffer;
1581  };
1582 
1583  //*************************************************************************
1585  //*************************************************************************
1586 #if ETL_CPP17_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1587  template <typename T, typename... Ts>
1588  vector(T*, Ts*...)
1589  ->vector<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T*>, 1U + sizeof...(Ts)>;
1590 #endif
1591 
1592  //***************************************************************************
1597  //***************************************************************************
1598  template <typename T>
1599  class vector_ext<T*> : public etl::ivector<T*>
1600  {
1601  public:
1602 
1603  //*************************************************************************
1605  //*************************************************************************
1606  vector_ext(void* buffer, size_t max_size)
1607  : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1608  {
1609  this->initialise();
1610  }
1611 
1612  //*************************************************************************
1615  //*************************************************************************
1616  vector_ext(size_t initial_size, void* buffer, size_t max_size)
1617  : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1618  {
1619  this->initialise();
1620  this->resize(initial_size);
1621  }
1622 
1623  //*************************************************************************
1627  //*************************************************************************
1628  vector_ext(size_t initial_size, typename etl::ivector<T*>::parameter_t value, void* buffer, size_t max_size)
1629  : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1630  {
1631  this->initialise();
1632  this->resize(initial_size, value);
1633  }
1634 
1635  //*************************************************************************
1640  //*************************************************************************
1641  template <typename TIterator>
1642  vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size)
1643  : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1644  {
1645  this->assign(first, last);
1646  }
1647 
1648 #if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
1649  //*************************************************************************
1651  //*************************************************************************
1652  vector_ext(std::initializer_list<T*> init, void* buffer, size_t max_size)
1653  : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1654  {
1655  this->assign(init.begin(), init.end());
1656  }
1657 #endif
1658 
1659  //*************************************************************************
1661  //*************************************************************************
1662  vector_ext(const vector_ext& other, void* buffer, size_t max_size)
1663  : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1664  {
1665  (void)etl::ivector<T*>::operator = (other);
1666  }
1667 
1668  //*************************************************************************
1670  //*************************************************************************
1671  vector_ext& operator = (const vector_ext& rhs)
1672  {
1673  (void)etl::ivector<T*>::operator = (rhs);
1674 
1675  return *this;
1676  }
1677 
1678 #if ETL_CPP11_SUPPORTED
1679  //*************************************************************************
1681  //*************************************************************************
1682  vector_ext(vector_ext&& other, void* buffer, size_t max_size)
1683  : etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
1684  {
1685  (void)etl::ivector<T*>::operator = (etl::move(other));
1686  }
1687 
1688  //*************************************************************************
1690  //*************************************************************************
1691  vector_ext& operator = (vector_ext&& rhs)
1692  {
1693  (void)etl::ivector<T*>::operator = (etl::move(rhs));
1694 
1695  return *this;
1696  }
1697 #endif
1698 
1699  //*************************************************************************
1701  //*************************************************************************
1703  {
1704  this->clear();
1705  }
1706 
1707  //*************************************************************************
1709  //*************************************************************************
1710  void repair()
1711 #ifdef ETL_IVECTOR_REPAIR_ENABLE
1712  ETL_OVERRIDE
1713 #endif
1714  {
1715  etl::ivector<T*>::repair_buffer(this->p_buffer);
1716  }
1717  };
1718 }
1719 
1720 #ifdef ETL_COMPILER_GCC
1721 #pragma GCC diagnostic pop
1722 #endif
1723 
1724 #endif
Definition: constant.h:45
Definition: alignment.h:116
#define ETL_ASSERT(b, e)
Definition: error_handler.h:290
void create_copy_at(T *p, const T &value)
Definition: memory.h:1635
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at(T *)
Definition: memory.h:949
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n(TIterator i_begin, TSize n)
Definition: memory.h:1111
void create_value_at(T *p)
Definition: memory.h:1614
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, void >::type destroy(TIterator, TIterator)
Definition: memory.h:1025
TOutputIterator uninitialized_move(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition: memory.h:472
TOutputIterator uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition: memory.h:297
TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T &value)
Definition: memory.h:177
T * addressof(T &t)
Definition: memory.h:61
add_rvalue_reference
Definition: type_traits_generator.h:1348
is_same
Definition: type_traits_generator.h:981
is_trivially_copyable
Definition: type_traits_generator.h:1191
remove_cv
Definition: type_traits_generator.h:921
void initialise()
Initialise the vector.
Definition: vector.h:950
iterator erase(iterator first, iterator last)
Definition: vector.h:836
iterator begin()
Definition: vector.h:108
~vector_ext()
Destructor.
Definition: vector.h:1435
iterator emplace(iterator position, const T1 &value1)
Emplaces a value to the vector at the specified position.
Definition: vector.h:605
const_reference at(size_t i) const
Definition: vector.h:296
size_type max_size() const
Definition: vector_base.h:143
vector_ext & operator=(const vector_ext &rhs)
Assignment operator.
Definition: vector.h:1377
void emplace_back(const T1 &value1, const T2 &value2, const T3 &value3)
Definition: vector.h:486
vector_ext(TIterator first, TIterator last, void *buffer, size_t max_size)
Definition: vector.h:1642
const_iterator begin() const
Definition: vector.h:117
void push_back(const_reference value)
Definition: vector.h:408
vector_ext(size_t initial_size, typename etl::ivector< T >::parameter_t value, void *buffer, size_t max_size)
Definition: vector.h:1334
vector()
Constructor.
Definition: vector.h:1474
const_reverse_iterator crbegin() const
Definition: vector.h:198
vector(size_t initial_size)
Definition: vector.h:1149
reverse_iterator rend()
Definition: vector.h:180
iterator insert(iterator position, const_reference value)
Definition: vector.h:531
const_iterator cend() const
Definition: vector.h:153
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1272
vector(const vector &other)
Copy constructor.
Definition: vector.h:1195
vector_ext(void *buffer, size_t max_size)
Constructor.
Definition: vector.h:1312
void clear()
Clears the vector.
Definition: vector.h:398
vector_ext(size_t initial_size, void *buffer, size_t max_size)
Definition: vector.h:1322
void emplace_back(const T1 &value1)
Definition: vector.h:454
void insert(iterator position, size_t n, parameter_t value)
Definition: vector.h:712
void reserve(size_t)
Does nothing.
Definition: vector.h:254
const size_type CAPACITY
The maximum number of elements in the vector.
Definition: vector_base.h:165
void emplace_back(const T1 &value1, const T2 &value2)
Definition: vector.h:470
pointer p_buffer
Pointer to the start of the buffer.
Definition: vector.h:968
vector_ext(size_t initial_size, typename etl::ivector< T * >::parameter_t value, void *buffer, size_t max_size)
Definition: vector.h:1628
reference front()
Definition: vector.h:306
iterator end()
Definition: vector.h:126
pointer data()
Definition: vector.h:342
const_pointer data() const
Definition: vector.h:351
vector(size_t initial_size, typename etl::ivector< T * >::parameter_t value)
Definition: vector.h:1496
const_reverse_iterator crend() const
Definition: vector.h:207
vector_ext(TIterator first, TIterator last, void *buffer, size_t max_size)
Definition: vector.h:1348
vector(size_t initial_size, typename etl::ivector< T >::parameter_t value)
Definition: vector.h:1161
reference operator[](size_t i)
Definition: vector.h:263
~vector_ext()
Destructor.
Definition: vector.h:1702
const_iterator cbegin() const
Definition: vector.h:144
ivector(T *p_buffer_, size_t MAX_SIZE)
Constructor.
Definition: vector.h:940
const_iterator end() const
Definition: vector.h:135
const_reverse_iterator rend() const
Definition: vector.h:189
~ivector()
Destructor.
Definition: vector.h:1032
vector_ext(size_t initial_size, void *buffer, size_t max_size)
Definition: vector.h:1616
void pop_back()
Definition: vector.h:517
void assign(size_t n, parameter_t value)
Definition: vector.h:385
reference at(size_t i)
Definition: vector.h:284
void emplace_back(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition: vector.h:502
vector & operator=(const vector &rhs)
Assignment operator.
Definition: vector.h:1204
const_reference back() const
Definition: vector.h:333
vector(TIterator first, TIterator last)
Definition: vector.h:1175
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1443
vector_ext(void *buffer, size_t max_size)
Constructor.
Definition: vector.h:1606
void repair_buffer(T *p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition: vector.h:961
void insert(iterator position, TIterator first, TIterator last)
Definition: vector.h:767
vector(const vector &other)
Copy constructor.
Definition: vector.h:1530
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1570
bool full() const
Definition: vector.h:914
vector_ext(const vector_ext &other, void *buffer, size_t max_size)
Copy constructor.
Definition: vector.h:1368
void assign(TIterator first, TIterator last)
Definition: vector.h:364
pointer p_end
Pointer to one past the last element in the buffer.
Definition: vector.h:969
vector(size_t initial_size)
Definition: vector.h:1484
ivector & operator=(const ivector &rhs)
Assignment operator.
Definition: vector.h:859
size_type size() const
Definition: vector.h:896
iterator erase(iterator i_element)
Definition: vector.h:820
void resize(size_t new_size, T value)
Definition: vector.h:230
void repair()
Fix the internal pointers after a low level memory copy.
Definition: vector.h:1710
bool empty() const
Definition: vector.h:905
const_reverse_iterator rbegin() const
Definition: vector.h:171
void resize(size_t new_size)
Definition: vector.h:218
~vector()
Destructor.
Definition: vector.h:1261
reference back()
Definition: vector.h:324
size_t available() const
Definition: vector.h:923
vector()
Constructor.
Definition: vector.h:1139
vector_ext(const vector_ext &other, void *buffer, size_t max_size)
Copy constructor.
Definition: vector.h:1662
reverse_iterator rbegin()
Definition: vector.h:162
const_reference front() const
Definition: vector.h:315
vector(TIterator first, TIterator last)
Definition: vector.h:1510
Definition: vector.h:80
Definition: ivectorpointer.h:49
Definition: vector.h:1129
Definition: vector_base.h:125
Definition: vector_base.h:83
Template deduction guides.
Definition: vector.h:1306
Definition: vector_base.h:69
Definition: vector_base.h:111
Definition: vector_base.h:97
Definition: absolute.h:37
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
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:594
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:582
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:606
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:621
iterator
Definition: iterator.h:422