5#ifndef BITCOIN_PREVECTOR_H
6#define BITCOIN_PREVECTOR_H
36template<
unsigned int N,
typename T,
typename Size = u
int32_t,
typename Diff =
int32_t>
38 static_assert(std::is_trivially_copyable_v<T>);
125 static_assert(
alignof(
char*) %
alignof(
size_type) == 0 &&
sizeof(
char*) %
alignof(
size_type) == 0,
"size_type cannot have more restrictive alignment requirement than pointer");
126 static_assert(
alignof(
char*) %
alignof(
T) == 0,
"value_type T cannot have more restrictive alignment requirement than pointer");
135 if (new_capacity <= N) {
140 memcpy(dst, src,
size() *
sizeof(
T));
153 char* new_indirect =
static_cast<char*
>(malloc(((
size_t)
sizeof(
T)) * new_capacity));
156 T* dst =
reinterpret_cast<T*
>(new_indirect);
157 memcpy(dst, src,
size() *
sizeof(
T));
169 std::fill_n(dst,
count, value);
172 template <std::input_iterator InputIterator>
173 void fill(
T* dst, InputIterator first, InputIterator last) {
174 while (first != last) {
175 new(
static_cast<void*
>(dst))
T(*first);
191 template <std::input_iterator InputIterator>
192 void assign(InputIterator first, InputIterator last) {
214 template <std::input_iterator InputIterator>
230 :
_union(std::move(other._union)),
_size(other._size)
236 if (&other ==
this) {
247 _union = std::move(other._union);
284 if (cur_size == new_size) {
287 if (cur_size > new_size) {
294 ptrdiff_t increase = new_size - cur_size;
321 memmove(dst, ptr, (
size() - p) *
sizeof(
T));
323 new(
static_cast<void*
>(ptr))
T(value);
335 memmove(dst, ptr, (
size() - p) *
sizeof(
T));
340 template <std::input_iterator InputIterator>
350 memmove(dst, ptr, (
size() - p) *
sizeof(
T));
352 fill(ptr, first, last);
363 if (new_size <
size()) {
371 return erase(pos, pos + 1);
382 char* endp = (
char*)&(*
end());
384 memmove(&(*first), &(*last), endp - ((
char*)(&(*last))));
388 template<
typename... Args>
424 std::swap(
_union, other._union);
425 std::swap(
_size, other._size);
443 if ((*b1) != (*b2)) {
453 return !(*
this == other);
bool operator==(const_iterator x) const
const_iterator & operator++()
const_iterator & operator+=(size_type n)
const_iterator friend operator+(size_type n, const_iterator x)
bool operator<(const_iterator x) const
const_iterator & operator-=(size_type n)
const_iterator operator--(int)
bool operator<=(const_iterator x) const
const_iterator operator++(int)
const_iterator(const T *ptr_)
const T * operator->() const
difference_type friend operator-(const_iterator a, const_iterator b)
bool operator!=(const_iterator x) const
const_iterator operator-(size_type n) const
bool operator>=(const_iterator x) const
const_iterator & operator--()
const T & operator*() const
const_iterator operator+(size_type n) const
std::contiguous_iterator_tag iterator_category
const T & operator[](size_type pos) const
bool operator>(const_iterator x) const
const_iterator(iterator x)
std::contiguous_iterator_tag iterator_category
bool operator<(iterator x) const
bool operator==(iterator x) const
difference_type friend operator-(iterator a, iterator b)
iterator operator-(size_type n) const
T & operator[](size_type pos) const
bool operator!=(iterator x) const
bool operator<=(iterator x) const
bool operator>=(iterator x) const
iterator & operator+=(size_type n)
iterator operator+(size_type n) const
iterator & operator-=(size_type n)
bool operator>(iterator x) const
iterator friend operator+(size_type n, iterator x)
Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without h...
void change_capacity(size_type new_capacity)
void fill(T *dst, ptrdiff_t count, const T &value=T{})
iterator erase(iterator first, iterator last)
prevector(InputIterator first, InputIterator last)
void swap(prevector< N, T, Size, Diff > &other) noexcept
prevector & operator=(prevector< N, T, Size, Diff > &&other) noexcept
const value_type & const_reference
bool operator==(const prevector< N, T, Size, Diff > &other) const
iterator erase(iterator pos)
prevector(size_type n, const T &val)
void fill(T *dst, InputIterator first, InputIterator last)
const T * indirect_ptr(difference_type pos) const
T * direct_ptr(difference_type pos)
const_iterator end() const
direct_or_indirect _union
void assign(InputIterator first, InputIterator last)
void emplace_back(Args &&... args)
void insert(iterator pos, InputIterator first, InputIterator last)
const T * item_ptr(difference_type pos) const
bool operator<(const prevector< N, T, Size, Diff > &other) const
const value_type * data() const
bool operator!=(const prevector< N, T, Size, Diff > &other) const
void reserve(size_type new_capacity)
prevector(const prevector< N, T, Size, Diff > &other)
const T & operator[](size_type pos) const
const T * direct_ptr(difference_type pos) const
void resize_uninitialized(size_type new_size)
T * item_ptr(difference_type pos)
T * indirect_ptr(difference_type pos)
prevector & operator=(const prevector< N, T, Size, Diff > &other)
void resize(size_type new_size)
size_t allocated_memory() const
iterator insert(iterator pos, const T &value)
prevector(prevector< N, T, Size, Diff > &&other) noexcept
const value_type * const_pointer
void assign(size_type n, const T &val)
void insert(iterator pos, size_type count, const T &value)
void push_back(const T &value)
const_iterator begin() const
T & operator[](size_type pos)
struct prevector::direct_or_indirect::@2 indirect_contents
char direct[sizeof(T) *N]