Queues

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::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::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

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.