Vector-like container consisting of few elements on stack and switches to dynamic allocation vector if needed. More...

#include <AUI/Common/ASmallVector.h>

Public Types#
using	iterator = StoredType*

using	const_iterator = const StoredType*

using	reference = StoredType&

using	const_reference = const StoredType&

using	value = StoredType

Public Member Functions#
	ASmallVector (ASmallVector &&rhs) noexcept

constexpr StoredType *	data () noexcept

constexpr const StoredType *	data () const noexcept

constexpr iterator	begin () noexcept

constexpr const_iterator	begin () const noexcept

constexpr iterator	end () noexcept

constexpr const_iterator	end () const noexcept

constexpr StoredType &	front () noexcept

constexpr StoredType &	back () noexcept

constexpr const StoredType &	front () const noexcept

constexpr const StoredType &	back () const noexcept

constexpr void	push_back (StoredType value) noexcept

constexpr void	push_front (StoredType value) noexcept

constexpr void	pop_back () noexcept

constexpr void	pop_front () noexcept

constexpr StoredType &	operator[] (std::size_t index) noexcept

constexpr StoredType &	operator[] (std::size_t index) const noexcept

constexpr bool	empty () const noexcept

constexpr void	clear () noexcept

std::size_t	size () const noexcept

bool	isInplaceAllocated () const noexcept

template<typename OtherIterator>
constexpr iterator	insert (iterator at, OtherIterator begin, OtherIterator end)

constexpr iterator	erase (iterator begin, iterator end) noexcept

constexpr iterator	insert (iterator at, StoredType value)

constexpr iterator	erase (iterator at)

template<typename OtherContainer>
iterator	insertAll (const OtherContainer &c) noexcept

template<typename OtherContainer>
iterator	insertAll (OtherContainer &&c) noexcept

template<typename OtherContainer>
iterator	insertAll (iterator at, const OtherContainer &c) noexcept

template<typename OtherContainer>
iterator	insertAll (iterator at, OtherContainer &&c) noexcept

void	removeAll (const StoredType &item) noexcept

template<typename T, aui::mapper< const StoredType &, const T & > Projection>
void	removeAll (const T &item, Projection projection) noexcept

void	removeFirst (const StoredType &item) noexcept

template<typename OtherContainer>
bool	isSubsetOf (const OtherContainer &c) const noexcept

bool	contains (const StoredType &value) const noexcept

std::size_t	sizeInBytes () const noexcept

StoredType &	at (std::size_t index)

const StoredType &	at (std::size_t index) const

self &	operator<< (const StoredType &rhs) noexcept

self &	operator<< (StoredType &&rhs) noexcept

template<typename OtherContainer, std::enable_if_t<!std::is_convertible_v< OtherContainer, StoredType >, bool > = true>
self &	operator<< (const OtherContainer &c) noexcept

template<typename OtherContainer, std::enable_if_t<!std::is_convertible_v< OtherContainer, StoredType >, bool > = true>
self &	operator<< (OtherContainer &&c) noexcept

StoredType &	first () noexcept

const StoredType &	first () const noexcept

StoredType &	last () noexcept

const StoredType &	last () const noexcept

AOptional< size_t >	indexOf (const StoredType &value) const noexcept

void	sort () noexcept

template<typename Comparator>
void	sort (Comparator &&comparator) noexcept

template<aui::predicate< StoredType > Predicate>
StoredType *	findIf (Predicate &&predicate) noexcept
	Finds element by predicate.

template<typename T, aui::mapper< const StoredType &, const T & > Projection>
StoredType *	findIf (const T &value, Projection &&projection) noexcept
	Finds element by value.

void	removeAt (size_t index) noexcept

template<typename Predicate>
void	removeIf (Predicate &&predicate) noexcept

ASet< StoredType >	toSet () const noexcept

template<aui::invocable< const StoredType & > UnaryOperation>
auto	map (UnaryOperation &&transformer) const -> AVector< decltype(transformer(std::declval< StoredType >()))>

template<aui::invocable< const StoredType & > UnaryOperation>
auto	toMap (UnaryOperation &&transformer) const -> AMap< decltype(transformer(std::declval< StoredType >()).first), decltype(transformer(std::declval< StoredType >()).second)>

template<aui::invocable< StoredType & > UnaryOperation>
auto	toMap (UnaryOperation &&transformer) -> AMap< decltype(transformer(std::declval< StoredType >()).first), decltype(transformer(std::declval< StoredType >()).second)>

template<aui::predicate< const StoredType & > Predicate>
self	filter (Predicate &&predicate)

Static Public Member Functions#
template<aui::incrementable Iterator, aui::invocable< decltype(*std::declval< Iterator >())> UnaryOperation>
static auto	fromRange (aui::range< Iterator > range, UnaryOperation &&transformer) -> AVector< decltype(transformer(range.first()))>
	Constructs a new vector of transformed items of the range.

Protected Types#
using	self = ASmallVector

using	super = self

using	StaticVector = AStaticVector<StoredType, StaticVectorSize>

using	DynamicVector = ADynamicVector<StoredType>

Detailed Description#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>
class ASmallVector< StoredType, StaticVectorSize, Allocator >

Template Parameters

StoredType	stored type
StaticVectorSize	how many elements can be stored without dynamic allocation
Allocator	allocation

Vector-like container optimized for the case when it contains up to StaticVectorSize in place, avoiding dynamic allocation. In case when element count exceeds StaticVectorSize, ASmallVector seamlessly switches to traditional dynamic allocation vector.

Member Function Documentation#

◆ contains()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

bool ASmallVector< StoredType, StaticVectorSize, Allocator >::contains ( const StoredType & value ) const

inlinenoexcept

Returns: true if container contains an element, false otherwise.

◆ findIf() [1/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename T, aui::mapper< const StoredType &, const T & > Projection>

StoredType * ASmallVector< StoredType, StaticVectorSize, Allocator >::findIf	(	const T &	value,
		Projection &&	projection )

inlinenoexcept

Parameters

value	value
projection	callable that transforms `const StoredType&` to `const T&`. Can be any operator() cappable object, including lambda and pointer-to-member.

Returns: Pointer to the value on which the predicate returned true, nullptr otherwise

◆ findIf() [2/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<aui::predicate< StoredType > Predicate>

StoredType * ASmallVector< StoredType, StaticVectorSize, Allocator >::findIf ( Predicate && predicate )

inlinenoexcept

Parameters

predicate predicate

Returns: Pointer to the value on which the predicate returned true, nullptr otherwise

◆ first() [1/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

const StoredType & ASmallVector< StoredType, StaticVectorSize, Allocator >::first ( ) const

inlinenoexcept

Sneaky assertions: Container is not empty.

Returns: the first element.

◆ first() [2/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

StoredType & ASmallVector< StoredType, StaticVectorSize, Allocator >::first ( )

inlinenoexcept

Sneaky assertions: Container is not empty.

Returns: the first element.

◆ fromRange()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<aui::incrementable Iterator, aui::invocable< decltype(*std::declval< Iterator >())> UnaryOperation>

static auto ASmallVector< StoredType, StaticVectorSize, Allocator >::fromRange	(	aui::range< Iterator >	range,
		UnaryOperation &&	transformer ) -> AVector<decltype(transformer(range.first()))>

inlinestatic

Parameters

range	items to transform from.
transformer	transformer function.

Returns: A new vector.

◆ indexOf()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

AOptional< size_t > ASmallVector< StoredType, StaticVectorSize, Allocator >::indexOf ( const StoredType & value ) const

inlinenodiscardnoexcept

Parameters

value element to find.

Returns: index of the specified element. If element is not found, std::nullopt is returned.

◆ insertAll() [1/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename OtherContainer>

iterator ASmallVector< StoredType, StaticVectorSize, Allocator >::insertAll ( const OtherContainer & c )

inlinenoexcept

Inserts all values of the specified container to the end.

Template Parameters

OtherContainer other container type.

Parameters

c	other container

Returns: iterator pointing to the first element inserted.

◆ insertAll() [2/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename OtherContainer>

iterator ASmallVector< StoredType, StaticVectorSize, Allocator >::insertAll	(	iterator	at,
		const OtherContainer &	c )

inlinenoexcept

Inserts all values of the specified container.

Template Parameters

OtherContainer other container type.

Parameters

at	position to insert at.
c	other container

Returns: iterator pointing to the first element inserted.

◆ insertAll() [3/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename OtherContainer>

iterator ASmallVector< StoredType, StaticVectorSize, Allocator >::insertAll	(	iterator	at,
		OtherContainer &&	c )

inlinenoexcept

Inserts all values of the specified container.

Template Parameters

OtherContainer other container type.

Parameters

at	position to insert at.
c	other container

Returns: iterator pointing to the first element inserted.

◆ insertAll() [4/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename OtherContainer>

iterator ASmallVector< StoredType, StaticVectorSize, Allocator >::insertAll ( OtherContainer && c )

inlinenoexcept

Inserts all values of the specified container to the end.

Template Parameters

OtherContainer other container type.

Parameters

c	other container

Returns: iterator pointing to the first element inserted.

◆ isSubsetOf()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename OtherContainer>

bool ASmallVector< StoredType, StaticVectorSize, Allocator >::isSubsetOf ( const OtherContainer & c ) const

inlinenoexcept

Returns: true if c container is a subset of this container, false otherwise.

◆ last() [1/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

const StoredType & ASmallVector< StoredType, StaticVectorSize, Allocator >::last ( ) const

inlinenoexcept

Sneaky assertions: Container is not empty.

Returns: the last element.

◆ last() [2/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

StoredType & ASmallVector< StoredType, StaticVectorSize, Allocator >::last ( )

inlinenoexcept

Sneaky assertions: Container is not empty.

Returns: the last element.

◆ operator<<() [1/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename OtherContainer, std::enable_if_t<!std::is_convertible_v< OtherContainer, StoredType >, bool > = true>

self & ASmallVector< StoredType, StaticVectorSize, Allocator >::operator<< ( const OtherContainer & c )

inlinenoexcept

Shortcut to insertAll.

Parameters

c	container to push

Returns: self

◆ operator<<() [2/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

self & ASmallVector< StoredType, StaticVectorSize, Allocator >::operator<< ( const StoredType & rhs )

inlinenoexcept

Shortcut to push_back.

Parameters

rhs	value to push

Returns: self

◆ operator<<() [3/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename OtherContainer, std::enable_if_t<!std::is_convertible_v< OtherContainer, StoredType >, bool > = true>

self & ASmallVector< StoredType, StaticVectorSize, Allocator >::operator<< ( OtherContainer && c )

inlinenoexcept

Shortcut to insertAll.

Parameters

c	container to push

Returns: self

◆ operator<<() [4/4]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

self & ASmallVector< StoredType, StaticVectorSize, Allocator >::operator<< ( StoredType && rhs )

inlinenoexcept

Shortcut to push_back.

Parameters

rhs	value to push

Returns: self

◆ removeAll() [1/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

void ASmallVector< StoredType, StaticVectorSize, Allocator >::removeAll ( const StoredType & item )

inlinenoexcept

Removes all occurrences of item.

Parameters

item	element to remove.

◆ removeAll() [2/2]#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename T, aui::mapper< const StoredType &, const T & > Projection>

void ASmallVector< StoredType, StaticVectorSize, Allocator >::removeAll	(	const T &	item,
		Projection	projection )

inlinenoexcept

Removes all occurrences of item with specified projection.

Parameters

item	element to remove.
projection	callable that transforms `const StoredType&` to `const T&`. Can be any operator() cappable object, including lambda and pointer-to-member.

◆ removeAt()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

void ASmallVector< StoredType, StaticVectorSize, Allocator >::removeAt ( size_t index )

inlinenoexcept

Removes element at the specified index.

Sneaky assertions: index points to the existing element.

Parameters

index index of the element.

◆ removeFirst()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

void ASmallVector< StoredType, StaticVectorSize, Allocator >::removeFirst ( const StoredType & item )

inlinenoexcept

Removes first occurrence of item.

Parameters

item	element to remove.

◆ removeIf()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

template<typename Predicate>

void ASmallVector< StoredType, StaticVectorSize, Allocator >::removeIf ( Predicate && predicate )

inlinenoexcept

Removes element if predicate(container[i]) == true.

Parameters

predicate predicate

◆ size()#

template<typename StoredType, std::size_t StaticVectorSize, typename Allocator = std::allocator<StoredType>>

std::size_t ASmallVector< StoredType, StaticVectorSize, Allocator >::size ( ) const

inlinenodiscardnoexcept

Returns: Size of the container.

Contents

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Detailed Description

View Page Source Edit Page Source

Public Types#

Public Member Functions#

Static Public Member Functions#

Protected Types#

Detailed Description#

Member Function Documentation#

◆ contains()#

◆ findIf() [1/2]#

◆ findIf() [2/2]#

◆ first() [1/2]#

◆ first() [2/2]#

◆ fromRange()#

◆ indexOf()#

◆ insertAll() [1/4]#

◆ insertAll() [2/4]#

◆ insertAll() [3/4]#

◆ insertAll() [4/4]#

◆ isSubsetOf()#

◆ last() [1/2]#

◆ last() [2/2]#

◆ operator<<() [1/4]#

◆ operator<<() [2/4]#

◆ operator<<() [3/4]#

◆ operator<<() [4/4]#

◆ removeAll() [1/2]#

◆ removeAll() [2/2]#

◆ removeAt()#

◆ removeFirst()#

◆ removeIf()#

◆ size()#

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Detailed Description