Pigweed
C/C++ API Reference
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Loading...
Searching...
No Matches
dynamic_vector.h
1// Copyright 2025 The Pigweed Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License"); you may not
4// use this file except in compliance with the License. You may obtain a copy of
5// the License at
6//
7// https://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, WITHOUT
11// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12// License for the specific language governing permissions and limitations under
13// the License.
14#pragma once
15
16#include <initializer_list>
17#include <iterator>
18
19#include "pw_allocator/allocator.h"
20#include "pw_containers/dynamic_deque.h"
21#include "pw_containers/ptr_iterator.h"
22
23namespace pw {
24
47template <typename T, typename SizeType = uint16_t>
49 public:
50 using value_type = T;
51 using size_type = SizeType;
52 using reference = value_type&;
53 using const_reference = const value_type&;
54 using pointer = value_type*;
55 using const_pointer = const value_type*;
58 using reverse_iterator = std::reverse_iterator<iterator>;
59 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
61
65 explicit constexpr DynamicVector(Allocator& allocator) : deque_(allocator) {}
66
67 DynamicVector(const DynamicVector&) = delete;
68 DynamicVector& operator=(const DynamicVector&) = delete;
69
70 constexpr DynamicVector(DynamicVector&&) = default;
71 constexpr DynamicVector& operator=(DynamicVector&&) = default;
72
73 // Iterators
74
75 iterator begin() { return iterator(data()); }
76 const_iterator begin() const { return cbegin(); }
77 const_iterator cbegin() const { return const_iterator(data()); }
78
79 iterator end() { return iterator(data() + size()); }
80 const_iterator end() const { return cend(); }
81 const_iterator cend() const { return const_iterator(data() + size()); }
82
83 reverse_iterator rbegin() { return reverse_iterator(end()); }
84 const_reverse_iterator rbegin() const { return crbegin(); }
85 const_reverse_iterator crbegin() const {
86 return const_reverse_iterator(end());
87 }
88
89 reverse_iterator rend() { return reverse_iterator(begin()); }
90 const_reverse_iterator rend() const { return crend(); }
91 const_reverse_iterator crend() const {
92 return const_reverse_iterator(begin());
93 }
94
95 // Capacity
96
98 constexpr allocator_type& get_allocator() const {
99 return deque_.get_allocator();
100 }
101
103 bool empty() const { return deque_.empty(); }
104
106 size_type size() const { return deque_.size(); }
107
110 size_type capacity() const { return deque_.capacity(); }
111
113 size_type max_size() const { return deque_.max_size(); }
114
120 void reserve(size_type new_capacity) { deque_.reserve(new_capacity); }
121
127 void reserve_exact(size_type new_capacity) {
128 deque_.reserve_exact(new_capacity);
129 }
130
138 [[nodiscard]] bool try_reserve(size_type new_capacity) {
139 return deque_.try_reserve(new_capacity);
140 }
141
148 [[nodiscard]] bool try_reserve_exact(size_type new_capacity) {
149 return deque_.try_reserve_exact(new_capacity);
150 }
151
153 void shrink_to_fit() { deque_.shrink_to_fit(); }
154
155 // Element access
156
163 reference operator[](size_type pos) { return data()[pos]; }
164
171 const_reference operator[](size_type pos) const { return data()[pos]; }
172
180 reference at(size_type pos) { return deque_.at(pos); }
181
189 const_reference at(size_type pos) const { return deque_.at(pos); }
190
194 reference front() { return deque_.front(); }
195
199 const_reference front() const { return deque_.front(); }
200
204 reference back() { return deque_.back(); }
205
209 const_reference back() const { return deque_.back(); }
210
217 pointer data() { return deque_.data(); }
218
224 const_pointer data() const { return deque_.data(); }
225
226 // Modifiers
227
233 void assign(size_type count, const value_type& value) {
234 deque_.assign(count, value);
235 }
236
237 [[nodiscard]] bool try_assign(size_type count, const value_type& value) {
238 return deque_.try_assign(count, value);
239 }
240
245 void assign(std::initializer_list<T> init) { deque_.assign(init); }
246
247 [[nodiscard]] bool try_assign(std::initializer_list<T> init) {
248 return deque_.try_assign(init);
249 }
250
255 void push_back(const value_type& value) { deque_.push_back(value); }
256
261 void push_back(value_type&& value) { deque_.push_back(std::move(value)); }
262
269 [[nodiscard]] bool try_push_back(const value_type& value) {
270 return deque_.try_push_back(value);
271 }
272
279 [[nodiscard]] bool try_push_back(value_type&& value) {
280 return deque_.try_push_back(std::move(value));
281 }
282
286 void pop_back() { deque_.pop_back(); }
287
292 template <typename... Args>
293 void emplace_back(Args&&... args) {
294 deque_.emplace_back(std::forward<Args>(args)...);
295 }
296
303 template <typename... Args>
304 [[nodiscard]] bool try_emplace_back(Args&&... args) {
305 return deque_.try_emplace_back(std::forward<Args>(args)...);
306 }
307
308 // TODO: b/424613355 - Implement insert, emplace
309
315 auto deque_it = deque_.erase(ToDequeIterator(pos));
316 return iterator(data() + deque_it.pos_);
317 }
318
325 auto deque_it = deque_.erase(ToDequeIterator(first), ToDequeIterator(last));
326 return iterator(data() + deque_it.pos_);
327 }
328
336 void resize(size_type count) { deque_.resize(count); }
337
347 void resize(size_type count, const value_type& value) {
348 deque_.resize(count, value);
349 }
350
355 [[nodiscard]] bool try_resize(size_type count) {
356 return deque_.try_resize(count);
357 }
358
365 [[nodiscard]] bool try_resize(size_type count, const value_type& value) {
366 return deque_.try_resize(count, value);
367 }
368
370 void clear() { deque_.clear(); }
371
375 void swap(DynamicVector& other) { deque_.swap(other.deque_); }
376
377 private:
378 typename DynamicDeque<T, size_type>::const_iterator ToDequeIterator(
379 const_iterator it) const {
380 return {deque_, static_cast<size_type>(it - cbegin())};
381 }
382
383 // The underlying DynamicDeque instance that provides the storage.
384 DynamicDeque<T, size_type> deque_;
385};
386
387} // namespace pw
Definition: allocator.h:34
void reserve(size_type new_capacity)
Increases capacity() to at least new_capacity. Crashes on failure.
Definition: dynamic_deque.h:146
void reserve_exact(size_type new_capacity)
Increases capacity() to exactly new_capacity. Crashes on failure.
Definition: dynamic_deque.h:162
void swap(DynamicDeque &other) noexcept
Swaps the contents of two deques. No allocations occur.
Definition: dynamic_deque.h:177
bool try_reserve(size_type new_capacity)
Definition: dynamic_deque.h:235
bool try_assign(size_type count, const value_type &value)
Definition: generic_deque.h:612
void shrink_to_fit()
Attempts to reduce capacity() to size(). Not guaranteed to succeed.
Definition: dynamic_deque.h:256
constexpr allocator_type & get_allocator() const
Returns the deque's allocator.
Definition: dynamic_deque.h:174
bool try_reserve_exact(size_type new_capacity)
Definition: dynamic_deque.h:157
Definition: dynamic_vector.h:48
constexpr allocator_type & get_allocator() const
Returns the vector's allocator.
Definition: dynamic_vector.h:98
void clear()
Removes all elements from the vector.
Definition: dynamic_vector.h:370
size_type capacity() const
Definition: dynamic_vector.h:110
bool try_resize(size_type count, const value_type &value)
Definition: dynamic_vector.h:365
bool try_emplace_back(Args &&... args)
Definition: dynamic_vector.h:304
reference at(size_type pos)
Definition: dynamic_vector.h:180
reference operator[](size_type pos)
Definition: dynamic_vector.h:163
bool try_reserve(size_type new_capacity)
Definition: dynamic_vector.h:138
const_reference back() const
Definition: dynamic_vector.h:209
bool try_reserve_exact(size_type new_capacity)
Definition: dynamic_vector.h:148
void resize(size_type count)
Definition: dynamic_vector.h:336
void pop_back()
Definition: dynamic_vector.h:286
void emplace_back(Args &&... args)
Definition: dynamic_vector.h:293
reference front()
Definition: dynamic_vector.h:194
reference back()
Definition: dynamic_vector.h:204
size_type max_size() const
Maximum possible value of size(), ignoring allocator limitations.
Definition: dynamic_vector.h:113
void reserve(size_type new_capacity)
Definition: dynamic_vector.h:120
const_reference operator[](size_type pos) const
Definition: dynamic_vector.h:171
const_pointer data() const
Definition: dynamic_vector.h:224
void resize(size_type count, const value_type &value)
Definition: dynamic_vector.h:347
bool try_push_back(value_type &&value)
Definition: dynamic_vector.h:279
void shrink_to_fit()
Reduces memory usage by releasing unused capacity.
Definition: dynamic_vector.h:153
void push_back(value_type &&value)
Definition: dynamic_vector.h:261
const_reference front() const
Definition: dynamic_vector.h:199
constexpr DynamicVector(Allocator &allocator)
Definition: dynamic_vector.h:65
void push_back(const value_type &value)
Definition: dynamic_vector.h:255
bool try_push_back(const value_type &value)
Definition: dynamic_vector.h:269
void reserve_exact(size_type new_capacity)
Definition: dynamic_vector.h:127
iterator erase(const_iterator pos)
Definition: dynamic_vector.h:314
pointer data()
Definition: dynamic_vector.h:217
size_type size() const
Returns the number of elements in the vector.
Definition: dynamic_vector.h:106
const_reference at(size_type pos) const
Definition: dynamic_vector.h:189
iterator erase(const_iterator first, const_iterator last)
Definition: dynamic_vector.h:324
void assign(size_type count, const value_type &value)
Definition: dynamic_vector.h:233
bool empty() const
Checks if the vector is empty.
Definition: dynamic_vector.h:103
void swap(DynamicVector &other)
Definition: dynamic_vector.h:375
void assign(std::initializer_list< T > init)
Definition: dynamic_vector.h:245
bool try_resize(size_type count)
Definition: dynamic_vector.h:355
Definition: ptr_iterator.h:159
Definition: ptr_iterator.h:137
constexpr size_type size() const noexcept
Returns the number of elements in the deque.
Definition: generic_deque.h:58
iterator erase(const_iterator pos)
Erases the item at pos, which must be a dereferenceable iterator.
Definition: generic_deque.h:314
constexpr size_type capacity() const noexcept
Returns the maximum number of elements in the deque.
Definition: generic_deque.h:63
void assign(size_type count, const value_type &value)
Sets the contents to count copies of value. Crashes if cannot fit.
Definition: generic_deque.h:220
Provides basic helpers for reading and writing UTF-8 encoded strings.
Definition: alignment.h:27