Embedded Template Library 1.0
pvoidvector.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_PVOIDVECTOR_INCLUDED
32#define ETL_PVOIDVECTOR_INCLUDED
33
34#define ETL_IN_PVOIDVECTOR
35
36#include "../platform.h"
37#include "../algorithm.h"
38#include "vector_base.h"
39#include "../type_traits.h"
40#include "../error_handler.h"
41#include "../functional.h"
42#include "../iterator.h"
43
44#include <stddef.h>
45
46#include "minmax_push.h"
47
48namespace etl
49{
50 //***************************************************************************
53 //***************************************************************************
54 class pvoidvector : public vector_base
55 {
56 public:
57
58 typedef void* value_type;
59 typedef value_type& reference;
60 typedef const value_type& const_reference;
61 typedef value_type* pointer;
62 typedef const value_type* const_pointer;
63 typedef value_type* iterator;
64 typedef const value_type* const_iterator;
65 typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
66 typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
67 typedef size_t size_type;
68 typedef etl::iterator_traits<iterator>::difference_type difference_type;
69
70 public:
71
72 //*********************************************************************
75 //*********************************************************************
76 iterator begin()
77 {
78 return p_buffer;
79 }
80
81 //*********************************************************************
84 //*********************************************************************
85 const_iterator begin() const
86 {
87 return const_iterator(p_buffer);
88 }
89
90 //*********************************************************************
93 //*********************************************************************
94 iterator end()
95 {
96 return p_end;
97 }
98
99 //*********************************************************************
102 //*********************************************************************
103 const_iterator end() const
104 {
105 return const_iterator(p_end);
106 }
107
108 //*********************************************************************
111 //*********************************************************************
112 const_iterator cbegin() const
113 {
114 return const_iterator(p_buffer);
115 }
116
117 //*********************************************************************
120 //*********************************************************************
121 const_iterator cend() const
122 {
123 return const_iterator(p_end);
124 }
125
126 //*********************************************************************
129 //*********************************************************************
130 reverse_iterator rbegin()
131 {
132 return reverse_iterator(end());
133 }
134
135 //*********************************************************************
138 //*********************************************************************
139 const_reverse_iterator rbegin() const
140 {
141 return const_reverse_iterator(end());
142 }
143
144 //*********************************************************************
147 //*********************************************************************
148 reverse_iterator rend()
149 {
150 return reverse_iterator(begin());
151 }
152
153 //*********************************************************************
156 //*********************************************************************
157 const_reverse_iterator rend() const
158 {
159 return const_reverse_iterator(begin());
160 }
161
162 //*********************************************************************
165 //*********************************************************************
166 const_reverse_iterator crbegin() const
167 {
168 return const_reverse_iterator(cend());
169 }
170
171 //*********************************************************************
174 //*********************************************************************
175 const_reverse_iterator crend() const
176 {
177 return const_reverse_iterator(cbegin());
178 }
179
180 //*********************************************************************
185 //*********************************************************************
186 void resize(size_t new_size)
187 {
188 ETL_ASSERT_OR_RETURN(new_size <= CAPACITY, ETL_ERROR(vector_full));
189
190 p_end = p_buffer + new_size;
191 }
192
193 //*********************************************************************
199 //*********************************************************************
200 void resize(size_t new_size, value_type value)
201 {
202 ETL_ASSERT_OR_RETURN(new_size <= CAPACITY, ETL_ERROR(vector_full));
203
204 pointer p_new_end = p_buffer + new_size;
205
206 // Size up if necessary.
207 if (p_end < p_new_end)
208 {
209 etl::fill(p_end, p_new_end, value);
210 }
211
212 p_end = p_new_end;
213 }
214
215 //*********************************************************************
218 //*********************************************************************
219 void uninitialized_resize(size_t new_size)
220 {
221 ETL_ASSERT_OR_RETURN(new_size <= CAPACITY, ETL_ERROR(vector_full));
222
223 p_end = p_buffer + new_size;
224 }
225
226 //*********************************************************************
230 //*********************************************************************
231 reference operator [](size_t i)
232 {
233 return p_buffer[i];
234 }
235
236 //*********************************************************************
240 //*********************************************************************
241 const_reference operator [](size_t i) const
242 {
243 return p_buffer[i];
244 }
245
246 //*********************************************************************
251 //*********************************************************************
252 reference at(size_t i)
253 {
254 ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
255 return p_buffer[i];
256 }
257
258 //*********************************************************************
263 //*********************************************************************
264 const_reference at(size_t i) const
265 {
266 ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
267 return p_buffer[i];
268 }
269
270 //*********************************************************************
273 //*********************************************************************
274 reference front()
275 {
276 return p_buffer[0];
277 }
278
279 //*********************************************************************
282 //*********************************************************************
283 const_reference front() const
284 {
285 return p_buffer[0];
286 }
287
288 //*********************************************************************
291 //*********************************************************************
292 reference back()
293 {
294 return *(p_end - 1);
295 }
296
297 //*********************************************************************
300 //*********************************************************************
301 const_reference back() const
302 {
303 return *(p_end - 1);
304 }
305
306 //*********************************************************************
309 //*********************************************************************
310 pointer data()
311 {
312 return p_buffer;
313 }
314
315 //*********************************************************************
318 //*********************************************************************
319 const_pointer data() const
320 {
321 return p_buffer;
322 }
323
324 //*********************************************************************
330 //*********************************************************************
331 template <typename TIterator>
333 assign(TIterator first, TIterator last)
334 {
335#if ETL_IS_DEBUG_BUILD
336 difference_type d = etl::distance(first, last);
337 ETL_ASSERT_OR_RETURN(static_cast<size_t>(d) <= CAPACITY, ETL_ERROR(vector_full));
338#endif
339
340 initialise();
341
342 while (first != last)
343 {
344 *p_end++ = (void*)(*first);
345 ++first;
346 }
347 }
348
349 //*********************************************************************
355 //*********************************************************************
356 template <typename TIterator>
358 assign(TIterator first, TIterator last)
359 {
360#if ETL_IS_DEBUG_BUILD
361 difference_type d = etl::distance(first, last);
362 ETL_ASSERT_OR_RETURN(static_cast<size_t>(d) <= CAPACITY, ETL_ERROR(vector_full));
363#endif
364
365 initialise();
366
367 void** p_first = (void**)(first);
368 void** p_last = (void**)(last);
369
370 p_end = etl::copy(p_first, p_last, p_buffer);
371 }
372
373 //*********************************************************************
378 //*********************************************************************
379 void assign(size_t n, value_type value)
380 {
381 ETL_ASSERT_OR_RETURN(n <= CAPACITY, ETL_ERROR(vector_full));
382
383 initialise();
384
385 p_end = etl::fill_n(p_buffer, n, value);
386 }
387
388 //*************************************************************************
390 //*************************************************************************
391 void clear()
392 {
393 initialise();
394 }
395
396 //*********************************************************************
400 //*********************************************************************
401 void push_back(value_type value)
402 {
403#if defined(ETL_CHECK_PUSH_POP)
404 ETL_ASSERT_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
405#endif
406 *p_end++ = value;
407 }
408
409 //*********************************************************************
413 //*********************************************************************
414 void emplace_back(value_type value)
415 {
416#if defined(ETL_CHECK_PUSH_POP)
417 ETL_ASSERT_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
418#endif
419 * p_end++ = value;
420 }
421
422 //*************************************************************************
425 //*************************************************************************
426 void pop_back()
427 {
428#if defined(ETL_CHECK_PUSH_POP)
429 ETL_ASSERT_OR_RETURN(size() > 0, ETL_ERROR(vector_empty));
430#endif
431 --p_end;
432 }
433
434 //*********************************************************************
439 //*********************************************************************
440 iterator insert(const_iterator position, value_type value)
441 {
442
443
444 iterator position_ = to_iterator(position);
445
446 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
447
448 if (size() != CAPACITY)
449 {
450 if (position_ != end())
451 {
452 ++p_end;
453 etl::copy_backward(position_, end() - 1, end());
454 *position_ = value;
455 }
456 else
457 {
458 *p_end++ = value;
459 }
460 }
461
462 return position_;
463 }
464
465
466 //*************************************************************************
469 //*************************************************************************
470 iterator emplace(const_iterator position, value_type value)
471 {
472 ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
473
474 iterator position_ = to_iterator(position);
475
476 if (position_ != end())
477 {
478 ++p_end;
479 etl::copy_backward(position_, end() - 1, end());
480 *position_ = value;
481 }
482 else
483 {
484 *p_end++ = value;
485 }
486
487 return position_;
488 }
489
490 //*********************************************************************
496 //*********************************************************************
497 void insert(const_iterator position, size_t n, value_type value)
498 {
499 ETL_ASSERT_OR_RETURN((size() + n) <= CAPACITY, ETL_ERROR(vector_full));
500
501 iterator position_ = to_iterator(position);
502
503 etl::copy_backward(position_, p_end, p_end + n);
504 etl::fill_n(position_, n, value);
505
506 p_end += n;
507 }
508
509 //*********************************************************************
516 //*********************************************************************
517 template <typename TIterator>
518 void insert(const_iterator position, TIterator first, TIterator last)
519 {
520 size_t count = etl::distance(first, last);
521
522 iterator position_ = to_iterator(position);
523
524 ETL_ASSERT_OR_RETURN((size() + count) <= CAPACITY, ETL_ERROR(vector_full));
525
526 etl::copy_backward(position_, p_end, p_end + count);
527 etl::copy(first, last, position_);
528 p_end += count;
529 }
530
531 //*********************************************************************
535 //*********************************************************************
536 iterator erase(iterator i_element)
537 {
538 etl::copy(i_element + 1, end(), i_element);
539 --p_end;
540
541 return i_element;
542 }
543
544 //*********************************************************************
548 //*********************************************************************
549 iterator erase(const_iterator i_element)
550 {
551 iterator i_element_ = to_iterator(i_element);
552
553 etl::copy(i_element_ + 1, end(), i_element_);
554 --p_end;
555
556 return i_element_;
557 }
558
559 //*********************************************************************
566 //*********************************************************************
567 iterator erase(const_iterator first, const_iterator last)
568 {
569 iterator first_ = to_iterator(first);
570 iterator last_ = to_iterator(last);
571
572 etl::copy(last_, end(), first_);
573 size_t n_delete = etl::distance(first, last);
574
575 // Just adjust the count.
576 p_end -= n_delete;
577
578 return first_;
579 }
580
581 //*************************************************************************
583 //*************************************************************************
585 {
586 if (&rhs != this)
587 {
588 this->initialise();
589 this->resize(rhs.size());
590 etl::copy_n(rhs.data(), rhs.size(), this->data());
591 }
592
593 return *this;
594 }
595
596#if ETL_USING_CPP11
597 //*************************************************************************
599 //*************************************************************************
601 {
602 if (&rhs != this)
603 {
604 this->initialise();
605 this->resize(rhs.size());
606 etl::copy_n(rhs.data(), rhs.size(), this->data());
607 rhs.initialise();
608 }
609
610 return *this;
611 }
612#endif
613
614 //*************************************************************************
617 //*************************************************************************
618 size_type size() const
619 {
620 return size_t(p_end - p_buffer);
621 }
622
623 //*************************************************************************
626 //*************************************************************************
627 bool empty() const
628 {
629 return (p_end == p_buffer);
630 }
631
632 //*************************************************************************
635 //*************************************************************************
636 bool full() const
637 {
638 return size() == CAPACITY;
639 }
640
641 //*************************************************************************
644 //*************************************************************************
645 size_t available() const
646 {
647 return max_size() - size();
648 }
649
650 protected:
651
652 //*********************************************************************
654 //*********************************************************************
655 pvoidvector(void** p_buffer_, size_t MAX_SIZE)
656 : vector_base(MAX_SIZE)
657 , p_buffer(p_buffer_)
658 , p_end(p_buffer_)
659 {
660 }
661
662 //*********************************************************************
664 //*********************************************************************
666 {
667 p_end = p_buffer;
668 }
669
670 //*************************************************************************
672 //*************************************************************************
673 void repair_buffer(void** p_buffer_)
674 {
675 uintptr_t length = p_end - p_buffer;
676
677 p_buffer = p_buffer_;
678 p_end = p_buffer_ + length;
679 }
680
681 void** p_buffer;
682 void** p_end;
683
684 private:
685
686 //*************************************************************************
688 //*************************************************************************
689 iterator to_iterator(const_iterator itr) const
690 {
691 return const_cast<iterator>(itr);
692 }
693
694 // Disable copy construction.
695 pvoidvector(const pvoidvector&);
696 };
697
698 //***************************************************************************
704 //***************************************************************************
705 inline bool operator ==(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
706 {
707 return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
708 }
709
710 //***************************************************************************
716 //***************************************************************************
717 inline bool operator !=(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
718 {
719 return !(lhs == rhs);
720 }
721
722 //***************************************************************************
728 //***************************************************************************
729 inline bool operator <(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
730 {
731 return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
732 }
733
734 //***************************************************************************
740 //***************************************************************************
741 inline bool operator >(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
742 {
743 return (rhs < lhs);
744 }
745
746 //***************************************************************************
752 //***************************************************************************
753 inline bool operator <=(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
754 {
755 return !(lhs > rhs);
756 }
757
758 //***************************************************************************
764 //***************************************************************************
765 inline bool operator >=(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
766 {
767 return !(lhs < rhs);
768 }
769}
770
771#include "minmax_pop.h"
772
773#undef ETL_IN_PVOIDVECTOR
774
775#endif
#define ETL_ASSERT(b, e)
Definition: error_handler.h:316
enable_if
Definition: type_traits_generator.h:1191
bool full() const
Definition: pvoidvector.h:636
iterator erase(const_iterator first, const_iterator last)
Definition: pvoidvector.h:567
etl::enable_if<!etl::is_pointer< TIterator >::value, void >::type assign(TIterator first, TIterator last)
Definition: pvoidvector.h:333
const_reference at(size_t i) const
Definition: pvoidvector.h:264
iterator begin()
Definition: pvoidvector.h:76
void emplace_back(value_type value)
Definition: pvoidvector.h:414
iterator erase(iterator i_element)
Definition: pvoidvector.h:536
pointer data()
Definition: pvoidvector.h:310
size_type max_size() const
Definition: vector_base.h:140
const_reverse_iterator rend() const
Definition: pvoidvector.h:157
reference operator[](size_t i)
Definition: pvoidvector.h:231
void initialise()
Initialise the vector.
Definition: pvoidvector.h:665
bool empty() const
Definition: pvoidvector.h:627
const_iterator end() const
Definition: pvoidvector.h:103
const size_type CAPACITY
The maximum number of elements in the vector.
Definition: vector_base.h:170
etl::pvoidvector & operator=(const etl::pvoidvector &rhs)
Assignment operator.
Definition: pvoidvector.h:584
void insert(const_iterator position, size_t n, value_type value)
Definition: pvoidvector.h:497
reverse_iterator rend()
Definition: pvoidvector.h:148
iterator insert(const_iterator position, value_type value)
Definition: pvoidvector.h:440
void clear()
Clears the vector.
Definition: pvoidvector.h:391
void assign(size_t n, value_type value)
Definition: pvoidvector.h:379
iterator emplace(const_iterator position, value_type value)
Definition: pvoidvector.h:470
void resize(size_t new_size)
Definition: pvoidvector.h:186
void pop_back()
Definition: pvoidvector.h:426
const_reverse_iterator crend() const
Definition: pvoidvector.h:175
const_reference front() const
Definition: pvoidvector.h:283
void repair_buffer(void **p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition: pvoidvector.h:673
reference back()
Definition: pvoidvector.h:292
iterator end()
Definition: pvoidvector.h:94
void uninitialized_resize(size_t new_size)
Definition: pvoidvector.h:219
const_pointer data() const
Definition: pvoidvector.h:319
reference front()
Definition: pvoidvector.h:274
pvoidvector(void **p_buffer_, size_t MAX_SIZE)
Constructor.
Definition: pvoidvector.h:655
void push_back(value_type value)
Definition: pvoidvector.h:401
const_reference back() const
Definition: pvoidvector.h:301
size_t available() const
Definition: pvoidvector.h:645
const_iterator cend() const
Definition: pvoidvector.h:121
void insert(const_iterator position, TIterator first, TIterator last)
Definition: pvoidvector.h:518
const_iterator begin() const
Definition: pvoidvector.h:85
const_iterator cbegin() const
Definition: pvoidvector.h:112
size_type size() const
Definition: pvoidvector.h:618
iterator erase(const_iterator i_element)
Definition: pvoidvector.h:549
const_reverse_iterator crbegin() const
Definition: pvoidvector.h:166
reverse_iterator rbegin()
Definition: pvoidvector.h:130
etl::enable_if< etl::is_pointer< TIterator >::value, void >::type assign(TIterator first, TIterator last)
Definition: pvoidvector.h:358
reference at(size_t i)
Definition: pvoidvector.h:252
void resize(size_t new_size, value_type value)
Definition: pvoidvector.h:200
const_reverse_iterator rbegin() const
Definition: pvoidvector.h:139
Definition: pvoidvector.h:55
Definition: vector_base.h:122
Definition: vector_base.h:80
Definition: vector_base.h:66
Definition: vector_base.h:94
bitset_ext
Definition: absolute.h:38
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:684
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:696
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:645
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:633
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:657
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition: array.h:672
iterator
Definition: iterator.h:399