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>);
127 static_assert(
alignof(
char*) %
alignof(
size_type) == 0 &&
sizeof(
char*) %
alignof(
size_type) == 0,
"size_type cannot have more restrictive alignment requirement than pointer");
128 static_assert(
alignof(
char*) %
alignof(
T) == 0,
"value_type T cannot have more restrictive alignment requirement than pointer");
137 if (new_capacity <= N) {
142 memcpy(dst, src,
size() *
sizeof(
T));
155 char* new_indirect =
static_cast<char*
>(malloc(((
size_t)
sizeof(
T)) * new_capacity));
158 T* dst =
reinterpret_cast<T*
>(new_indirect);
159 memcpy(dst, src,
size() *
sizeof(
T));
171 std::fill_n(dst,
count, value);
174 template <std::input_iterator InputIterator>
175 void fill(
T* dst, InputIterator first, InputIterator last) {
176 while (first != last) {
177 new(
static_cast<void*
>(dst))
T(*first);
193 template <std::input_iterator InputIterator>
194 void assign(InputIterator first, InputIterator last) {
216 template <std::input_iterator InputIterator>
232 :
_union(std::move(other._union)),
_size(other._size)
238 if (&other ==
this) {
249 _union = std::move(other._union);
286 if (cur_size == new_size) {
289 if (cur_size > new_size) {
296 ptrdiff_t increase = new_size - cur_size;
323 memmove(dst, ptr, (
size() - p) *
sizeof(
T));
325 new(
static_cast<void*
>(ptr))
T(value);
337 memmove(dst, ptr, (
size() - p) *
sizeof(
T));
342 template <std::input_iterator InputIterator>
352 memmove(dst, ptr, (
size() - p) *
sizeof(
T));
354 fill(ptr, first, last);
365 if (new_size <
size()) {
373 return erase(pos, pos + 1);
384 char* endp = (
char*)&(*
end());
386 memmove(&(*first), &(*last), endp - ((
char*)(&(*last))));
390 template<
typename... Args>
426 std::swap(
_union, other._union);
427 std::swap(
_size, other._size);
445 if ((*b1) != (*b2)) {
455 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
static constexpr unsigned int STATIC_SIZE
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]