Overview

Submodules
	C++ API

Classes
class	pw::Deque< T, SizeType >

class	pw::FixedDeque< T, kInlineCapacity, S >

class	pw::FixedDeque< T, containers::kExternalStorage, S >

class	pw::DynamicDeque< ValueType, SizeType >

class	pw::DynamicQueue< T, SizeType >

class	pw::BasicInlineAsyncDeque< ValueType, SizeType, kCapacity >

class	pw::BasicInlineAsyncQueue< ValueType, SizeType, kCapacity >

class	pw::BasicInlineQueue< ValueType, SizeType, kCapacity >

class	pw::BasicInlineQueue< ValueType, SizeType, containers::internal::kGenericSized >

class	pw::containers::internal::GenericDequeBase< CountAndCapacityType >

class	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >

class	pw::Queue< T, SizeType >

class	pw::FixedQueue< T, kInlineCapacity, SizeType >

class	pw::FixedQueue< T, containers::kExternalStorage, S >

Typedefs
using	pw::DynamicDeque< ValueType, SizeType >::allocator_type = Allocator

using	pw::DynamicQueue< T, SizeType >::const_iterator = typename Deque::const_iterator

using	pw::DynamicQueue< T, SizeType >::const_pointer = typename Deque::const_pointer

using	pw::DynamicQueue< T, SizeType >::const_reference = typename Deque::const_reference

using	pw::DynamicQueue< T, SizeType >::difference_type = typename Deque::difference_type

using	pw::DynamicQueue< T, SizeType >::iterator = typename Deque::iterator

using	pw::DynamicQueue< T, SizeType >::pointer = typename Deque::pointer

using	pw::DynamicQueue< T, SizeType >::reference = typename Deque::reference

using	pw::DynamicQueue< T, SizeType >::size_type = typename Deque::size_type

using	pw::DynamicQueue< T, SizeType >::value_type = typename Deque::value_type

template<typename T , size_t kCapacity = containers::internal::kGenericSized>
using	pw::InlineAsyncDeque = BasicInlineAsyncDeque< T, uint16_t, kCapacity >

template<typename ValueType , size_t kCapacity = containers::internal::kGenericSized>
using	pw::InlineAsyncQueue = BasicInlineAsyncQueue< ValueType, uint16_t, kCapacity >

template<typename T , size_t kCapacity = containers::internal::kGenericSized>
using	pw::InlineQueue = BasicInlineQueue< T, uint16_t, kCapacity >

using	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::size_type = typename CountAndCapacityType::size_type

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::value_type = ValueType

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::size_type = typename CountAndCapacityType::size_type

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::difference_type = ptrdiff_t

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::reference = value_type &

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::const_reference = const value_type &

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::pointer = value_type *

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::const_pointer = const value_type *

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::iterator = containers::internal::DequeIterator< Derived >

using	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::const_iterator = containers::internal::DequeIterator< const Derived >

Functions
constexpr	pw::Deque< T, SizeType >::Deque (span< std::byte > unaligned_buffer) noexcept

template<size_t kAlignment, size_t kSizeBytes>
constexpr	pw::Deque< T, SizeType >::Deque (containers::Storage< kAlignment, kSizeBytes > &buffer) noexcept

	pw::Deque< T, SizeType >::Deque (const Deque &)=delete
	Copying is not supported since it can fail.

Deque &	pw::Deque< T, SizeType >::operator= (const Deque &)=delete

	pw::Deque< T, SizeType >::Deque (Deque &&)=delete
	Move is not supported to avoid confusion about deque/buffer pairings.

Deque &	pw::Deque< T, SizeType >::operator= (Deque &&)=delete

constexpr size_type	pw::Deque< T, SizeType >::max_size () const noexcept

static constexpr Aligned	pw::Deque< T, SizeType >::Aligned::Align (span< std::byte > unaligned_buffer)

static constexpr Aligned	pw::Deque< T, SizeType >::Aligned::Assert (std::byte *data, size_t size)

constexpr	pw::Deque< T, SizeType >::Aligned::Aligned (std::byte *aligned_data, size_t size_bytes)

constexpr std::byte *	pw::Deque< T, SizeType >::Aligned::data () const

constexpr size_t	pw::Deque< T, SizeType >::Aligned::capacity () const

constexpr	pw::FixedDeque< T, kInlineCapacity, S >::FixedDeque ()

	pw::FixedDeque< T, kInlineCapacity, S >::FixedDeque (const FixedDeque &)=delete

FixedDeque &	pw::FixedDeque< T, kInlineCapacity, S >::operator= (const FixedDeque &)=delete

constexpr	pw::FixedDeque< T, kInlineCapacity, S >::FixedDeque (FixedDeque &&other) noexcept

constexpr FixedDeque &	pw::FixedDeque< T, kInlineCapacity, S >::operator= (FixedDeque &&other) noexcept

template<size_t kOtherCapacity>
	pw::FixedDeque< T, kInlineCapacity, S >::MoveItemsFrom (other)

template<size_t kOtherCapacity>
	pw::FixedDeque< T, kInlineCapacity, S >::clear ()

this	pw::FixedDeque< T, kInlineCapacity, S >::MoveItemsFrom (other)

template<size_t kOtherCapacity>
void	pw::FixedDeque< T, kInlineCapacity, S >::swap (FixedDeque< T, kOtherCapacity, S > &other)

constexpr Deallocator *	pw::FixedDeque< T, kInlineCapacity, S >::deallocator () const
	Returns `nullptr`; a `FixedDeque` with static storage never allocates.

static FixedDeque	pw::FixedDeque< T, containers::kExternalStorage, S >::Allocate (Allocator &allocator, const S capacity)

static FixedDeque	pw::FixedDeque< T, containers::kExternalStorage, S >::TryAllocate (Allocator &allocator, S capacity)

static FixedDeque	pw::FixedDeque< T, containers::kExternalStorage, S >::WithStorage (UniquePtr< std::byte[]> &&storage)

constexpr	pw::FixedDeque< T, containers::kExternalStorage, S >::FixedDeque (span< std::byte > unaligned_buffer) noexcept

template<size_t kAlignment, size_t kSizeBytes>
constexpr	pw::FixedDeque< T, containers::kExternalStorage, S >::FixedDeque (containers::Storage< kAlignment, kSizeBytes > &buffer) noexcept

	pw::FixedDeque< T, containers::kExternalStorage, S >::FixedDeque (const FixedDeque &)=delete
	Copying is not supported since it can fail.

FixedDeque &	pw::FixedDeque< T, containers::kExternalStorage, S >::operator= (const FixedDeque &)=delete

constexpr	pw::FixedDeque< T, containers::kExternalStorage, S >::FixedDeque (FixedDeque &&other) noexcept

constexpr FixedDeque &	pw::FixedDeque< T, containers::kExternalStorage, S >::operator= (FixedDeque &&other) noexcept

void	pw::FixedDeque< T, containers::kExternalStorage, S >::swap (FixedDeque &other) noexcept

template<size_t kInlineCapacity>
void	pw::FixedDeque< T, containers::kExternalStorage, S >::swap (FixedDeque< T, kInlineCapacity, S > &other)

constexpr Deallocator *	pw::FixedDeque< T, containers::kExternalStorage, S >::deallocator () const

constexpr	pw::DynamicDeque< ValueType, SizeType >::DynamicDeque (Allocator &allocator) noexcept

	pw::DynamicDeque< ValueType, SizeType >::DynamicDeque (const DynamicDeque &)=delete

DynamicDeque &	pw::DynamicDeque< ValueType, SizeType >::operator= (const DynamicDeque &)=delete

constexpr	pw::DynamicDeque< ValueType, SizeType >::DynamicDeque (DynamicDeque &&other) noexcept

DynamicDeque &	pw::DynamicDeque< ValueType, SizeType >::operator= (DynamicDeque &&other) noexcept

template<typename InputIt , typename = containers::internal::EnableIfInputIterator<InputIt>>
iterator	pw::DynamicDeque< ValueType, SizeType >::insert (const_iterator pos, InputIt first, InputIt last)

iterator	pw::DynamicDeque< ValueType, SizeType >::insert (const_iterator pos, const value_type &value)

iterator	pw::DynamicDeque< ValueType, SizeType >::insert (const_iterator pos, value_type &&value)

iterator	pw::DynamicDeque< ValueType, SizeType >::insert (const_iterator pos, size_type count, const value_type &value)

iterator	pw::DynamicDeque< ValueType, SizeType >::insert (const_iterator pos, std::initializer_list< value_type > ilist)

bool	pw::DynamicDeque< ValueType, SizeType >::try_reserve (size_type new_capacity)

void	pw::DynamicDeque< ValueType, SizeType >::reserve (size_type new_capacity)
	Increases `capacity()` to at least `new_capacity`. Crashes on failure.

bool	pw::DynamicDeque< ValueType, SizeType >::try_reserve_exact (size_type new_capacity)

void	pw::DynamicDeque< ValueType, SizeType >::reserve_exact (size_type new_capacity)
	Increases `capacity()` to exactly `new_capacity`. Crashes on failure.

void	pw::DynamicDeque< ValueType, SizeType >::shrink_to_fit ()
	Attempts to reduce `capacity()` to `size()`. Not guaranteed to succeed.

constexpr size_type	pw::DynamicDeque< ValueType, SizeType >::max_size () const noexcept

constexpr allocator_type &	pw::DynamicDeque< ValueType, SizeType >::get_allocator () const
	Returns the deque's allocator.

void	pw::DynamicDeque< ValueType, SizeType >::swap (DynamicDeque &other) noexcept
	Swaps the contents of two deques. No allocations occur.

constexpr	pw::DynamicQueue< T, SizeType >::DynamicQueue (pw::Allocator &allocator)
	Constructs a `DynamicQueue` using the provided allocator.

	pw::DynamicQueue< T, SizeType >::DynamicQueue (const DynamicQueue &)=delete

DynamicQueue &	pw::DynamicQueue< T, SizeType >::operator= (const DynamicQueue &)=delete

constexpr	pw::DynamicQueue< T, SizeType >::DynamicQueue (DynamicQueue &&)=default
	Move operations are supported and incur no allocations.

DynamicQueue &	pw::DynamicQueue< T, SizeType >::operator= (DynamicQueue &&)=default

bool	pw::DynamicQueue< T, SizeType >::try_push (const value_type &value)
	Attempts to add an element to the back of the queue.

bool	pw::DynamicQueue< T, SizeType >::try_push (value_type &&value)
	Attempts to add an element to the back of the queue (move version).

template<typename... Args>
bool	pw::DynamicQueue< T, SizeType >::try_emplace (Args &&... args)
	Attempts to construct an element in place at the back of the queue.

void	pw::DynamicQueue< T, SizeType >::reserve (size_type capacity)
	Sets the queue capacity to at least `max(capacity, size())` elements.

bool	pw::DynamicQueue< T, SizeType >::try_reserve (size_type capacity)

void	pw::DynamicQueue< T, SizeType >::reserve_exact (size_type capacity)
	Sets the queue capacity to `max(capacity, size())` elements.

bool	pw::DynamicQueue< T, SizeType >::try_reserve_exact (size_type capacity)
	Attempts to set the queue capacity to `max(capacity, size())` elements.

void	pw::DynamicQueue< T, SizeType >::shrink_to_fit ()
	Reduces memory usage by releasing unused capacity, if possible.

void	pw::DynamicQueue< T, SizeType >::swap (DynamicQueue &other)
	Swaps the contents with another queue.

constexpr bool	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::empty () const noexcept

constexpr bool	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::full () const noexcept

constexpr size_type	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::size () const noexcept
	Returns the number of elements in the deque.

constexpr size_type	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::capacity () const noexcept
	Returns the maximum number of elements in the deque.

CountAndCapacityType &	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::count_and_capacity () noexcept

constexpr void	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::MoveAssignIndices (GenericDequeBase &other) noexcept

void	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::SwapIndices (GenericDequeBase &other) noexcept

bool	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::CanExtendBuffer () const

bool	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::CanShrinkBuffer () const

void	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::HandleNewBuffer (size_type new_capacity)

void	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::HandleExtendedBuffer (size_type new_capacity)

void	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::HandleShrunkBuffer (size_type new_capacity)

	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::GenericDeque (const GenericDeque &)=delete

	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::GenericDeque (GenericDeque &&)=delete

GenericDeque &	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::operator= (const GenericDeque &)=delete

GenericDeque &&	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::operator= (GenericDeque &&)=delete

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::assign (size_type count, const value_type &value)
	Sets the contents to `count` copies of `value`. Crashes if cannot fit.

template<typename It , int & ..., typename = containers::internal::EnableIfInputIterator<It>>
void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::assign (It start, It finish)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::assign (const std::initializer_list< value_type > &list)
	Sets contents to copies of the items from the list. Crashes if cannot fit.

constexpr reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::at (size_type index)

constexpr const_reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::at (size_type index) const

constexpr reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::operator[] (size_type index)

constexpr const_reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::operator[] (size_type index) const

constexpr reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::front ()

constexpr const_reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::front () const

constexpr reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::back ()

constexpr const_reference	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::back () const

constexpr std::pair< span< const value_type >, span< const value_type > >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::contiguous_data () const
	Provides access to the valid data in a contiguous form.

constexpr std::pair< span< value_type >, span< value_type > >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::contiguous_data ()

constexpr iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::begin () noexcept

constexpr const_iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::begin () const noexcept

constexpr const_iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::cbegin () const noexcept

constexpr iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::end () noexcept

constexpr const_iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::end () const noexcept

constexpr const_iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::cend () const noexcept

constexpr void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::clear ()

iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::erase (const_iterator pos)
	Erases the item at `pos`, which must be a dereferenceable iterator.

iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::erase (const_iterator first, const_iterator last)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::push_back (const value_type &value)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::push_back (value_type &&value)

template<typename... Args>
void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::emplace_back (Args &&... args)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::pop_back ()

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::push_front (const value_type &value)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::push_front (value_type &&value)

template<typename... Args>
void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::emplace_front (Args &&... args)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::pop_front ()

template<typename... Args>
iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::emplace (const_iterator pos, Args &&... args)

iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert (const_iterator pos, const value_type &value)

iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert (const_iterator pos, value_type &&value)

iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert (const_iterator pos, size_type count, const value_type &value)

template<typename InputIt , typename = containers::internal::EnableIfInputIterator<InputIt>>
iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert (const_iterator pos, InputIt first, InputIt last)

iterator	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert (const_iterator pos, std::initializer_list< value_type > ilist)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::resize (size_type new_size)

void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::resize (size_type new_size, const value_type &value)

constexpr	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::GenericDeque (size_type initial_capacity) noexcept

constexpr void	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::DestroyAll ()

Derived &	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::operator= (const std::initializer_list< value_type > &list)

template<typename T , typename = containers::internal::EnableIfIterable<T>>
Derived &	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::operator= (const T &other)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_assign (size_type count, const value_type &value)

template<typename It , int & ..., typename = containers::internal::EnableIfForwardIterator<It>>
bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_assign (It start, It finish)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_assign (const std::initializer_list< value_type > &list)

template<typename... Args>
std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_emplace (const_iterator pos, Args &&... args)

std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert (const_iterator pos, const value_type &value)

std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert (const_iterator pos, value_type &&value)

std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert (const_iterator pos, size_type count, const value_type &value)

template<typename ForwardIt , typename = containers::internal::EnableIfForwardIterator<ForwardIt>>
std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert (const_iterator pos, ForwardIt first, ForwardIt last)

std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert (const_iterator pos, std::initializer_list< value_type > ilist)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_push_back (const value_type &value)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_push_back (value_type &&value)

template<typename... Args>
bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_emplace_back (Args &&... args)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_push_front (const value_type &value)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_push_front (value_type &&value)

template<typename... Args>
bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_emplace_front (Args &&... args)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_resize (size_type new_size)

bool	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_resize (size_type new_size, const value_type &value)

template<typename... Args>
std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_emplace_shift_right (const_iterator pos, Args &&... args)

std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert_shift_right (const_iterator pos, size_type count, const value_type &value)

template<typename ForwardIt , typename = containers::internal::EnableIfForwardIterator<ForwardIt>>
std::optional< iterator >	pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert_shift_right (const_iterator pos, ForwardIt first, ForwardIt last)

constexpr	pw::Queue< T, SizeType >::Queue (span< std::byte > unaligned_buffer) noexcept

template<size_t kAlignment, size_t kSizeBytes>
constexpr	pw::Queue< T, SizeType >::Queue (containers::Storage< kAlignment, kSizeBytes > &storage) noexcept

	pw::Queue< T, SizeType >::Queue (const Queue &)=delete

Queue &	pw::Queue< T, SizeType >::operator= (const Queue &)=delete

	pw::Queue< T, SizeType >::Queue (Queue &&)=delete

Queue &	pw::Queue< T, SizeType >::operator= (Queue &&)=delete

constexpr	pw::FixedQueue< T, kInlineCapacity, SizeType >::FixedQueue ()

	pw::FixedQueue< T, kInlineCapacity, SizeType >::FixedQueue (const FixedQueue &)=delete

FixedQueue &	pw::FixedQueue< T, kInlineCapacity, SizeType >::operator= (const FixedQueue &)=delete

constexpr	pw::FixedQueue< T, kInlineCapacity, SizeType >::FixedQueue (FixedQueue &&other) noexcept

constexpr FixedQueue &	pw::FixedQueue< T, kInlineCapacity, SizeType >::operator= (FixedQueue &&other) noexcept

template<size_t kOtherCapacity>
	pw::FixedQueue< T, kInlineCapacity, SizeType >::MoveItemsFrom (other)

template<size_t kOtherCapacity>
	pw::FixedQueue< T, kInlineCapacity, SizeType >::clear ()

this	pw::FixedQueue< T, kInlineCapacity, SizeType >::MoveItemsFrom (other)

template<size_t kOtherCapacity>
void	pw::FixedQueue< T, kInlineCapacity, SizeType >::swap (FixedQueue< T, kOtherCapacity, SizeType > &other)

constexpr Deallocator *	pw::FixedQueue< T, kInlineCapacity, SizeType >::deallocator () const
	Returns `nullptr`; a `FixedQueue` with static storage never allocates.

static FixedQueue	pw::FixedQueue< T, containers::kExternalStorage, S >::Allocate (Allocator &allocator, const S capacity)

static FixedQueue	pw::FixedQueue< T, containers::kExternalStorage, S >::TryAllocate (Allocator &allocator, S capacity)

static FixedQueue	pw::FixedQueue< T, containers::kExternalStorage, S >::WithStorage (UniquePtr< std::byte[]> &&storage)

constexpr	pw::FixedQueue< T, containers::kExternalStorage, S >::FixedQueue (span< std::byte > unaligned_buffer) noexcept

template<size_t kAlignment, size_t kSizeBytes>
constexpr	pw::FixedQueue< T, containers::kExternalStorage, S >::FixedQueue (containers::Storage< kAlignment, kSizeBytes > &buffer) noexcept

	pw::FixedQueue< T, containers::kExternalStorage, S >::FixedQueue (const FixedQueue &)=delete
	Copying is not supported since it can fail.

FixedQueue &	pw::FixedQueue< T, containers::kExternalStorage, S >::operator= (const FixedQueue &)=delete

constexpr	pw::FixedQueue< T, containers::kExternalStorage, S >::FixedQueue (FixedQueue &&other) noexcept

constexpr FixedQueue &	pw::FixedQueue< T, containers::kExternalStorage, S >::operator= (FixedQueue &&other) noexcept

void	pw::FixedQueue< T, containers::kExternalStorage, S >::swap (FixedQueue &other) noexcept

template<size_t kInlineCapacity>
void	pw::FixedQueue< T, containers::kExternalStorage, S >::swap (FixedQueue< T, kInlineCapacity, S > &other)

constexpr Deallocator *	pw::FixedQueue< T, containers::kExternalStorage, S >::deallocator () const

Variables
return *	pw::FixedDeque< T, kInlineCapacity, S >::this

return *	pw::FixedQueue< T, kInlineCapacity, SizeType >::this

Friends
template<typename , typename >
class	pw::Deque< T, SizeType >::Queue

template<typename , size_t , typename >
class	pw::Deque< T, SizeType >::FixedDeque

template<typename , typename >
class	pw::DynamicDeque< ValueType, SizeType >::DynamicVector

template<typename Derived , typename ValueType , typename S >
class	pw::containers::internal::GenericDequeBase< CountAndCapacityType >::GenericDeque

template<typename , typename >
class	pw::Queue< T, SizeType >::containers::internal::GenericQueue

template<typename , size_t , typename >
class	pw::Queue< T, SizeType >::FixedQueue

Typedef Documentation

◆ InlineAsyncDeque

template<typename T , size_t kCapacity = containers::internal::kGenericSized>

using pw::InlineAsyncDeque = typedef BasicInlineAsyncDeque<T, uint16_t, kCapacity>

Async wrapper around pw::InlineDeque.

This class mimics the structure of BasicInlineDeque to allow referring to an InlineAsyncDeque without an explicit maximum size.

Warning: InlineAsyncDeque is NOT thread safe. External synchronization is required to share an InlineAsyncDeque between threads.

◆ InlineAsyncQueue

template<typename ValueType , size_t kCapacity = containers::internal::kGenericSized>

using pw::InlineAsyncQueue = typedef BasicInlineAsyncQueue<ValueType, uint16_t, kCapacity>

Async wrapper around pw::InlineQueue.

This class mimics the structure of BasicInlineQueue to allow referring to an InlineAsyncQueue without an explicit maximum size.

Warning: InlineAsyncQueue is NOT thread safe. External synchronization is required to share an InlineAsyncQueue between threads.

◆ InlineQueue

template<typename T , size_t kCapacity = containers::internal::kGenericSized>

using pw::InlineQueue = typedef BasicInlineQueue<T, uint16_t, kCapacity>

The InlineQueue class is similar to std::queue<T, std::deque>, except it is backed by a fixed-size buffer. InlineQueue's must be declared with an explicit maximum size (e.g. InlineQueue<int, 10>>) but deques can be used and referred to without the max size template parameter (e.g. InlineQueue<int>).

pw::InlineQueue is wrapper around pw::InlineDeque with a simplified API and push_overwrite() & emplace_overwrite() helpers.

Function Documentation

◆ Allocate() [1/2]

template<typename T , typename S >

static FixedDeque pw::FixedDeque< T, containers::kExternalStorage, S >::Allocate	(	Allocator &	allocator,
		const S	capacity
	)

inlinestatic

Allocates a buffer large enough to hold capacity items and uses it for a FixedDeque's buffer. Crashes if unable to allocate space for capacity items.

The FixedDeque owns the buffer and frees it upon destruction.

◆ Allocate() [2/2]

template<typename T , typename S >

static FixedQueue pw::FixedQueue< T, containers::kExternalStorage, S >::Allocate	(	Allocator &	allocator,
		const S	capacity
	)

inlinestatic

Allocates a buffer large enough to hold capacity items and uses it for a FixedQueue's buffer. Crashes if unable to allocate space for capacity items.

The FixedQueue owns the buffer and frees it upon destruction.

◆ assign()

template<typename Derived , typename ValueType , typename CountAndCapacityType >

template<typename It , int & ..., typename >

void pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::assign	(	It	start,
		It	finish
	)

Sets the contents to copies of the items from the iterator. Crashes if cannot fit.

◆ deallocator() [1/2]

template<typename T , typename S >

constexpr Deallocator * pw::FixedDeque< T, containers::kExternalStorage, S >::deallocator ( ) const

inlineconstexpr

Returns the deallocator that will be used to free this FixedDeque's storage. Returns nullptr if the storage is unowned.

◆ deallocator() [2/2]

template<typename T , typename S >

constexpr Deallocator * pw::FixedQueue< T, containers::kExternalStorage, S >::deallocator ( ) const

inlineconstexpr

Returns the deallocator that will be used to free this FixedQueue's storage. Returns nullptr if the storage is unowned.

◆ Deque() [1/2]

template<typename T , typename SizeType = uint16_t>

template<size_t kAlignment, size_t kSizeBytes>

constexpr pw::Deque< T, SizeType >::Deque ( containers::Storage< kAlignment, kSizeBytes > & buffer )

inlineexplicitconstexprnoexcept

Constructs an empty Deque using a pw::containers::Storage buffer. This constructor avoids run time alignment checks.

◆ Deque() [2/2]

template<typename T , typename SizeType = uint16_t>

constexpr pw::Deque< T, SizeType >::Deque ( span< std::byte > unaligned_buffer )

inlineexplicitconstexprnoexcept

Constructs an empty Deque using the provided buffer for storage.

Parameters

unaligned_buffer Storage for the deque. If the buffer is not aligned as as value_type, an aligned subset of the buffer will be used. If the buffer is too small to hold at least one value_type, the queue's capacity will be 0.

◆ DynamicDeque() [1/2]

template<typename ValueType , typename SizeType = uint16_t>

constexpr pw::DynamicDeque< ValueType, SizeType >::DynamicDeque ( Allocator & allocator )

inlineconstexprnoexcept

Constructs an empty DynamicDeque. No memory is allocated.

Since allocations can fail, initialization in the constructor is not supported.

◆ DynamicDeque() [2/2]

template<typename ValueType , typename SizeType = uint16_t>

constexpr pw::DynamicDeque< ValueType, SizeType >::DynamicDeque ( DynamicDeque< ValueType, SizeType > && other )

inlineconstexprnoexcept

Move construction/assignment is supported since it cannot fail. Copy construction/assignment is not supported. Can use assign()/try_assign() instead.

◆ emplace()

template<typename Derived , typename ValueType , typename CountAndCapacityType >

template<typename... Args>

iterator pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::emplace	(	const_iterator	pos,
		Args &&...	args
	)

inline

Constructs an item in place at pos. Crashes if memory allocation fails.

Returns: an iterator to the emplaced item.

◆ erase()

template<typename Derived , typename ValueType , typename CountAndCapacityType >

GenericDeque< Derived, ValueType, CountAndCapacityType >::iterator pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::erase	(	const_iterator	first,
		const_iterator	last
	)

Erases the items in the range [first, last). Does nothing if first == last.

◆ FixedDeque() [1/4]

template<typename T , size_t kInlineCapacity = containers::kExternalStorage, typename S = typename Deque<T>::size_type>

constexpr pw::FixedDeque< T, kInlineCapacity, S >::FixedDeque ( )

inlineconstexpr

Constructs an empty FixedDeque with internal, statically allocated storage.

◆ FixedDeque() [2/4]

template<typename T , typename S >

template<size_t kAlignment, size_t kSizeBytes>

constexpr pw::FixedDeque< T, containers::kExternalStorage, S >::FixedDeque ( containers::Storage< kAlignment, kSizeBytes > & buffer )

inlineexplicitconstexprnoexcept

Constructs an empty FixedDeque using a pw::containers::Storage buffer. This constructor avoids run time alignment checks.

The buffer is unowned and is not freed when the FixedDeque is destroyed.

◆ FixedDeque() [3/4]

template<typename T , typename S >

constexpr pw::FixedDeque< T, containers::kExternalStorage, S >::FixedDeque ( FixedDeque< T, containers::kExternalStorage, S > && other )

inlineconstexprnoexcept

Move construction/assignment from other FixedDeques with external buffers is supported and infallible. To move items from a statically allocated FixedDeque, use assign() with std::make_move_iterator, or move items individually.

◆ FixedDeque() [4/4]

template<typename T , typename S >

constexpr pw::FixedDeque< T, containers::kExternalStorage, S >::FixedDeque ( span< std::byte > unaligned_buffer )

inlineexplicitconstexprnoexcept

Constructs an FixedDeque from a buffer. The buffer is unowned and is not freed when the FixedDeque is destroyed.

Parameters

unaligned_buffer Storage for the deque. If the buffer is not aligned as as value_type, an aligned subset of the buffer will be used. If the buffer is too small to hold at least one value_type, the queue's capacity will be 0.

◆ FixedQueue() [1/4]

template<typename T , size_t kInlineCapacity = containers::kExternalStorage, typename SizeType = typename Queue<T>::size_type>

constexpr pw::FixedQueue< T, kInlineCapacity, SizeType >::FixedQueue ( )

inlineconstexpr

Constructs an empty FixedQueue with internal, statically allocated storage.

◆ FixedQueue() [2/4]

template<typename T , typename S >

template<size_t kAlignment, size_t kSizeBytes>

constexpr pw::FixedQueue< T, containers::kExternalStorage, S >::FixedQueue ( containers::Storage< kAlignment, kSizeBytes > & buffer )

inlineexplicitconstexprnoexcept

Constructs an empty FixedQueue using a pw::containers::Storage buffer. This constructor avoids run time alignment checks.

The buffer is unowned and is not freed when the FixedQueue is destroyed.

◆ FixedQueue() [3/4]

template<typename T , typename S >

constexpr pw::FixedQueue< T, containers::kExternalStorage, S >::FixedQueue ( FixedQueue< T, containers::kExternalStorage, S > && other )

inlineconstexprnoexcept

Move construction/assignment from other FixedQueues with external buffers is supported and infallible. To move items from a statically allocated FixedQueue, use assign() with std::make_move_iterator, or move items individually.

◆ FixedQueue() [4/4]

template<typename T , typename S >

constexpr pw::FixedQueue< T, containers::kExternalStorage, S >::FixedQueue ( span< std::byte > unaligned_buffer )

inlineexplicitconstexprnoexcept

Constructs an FixedQueue from a buffer. The buffer is unowned and is not freed when the FixedQueue is destroyed.

Parameters

unaligned_buffer Storage for the queue. If the buffer is not aligned as as value_type, an aligned subset of the buffer will be used. If the buffer is too small to hold at least one value_type, the queue's capacity will be 0.

◆ insert() [1/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

iterator pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert	(	const_iterator	pos,
		const value_type &	value
	)

inline

Inserts a copy of an item at pos. Crashes if memory allocation fails.

Returns: an iterator to the inserted item.

◆ insert() [2/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

template<typename InputIt , typename >

GenericDeque< Derived, ValueType, CountAndCapacityType >::iterator pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert	(	const_iterator	pos,
		InputIt	first,
		InputIt	last
	)

Inserts the contents of an iterator at pos. Crashes if memory allocation fails.

Returns: an iterator to the first inserted item.

◆ insert() [3/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

iterator pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert	(	const_iterator	pos,
		size_type	count,
		const value_type &	value
	)

inline

Inserts count copies of value at pos. Crashes if memory allocation fails.

Returns: an iterator to the first inserted item.

◆ insert() [4/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

iterator pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert	(	const_iterator	pos,
		std::initializer_list< value_type >	ilist
	)

inline

Inserts an initializer list at pos. Crashes if memory allocation fails.

Returns: an iterator to the first inserted item.

◆ insert() [5/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

iterator pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::insert	(	const_iterator	pos,
		value_type &&	value
	)

inline

Inserts an item at pos using move semanatics. Crashes if memory allocation fails.

Returns: an iterator to the inserted item.

◆ MoveItemsFrom() [1/2]

template<typename T , size_t kInlineCapacity = containers::kExternalStorage, typename S = typename Deque<T>::size_type>

template<size_t kOtherCapacity>

pw::FixedDeque< T, kInlineCapacity, S >::MoveItemsFrom ( other )

FixedDeque supports moves that are guaranteed to succeed (moving into equal or greater capacity or between deques with external storage).

◆ MoveItemsFrom() [2/2]

template<typename T , size_t kInlineCapacity = containers::kExternalStorage, typename SizeType = typename Queue<T>::size_type>

template<size_t kOtherCapacity>

pw::FixedQueue< T, kInlineCapacity, SizeType >::MoveItemsFrom ( other )

FixedQueue supports moves that are guaranteed to succeed (moving into equal or greater capacity or between queues with external storage).

◆ Queue() [1/2]

template<typename T , typename SizeType = uint16_t>

template<size_t kAlignment, size_t kSizeBytes>

constexpr pw::Queue< T, SizeType >::Queue ( containers::Storage< kAlignment, kSizeBytes > & storage )

inlineexplicitconstexprnoexcept

Constructs an empty Queue using a pw::containers::Storage buffer. This constructor avoids run time alignment checks.

◆ Queue() [2/2]

template<typename T , typename SizeType = uint16_t>

constexpr pw::Queue< T, SizeType >::Queue ( span< std::byte > unaligned_buffer )

inlineexplicitconstexprnoexcept

Constructs an empty Queue using the provided buffer for storage.

Parameters

unaligned_buffer Storage for the queue. If the buffer is not aligned as as value_type, an aligned subset of the buffer will be used. If the buffer is too small to hold at least one value_type, the queue's capacity will be 0.

◆ swap() [1/6]

template<typename T , typename S >

void pw::FixedDeque< T, containers::kExternalStorage, S >::swap ( FixedDeque< T, containers::kExternalStorage, S > & other )

inlinenoexcept

Swaps this FixedDeque with another externally allocated FixedDeque in O(1) time. No allocations occur, and individual items are not moved.

◆ swap() [2/6]

template<typename T , typename S >

template<size_t kInlineCapacity>

void pw::FixedDeque< T, containers::kExternalStorage, S >::swap ( FixedDeque< T, kInlineCapacity, S > & other )

inline

Swaps the contents of this FixedDeque with an internal-storage FixedDeque in O(n) time. No allocations occur, but items are moved individually. Crashes if the size of one deque exceeds the capacity of the other.

◆ swap() [3/6]

template<typename T , size_t kInlineCapacity = containers::kExternalStorage, typename S = typename Deque<T>::size_type>

template<size_t kOtherCapacity>

void pw::FixedDeque< T, kInlineCapacity, S >::swap ( FixedDeque< T, kOtherCapacity, S > & other )

inline

Swaps the contents of this FixedDeque with another, in O(n) time. Crashes if one deque's size is greater than the other's capacity.

◆ swap() [4/6]

template<typename T , typename S >

void pw::FixedQueue< T, containers::kExternalStorage, S >::swap ( FixedQueue< T, containers::kExternalStorage, S > & other )

inlinenoexcept

Swaps this FixedQueue with another externally allocated FixedQueue in O(1) time. No allocations occur, and individual items are not moved.

◆ swap() [5/6]

template<typename T , typename S >

template<size_t kInlineCapacity>

void pw::FixedQueue< T, containers::kExternalStorage, S >::swap ( FixedQueue< T, kInlineCapacity, S > & other )

inline

Swaps the contents of this FixedQueue with an internal-storage FixedQueue in O(n) time. No allocations occur, but items are moved individually. Crashes if the size of one queue exceeds the capacity of the other.

◆ swap() [6/6]

template<typename T , size_t kInlineCapacity = containers::kExternalStorage, typename SizeType = typename Queue<T>::size_type>

template<size_t kOtherCapacity>

void pw::FixedQueue< T, kInlineCapacity, SizeType >::swap ( FixedQueue< T, kOtherCapacity, SizeType > & other )

inline

Swaps the contents of this FixedQueue with another, in O(n) time. Crashes if one queue's size is greater than the other's capacity.

◆ try_assign() [1/3]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

bool pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_assign ( const std::initializer_list< value_type > & list )

inlineprotected

Replaces the container with copies of items from an initializer list. Does nothing if unable to accommodate all items.

◆ try_assign() [2/3]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

template<typename It , int & ..., typename >

bool pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_assign	(	It	start,
		It	finish
	)

protected

Replaces the container with copies of items from an iterator. Does nothing if unable to accommodate all items.

try_assign() requires a forward iterator so that the capacity can be checked upfront to avoid partial assignments. Input iterators are only suitable for one pass, so could be exhausted by a std::distance check.

◆ try_assign() [3/3]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

bool pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_assign	(	size_type	count,
		const value_type &	value
	)

protected

Attempts to replace the contents with count copies of value. If count <blockquote>&zwj;capacity() and allocation is supported, attempts to allocate to

increase capacity. Does nothing if unable to accommodate count items.

◆ try_emplace()

template<typename Derived , typename ValueType , typename CountAndCapacityType >

template<typename... Args>

std::optional< iterator > pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_emplace	(	const_iterator	pos,
		Args &&...	args
	)

protected

Tries to construct an item in place at pos.

Returns: an std::optional iterator to the emplaced item. If memory allocation fails, returns std::nullopt and the container is left unchanged.

◆ try_insert() [1/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

std::optional< iterator > pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert	(	const_iterator	pos,
		const value_type &	value
	)

inlineprotected

Tries to insert a copy of an item at pos.

Returns: an std::optional iterator to the inserted item. If memory allocation fails, returns std::nullopt and the container is left unchanged.

◆ try_insert() [2/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

template<typename ForwardIt , typename = containers::internal::EnableIfForwardIterator<ForwardIt>>

std::optional< iterator > pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert	(	const_iterator	pos,
		ForwardIt	first,
		ForwardIt	last
	)

protected

Tries to insert the contents of an iterator at pos.

Returns: an std::optional iterator to the first inserted item. If memory allocation fails, returns std::nullopt and the container is left unchanged.

◆ try_insert() [3/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

std::optional< typename GenericDeque< Derived, ValueType, CountAndCapacityType >::iterator > pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert	(	const_iterator	pos,
		size_type	count,
		const value_type &	value
	)

protected

Tries to insert count copies of value at pos.

Returns: an std::optional iterator to the first inserted item. If memory allocation fails, returns std::nullopt and the container is left unchanged.

◆ try_insert() [4/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

std::optional< iterator > pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert	(	const_iterator	pos,
		std::initializer_list< value_type >	ilist
	)

inlineprotected

Tries to insert an initializer list at pos.

Returns: an std::optional iterator to the first inserted item. If memory allocation fails, returns std::nullopt and the container is left unchanged.

◆ try_insert() [5/5]

template<typename Derived , typename ValueType , typename CountAndCapacityType >

std::optional< iterator > pw::containers::internal::GenericDeque< Derived, ValueType, CountAndCapacityType >::try_insert	(	const_iterator	pos,
		value_type &&	value
	)

inlineprotected

Tries to insert an item at pos using move semanatics.

Returns: an std::optional iterator to the inserted item. If memory allocation fails, returns std::nullopt and the container is left unchanged.

◆ try_reserve() [1/2]

template<typename T , typename SizeType = uint16_t>

bool pw::DynamicQueue< T, SizeType >::try_reserve ( size_type capacity )

inline

Attempts to set the queue capacity to at least max(capacity, size()) elements.

◆ try_reserve() [2/2]

template<typename ValueType , typename SizeType >

bool pw::DynamicDeque< ValueType, SizeType >::try_reserve ( size_type new_capacity )

Attempts to increase capacity() to at least new_capacity, allocating memory if needed. Does nothing if new_capacity is less than or equal to capacity(). Iterators are invalidated if allocation occurs.

try_reserve may increase the capacity to be larger than new_capacity, with the same behavior as if the size were increased to new_capacity. To increase the capacity to a precise value, use try_reserve_exact().

Returns: true if allocation succeeded or capacity() was already large enough; false if allocation failed

◆ try_reserve_exact()

template<typename ValueType , typename SizeType = uint16_t>

bool pw::DynamicDeque< ValueType, SizeType >::try_reserve_exact ( size_type new_capacity )

inline

Attempts to increase capacity() to new_capacity, allocating memory if needed. Does nothing if new_capacity is less than or equal to capacity().

This differs from try_reserve(), which may reserve space for more than new_capacity.

Returns: true if allocation succeeded or capacity() was already large enough; false if allocation failed

◆ TryAllocate() [1/2]

template<typename T , typename S >

static FixedDeque pw::FixedDeque< T, containers::kExternalStorage, S >::TryAllocate	(	Allocator &	allocator,
		S	capacity
	)

inlinestatic

Attempts to allocate a T-aligned buffer large enough to hold capacity items and use it for a FixedDeque's buffer. If unable to allocate space for capacity items, returns a FixedDeque with a capacity of 0.

If allocation succeeds, the FixedDeque owns the buffer and frees it upon destruction.

◆ TryAllocate() [2/2]

template<typename T , typename S >

static FixedQueue pw::FixedQueue< T, containers::kExternalStorage, S >::TryAllocate	(	Allocator &	allocator,
		S	capacity
	)

inlinestatic

Attempts to allocate a T-aligned buffer large enough to hold capacity items and use it for a FixedQueue's buffer. If unable to allocate space for capacity items, returns a FixedQueue with a capacity of 0.

If allocation succeeds, the FixedQueue owns the buffer and frees it upon destruction.

◆ WithStorage() [1/2]

template<typename T , typename S >

static FixedDeque pw::FixedDeque< T, containers::kExternalStorage, S >::WithStorage ( UniquePtr< std::byte[]> && storage )

inlinestatic

Constructs an empty FixedDeque that uses the provided pw::UniquePtr for its storage. Takes ownership of the pw::UniquePtr.

Precondition: storage MUST be aligned at least as value_type.

◆ WithStorage() [2/2]

template<typename T , typename S >

static FixedQueue pw::FixedQueue< T, containers::kExternalStorage, S >::WithStorage ( UniquePtr< std::byte[]> && storage )

inlinestatic

Constructs an empty FixedQueue that uses the provided pw::UniquePtr for its storage. Takes ownership of the pw::UniquePtr.

Precondition: storage MUST be aligned at least as value_type.

Overview

Submodules

Classes

Typedefs

Functions

Variables

Friends

Typedef Documentation

◆ InlineAsyncDeque

◆ InlineAsyncQueue

◆ InlineQueue

Function Documentation

◆ Allocate() [1/2]

◆ Allocate() [2/2]

◆ assign()

◆ deallocator() [1/2]

◆ deallocator() [2/2]

◆ Deque() [1/2]

◆ Deque() [2/2]

◆ DynamicDeque() [1/2]

◆ DynamicDeque() [2/2]

◆ emplace()

◆ erase()

◆ FixedDeque() [1/4]

◆ FixedDeque() [2/4]

◆ FixedDeque() [3/4]

◆ FixedDeque() [4/4]

◆ FixedQueue() [1/4]

◆ FixedQueue() [2/4]

◆ FixedQueue() [3/4]

◆ FixedQueue() [4/4]

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ MoveItemsFrom() [1/2]

◆ MoveItemsFrom() [2/2]

◆ Queue() [1/2]

◆ Queue() [2/2]

◆ swap() [1/6]

◆ swap() [2/6]

◆ swap() [3/6]

◆ swap() [4/6]

◆ swap() [5/6]

◆ swap() [6/6]

◆ try_assign() [1/3]

◆ try_assign() [2/3]

◆ try_assign() [3/3]

◆ try_emplace()

◆ try_insert() [1/5]

◆ try_insert() [2/5]

◆ try_insert() [3/5]

◆ try_insert() [4/5]

◆ try_insert() [5/5]

◆ try_reserve() [1/2]

◆ try_reserve() [2/2]

◆ try_reserve_exact()

◆ TryAllocate() [1/2]

◆ TryAllocate() [2/2]

◆ WithStorage() [1/2]

◆ WithStorage() [2/2]