Fast RTPS  Version 2.14.1
Fast RTPS
Loading...
Searching...
No Matches
ResourceLimitedVector.hpp
1// Copyright 2019 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
20#ifndef FASTRTPS_UTILS_COLLECTIONS_RESOURCELIMITEDVECTOR_HPP_
21#define FASTRTPS_UTILS_COLLECTIONS_RESOURCELIMITEDVECTOR_HPP_
22
23#include "ResourceLimitedContainerConfig.hpp"
24
25#include <assert.h>
26#include <algorithm>
27#include <type_traits>
28#include <vector>
29
30namespace eprosima {
31namespace fastrtps {
32
52template <
53 typename _Ty,
54 typename _KeepOrderEnabler = std::false_type,
55 typename _LimitsConfig = ResourceLimitedContainerConfig,
56 typename _Alloc = std::allocator<_Ty>,
57 typename _Collection = std::vector<_Ty, _Alloc>>
59{
60public:
61
62 using configuration_type = _LimitsConfig;
63 using collection_type = _Collection;
64 using value_type = _Ty;
65 using allocator_type = _Alloc;
66 using pointer = typename collection_type::pointer;
67 using const_pointer = typename collection_type::const_pointer;
68 using reference = typename collection_type::reference;
69 using const_reference = typename collection_type::const_reference;
70 using size_type = typename collection_type::size_type;
71 using difference_type = typename collection_type::difference_type;
72 using iterator = typename collection_type::iterator;
73 using const_iterator = typename collection_type::const_iterator;
74 using reverse_iterator = typename collection_type::reverse_iterator;
75 using const_reverse_iterator = typename collection_type::const_reverse_iterator;
76
91 const allocator_type& alloc = allocator_type())
92 : configuration_(cfg)
93 , collection_(alloc)
94 {
95 collection_.reserve(cfg.initial);
96 }
97
99 const ResourceLimitedVector& other)
101 , collection_(other.collection_.get_allocator())
102 {
103 collection_.reserve(other.collection_.capacity());
104 collection_.assign(other.collection_.begin(), other.collection_.end());
105 }
106
107 virtual ~ResourceLimitedVector () = default;
108
110 const ResourceLimitedVector& other)
111 {
112 clear();
113 for (const_reference item : other)
114 {
115 push_back(item);
116 }
117
118 assert(size() == other.size());
119 return *this;
120 }
121
131 const_iterator pos,
132 const value_type& value)
133 {
134 auto dist = std::distance(collection_.cbegin(), pos);
135 if (!ensure_capacity())
136 {
137 return end();
138 }
139
140 return collection_.insert(collection_.cbegin() + dist, value);
141 }
142
152 const_iterator pos,
153 value_type&& value)
154 {
155 auto dist = std::distance(collection_.cbegin(), pos);
156 if (!ensure_capacity())
157 {
158 return end();
159 }
160
161 return collection_.insert(collection_.cbegin() + dist, std::move(value));
162 }
163
175 const value_type& val)
176 {
177 return emplace_back(val);
178 }
179
191 value_type&& val)
192 {
193 if (!ensure_capacity())
194 {
195 // Indicate error by returning null pointer
196 return nullptr;
197 }
198
199 // Move the element at the end of the collection
200 collection_.push_back(std::move(val));
201
202 // Return pointer to newly created element
203 return &collection_.back();
204 }
205
216 template<typename ... Args>
218 Args&& ... args)
219 {
220 if (!ensure_capacity())
221 {
222 // Indicate error by returning null pointer
223 return nullptr;
224 }
225
226 // Construct new element at the end of the collection
227 collection_.emplace_back(args ...);
228
229 // Return pointer to newly created element
230 return &collection_.back();
231 }
232
243 bool remove(
244 const value_type& val)
245 {
246 iterator it = std::find(collection_.begin(), collection_.end(), val);
247 if (it != collection_.end())
248 {
249 do_remove(it);
250 return true;
251 }
252 return false;
253 }
254
270 template<class UnaryPredicate>
272 UnaryPredicate pred)
273 {
274 iterator it = std::find_if(collection_.begin(), collection_.end(), pred);
275 if (it != collection_.end())
276 {
277 do_remove(it);
278 return true;
279 }
280 return false;
281 }
282
293 const value_type& val)
294 {
295 iterator it = std::find(collection_.begin(), collection_.end(), val);
296 if (it != collection_.end())
297 {
298 return true;
299 }
300 return false;
301 }
302
317 template <class InputIterator>
318 void assign(
319 InputIterator first,
320 InputIterator last)
321 {
322 size_type n = static_cast<size_type>(std::distance(first, last));
323 n = (std::min)(n, configuration_.maximum);
324 InputIterator value = first;
325 std::advance(value, n);
326 collection_.assign(first, value);
327 }
328
339 void assign(
340 size_type n,
341 const value_type& val)
342 {
343 n = (std::min)(n, configuration_.maximum);
344 collection_.assign(n, val);
345 }
346
358 void assign(
359 std::initializer_list<value_type> il)
360 {
361 size_type n = (std::min)(il.size(), configuration_.maximum);
362 collection_.assign(il.begin(), il.begin() + n);
363 }
364
371 size_type pos)
372 {
373 return collection_.at(pos);
374 }
375
377 size_type pos) const
378 {
379 return collection_.at(pos);
380 }
381
383 size_type pos)
384 {
385 return collection_[pos];
386 }
387
389 size_type pos) const
390 {
391 return collection_[pos];
392 }
393
395 {
396 return collection_.front();
397 }
398
400 {
401 return collection_.front();
402 }
403
405 {
406 return collection_.back();
407 }
408
410 {
411 return collection_.back();
412 }
413
414 iterator begin() noexcept
415 {
416 return collection_.begin();
417 }
418
419 const_iterator begin() const noexcept
420 {
421 return collection_.begin();
422 }
423
424 const_iterator cbegin() const noexcept
425 {
426 return collection_.cbegin();
427 }
428
429 iterator end() noexcept
430 {
431 return collection_.end();
432 }
433
434 const_iterator end() const noexcept
435 {
436 return collection_.end();
437 }
438
439 const_iterator cend() const noexcept
440 {
441 return collection_.cend();
442 }
443
445 {
446 return collection_.rbegin();
447 }
448
450 {
451 return collection_.rbegin();
452 }
453
455 {
456 return collection_.crbegin();
457 }
458
460 {
461 return collection_.rend();
462 }
463
465 {
466 return collection_.rend();
467 }
468
470 {
471 return collection_.crend();
472 }
473
474 bool empty() const noexcept
475 {
476 return collection_.empty();
477 }
478
479 size_type size() const noexcept
480 {
481 return collection_.size();
482 }
483
484 size_type capacity() const noexcept
485 {
486 return collection_.capacity();
487 }
488
489 size_type max_size() const noexcept
490 {
491 return (std::min)(configuration_.maximum, collection_.max_size());
492 }
493
494 void clear()
495 {
496 collection_.clear();
497 }
498
500 const_iterator pos)
501 {
502 return collection_.erase(pos);
503 }
504
506 const_iterator first,
507 const_iterator last)
508 {
509 return collection_.erase(first, last);
510 }
511
512 void pop_back()
513 {
514 collection_.pop_back();
515 }
516
518 {
519 return collection_.data();
520 }
521
522 const value_type* data() const
523 {
524 return collection_.data();
525 }
526
528
536 operator const collection_type& () const noexcept
537 {
538 return collection_;
539 }
540
541protected:
542
545
554 {
555 size_type size = collection_.size();
556 size_type cap = collection_.capacity();
557 if (size == cap)
558 {
559 // collection is full, check resource limit
560 if (cap < configuration_.maximum)
561 {
562 // increase collection capacity
563 assert(configuration_.increment > 0);
564 cap += configuration_.increment;
565 cap = (std::min)(cap, configuration_.maximum);
566 collection_.reserve(cap);
567 }
568 else
569 {
570 return false;
571 }
572 }
573
574 return true;
575 }
576
586 template <typename Enabler = _KeepOrderEnabler>
587 typename std::enable_if<!Enabler::value, void>::type do_remove(
588 iterator it)
589 {
590 // Copy last element into the element being removed
591 if (it != --collection_.end())
592 {
593 *it = std::move(collection_.back());
594 }
595
596 // Then drop last element
597 collection_.pop_back();
598 }
599
610 template <typename Enabler = _KeepOrderEnabler>
611 typename std::enable_if<Enabler::value, void>::type do_remove(
612 iterator it)
613 {
614 collection_.erase(it);
615 }
616
617};
618
619} // namespace fastrtps
620} // namespace eprosima
621
622#endif /* FASTRTPS_UTILS_COLLECTIONS_RESOURCELIMITEDVECTOR_HPP_ */
Resource limited wrapper of std::vector.
Definition ResourceLimitedVector.hpp:59
void pop_back()
Definition ResourceLimitedVector.hpp:512
size_type size() const noexcept
Definition ResourceLimitedVector.hpp:479
configuration_type configuration_
Definition ResourceLimitedVector.hpp:543
const_reference front() const
Definition ResourceLimitedVector.hpp:399
typename collection_type::iterator iterator
Definition ResourceLimitedVector.hpp:72
pointer push_back(value_type &&val)
Add element at the end.
Definition ResourceLimitedVector.hpp:190
typename collection_type::difference_type difference_type
Definition ResourceLimitedVector.hpp:71
void assign(std::initializer_list< value_type > il)
Assign vector content.
Definition ResourceLimitedVector.hpp:358
typename collection_type::reverse_iterator reverse_iterator
Definition ResourceLimitedVector.hpp:74
std::enable_if< Enabler::value, void >::type do_remove(iterator it)
Remove element.
Definition ResourceLimitedVector.hpp:611
void assign(size_type n, const value_type &val)
Assign vector content.
Definition ResourceLimitedVector.hpp:339
const_iterator begin() const noexcept
Definition ResourceLimitedVector.hpp:419
typename collection_type::const_pointer const_pointer
Definition ResourceLimitedVector.hpp:67
std::enable_if<!Enabler::value, void >::type do_remove(iterator it)
Remove element.
Definition ResourceLimitedVector.hpp:587
iterator erase(const_iterator pos)
Definition ResourceLimitedVector.hpp:499
_LimitsConfig configuration_type
Definition ResourceLimitedVector.hpp:62
iterator insert(const_iterator pos, value_type &&value)
Insert value before pos.
Definition ResourceLimitedVector.hpp:151
bool empty() const noexcept
Definition ResourceLimitedVector.hpp:474
typename collection_type::const_reverse_iterator const_reverse_iterator
Definition ResourceLimitedVector.hpp:75
ResourceLimitedVector(const ResourceLimitedVector &other)
Definition ResourceLimitedVector.hpp:98
typename collection_type::pointer pointer
Definition ResourceLimitedVector.hpp:66
const_reference at(size_type pos) const
Definition ResourceLimitedVector.hpp:376
reference at(size_type pos)
Wrappers to other basic vector methods.
Definition ResourceLimitedVector.hpp:370
const_iterator end() const noexcept
Definition ResourceLimitedVector.hpp:434
const_reference back() const
Definition ResourceLimitedVector.hpp:409
bool remove_if(UnaryPredicate pred)
Remove element.
Definition ResourceLimitedVector.hpp:271
typename collection_type::const_iterator const_iterator
Definition ResourceLimitedVector.hpp:73
reference front()
Definition ResourceLimitedVector.hpp:394
_Collection collection_type
Definition ResourceLimitedVector.hpp:63
bool ensure_capacity()
Make room for one item.
Definition ResourceLimitedVector.hpp:553
iterator begin() noexcept
Definition ResourceLimitedVector.hpp:414
const_iterator cend() const noexcept
Definition ResourceLimitedVector.hpp:439
const value_type * data() const
Definition ResourceLimitedVector.hpp:522
iterator erase(const_iterator first, const_iterator last)
Definition ResourceLimitedVector.hpp:505
_Ty value_type
Definition ResourceLimitedVector.hpp:64
reference operator[](size_type pos)
Definition ResourceLimitedVector.hpp:382
_Alloc allocator_type
Definition ResourceLimitedVector.hpp:65
pointer push_back(const value_type &val)
Add element at the end.
Definition ResourceLimitedVector.hpp:174
const_reverse_iterator crbegin() const noexcept
Definition ResourceLimitedVector.hpp:454
const_iterator cbegin() const noexcept
Definition ResourceLimitedVector.hpp:424
ResourceLimitedVector(configuration_type cfg=configuration_type(), const allocator_type &alloc=allocator_type())
Construct a ResourceLimitedVector.
Definition ResourceLimitedVector.hpp:89
size_type max_size() const noexcept
Definition ResourceLimitedVector.hpp:489
const_reverse_iterator rend() const noexcept
Definition ResourceLimitedVector.hpp:464
reverse_iterator rbegin() noexcept
Definition ResourceLimitedVector.hpp:444
void clear()
Definition ResourceLimitedVector.hpp:494
typename collection_type::size_type size_type
Definition ResourceLimitedVector.hpp:70
iterator insert(const_iterator pos, const value_type &value)
Insert value before pos.
Definition ResourceLimitedVector.hpp:130
typename collection_type::reference reference
Definition ResourceLimitedVector.hpp:68
const_reverse_iterator crend() const noexcept
Definition ResourceLimitedVector.hpp:469
reverse_iterator rend() noexcept
Definition ResourceLimitedVector.hpp:459
void assign(InputIterator first, InputIterator last)
Assign vector content.
Definition ResourceLimitedVector.hpp:318
collection_type collection_
Definition ResourceLimitedVector.hpp:544
size_type capacity() const noexcept
Definition ResourceLimitedVector.hpp:484
pointer emplace_back(Args &&... args)
Construct and insert element at the end.
Definition ResourceLimitedVector.hpp:217
value_type * data()
Definition ResourceLimitedVector.hpp:517
bool contains(const value_type &val)
Contains element.
Definition ResourceLimitedVector.hpp:292
bool remove(const value_type &val)
Remove element.
Definition ResourceLimitedVector.hpp:243
typename collection_type::const_reference const_reference
Definition ResourceLimitedVector.hpp:69
reference back()
Definition ResourceLimitedVector.hpp:404
iterator end() noexcept
Definition ResourceLimitedVector.hpp:429
const_reverse_iterator rbegin() const noexcept
Definition ResourceLimitedVector.hpp:449
ResourceLimitedVector & operator=(const ResourceLimitedVector &other)
Definition ResourceLimitedVector.hpp:109
eProsima namespace.
Definition LibrarySettingsAttributes.h:23