#include <basearray.h>

Inheritance diagram for BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >:

[legend]

Detailed Description

template<typename T, Int MINCHUNKSIZE = BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS MEMFLAGS = BASEARRAYFLAGS::NONE, typename ALLOCATOR = DefaultAllocator>
class maxon::BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >

Basic array template. The array consists of one contiguous block of memory. The block will have a minimum size of MINCHUNKSIZE elements of type T as soon as the first element is added.

The elements may be copied and change their memory address when the array grows. If your objects cannot be copied or need a constant address use the BlockArray template.

If you need a specific alignment you may have to use a non-default allocator. See defaultallocator.h for alignment and grow rate behaviour details.

Please note that in a C++11 range based for loop you may not call a non-const method that modifies the range (e.g. Erase) - it does not work because the loop does not expect the range to change. Use the Iterable::EraseIterator in that case.

Note: The 'Base' in BaseArray doesn't indicate that you should inherit from this class - it's just the most basic array template which is used as foundation by many other array templates and collections as well. The intended usage is simply
BaseArray<MyDataType> myArray;

Performance characteristics: Random access to array elements is constant: O(1). Append or Pop (erase the last) an element is amortized constant: O(1) Insert or Erase an element is linear with the number of elements which have to be moved (with n elements until the array end): O(n)

Note: : Do not rely on the characteristics to pick the right type of collection. Always profile!

Template Parameters

T	Type of the array elements.
MINCHUNKSIZE	The minimum number of elements upon array creation.
MEMFLAGS	Use BASEARRAYFLAGS::NONE unless you know the object can be moved and/or copied.
ALLOCATOR	Class for memory allocation.

Note: Note that the array element class has special requirements regarding copy and move constructors .

See also: $ref arrays

Public Types
using	IsBaseArray = std::true_type

using	AllocatorType = ALLOCATOR

using	Iterator = BaseIterator< BaseArray, false >

using	ConstIterator = BaseIterator< const BaseArray, false >

using	Super = ArrayBase< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, MEMFLAGS, ALLOCATOR, STD_IS_REPLACEMENT(empty, ALLOCATOR)>, DefaultCompare >

Public Types inherited from Collection< COLLECTION, VALUETYPE, SUPER >
using	Super = BaseCollection< COLLECTION, SUPER >

using	ValueType = VALUETYPE

Public Types inherited from BaseCollection< COLLECTION, SUPER >
using	IsCollection = std::true_type

using	IsBaseArray = std::false_type

Public Member Functions
MAXON_ATTRIBUTE_FORCE_INLINE	BaseArray ()

MAXON_ATTRIBUTE_FORCE_INLINE	BaseArray (const ALLOCATOR &a)

MAXON_ATTRIBUTE_FORCE_INLINE	BaseArray (ALLOCATOR &&a)

MAXON_ATTRIBUTE_FORCE_INLINE	~BaseArray ()

MAXON_ATTRIBUTE_FORCE_INLINE	BaseArray (BaseArray &&src)

	MAXON_OPERATOR_MOVE_ASSIGNMENT (BaseArray)

const Block< const T > &	ToBlock () const

const Block< const T > &	ToConstBlock () const

const Block< T > &	ToBlock ()

	operator const Block< const T > & () const

	operator const Block< T > & ()

	operator StridedBlock< const T > () const

	operator StridedBlock< T > ()

template<typename DUMMY = T, typename = typename std::enable_if<STD_IS_REPLACEMENT(scalar, DUMMY)>::type>
	operator Block< const Byte > () const

template<typename DUMMY = T, typename = typename std::enable_if<STD_IS_REPLACEMENT(scalar, DUMMY)>::type>
	operator Block< Byte > ()

void	Reset ()

void	Flush ()

MAXON_ATTRIBUTE_FORCE_INLINE Int	GetCount () const

MAXON_ATTRIBUTE_FORCE_INLINE Int	GetCapacityCount () const

MAXON_ATTRIBUTE_FORCE_INLINE const T &	operator[] (Int idx) const

MAXON_ATTRIBUTE_FORCE_INLINE T &	operator[] (Int idx)

template<typename ARG >
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T >	Append (ARG &&x)

template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< sizeof...(ARGS) !=1, ResultRef< T > >::type	Append (ARGS &&... args)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	AppendBlock (const Block< const T > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	AppendBlock (const MoveBlock< T > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (Block< typename std::remove_const< T >::type > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (Block< const T > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (const Block< typename std::remove_const< T >::type > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (const Block< const T > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (Block< typename std::remove_const< T >::type > &&values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (Block< const T > &&values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (MoveBlock< T > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (const MoveBlock< T > &values)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (MoveBlock< T > &&values)

template<Int N>
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (typename std::remove_const< T >::type(&array)[N])

template<Int N>
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (const T(&array)[N])

template<Int CS, BASEARRAYFLAGS MF, typename A >
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (BaseArray< T, CS, MF, A > &a)

template<Int CS, BASEARRAYFLAGS MF, typename A >
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (const BaseArray< T, CS, MF, A > &a)

template<Int CS, BASEARRAYFLAGS MF, typename A >
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (BaseArray< T, CS, MF, A > &&a)

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Append (const std::initializer_list< T > &values)

template<typename ARG >
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T >	Insert (Int position, ARG &&x)

template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< sizeof...(ARGS) !=1, ResultRef< T > >::type	Insert (Int position, ARGS &&... args)

ResultPtr< T >	Insert (Int position, Block< typename std::remove_const< T >::type > &values)

ResultPtr< T >	Insert (Int position, Block< const T > &values)

ResultPtr< T >	Insert (Int position, const Block< typename std::remove_const< T >::type > &values)

ResultPtr< T >	Insert (Int position, const Block< const T > &values)

ResultPtr< T >	Insert (Int position, Block< typename std::remove_const< T >::type > &&values)

ResultPtr< T >	Insert (Int position, Block< const T > &&values)

ResultPtr< T >	Insert (Int position, MoveBlock< T > &values)

ResultPtr< T >	Insert (Int position, const MoveBlock< T > &values)

ResultPtr< T >	Insert (Int position, MoveBlock< T > &&values)

template<Int CS, BASEARRAYFLAGS MF, typename A >
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Insert (Int position, BaseArray< T, CS, MF, A > &a)

template<Int CS, BASEARRAYFLAGS MF, typename A >
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Insert (Int position, const BaseArray< T, CS, MF, A > &a)

template<Int CS, BASEARRAYFLAGS MF, typename A >
MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T >	Insert (Int position, BaseArray< T, CS, MF, A > &&a)

ResultPtr< T >	InsertBlock (Int position, const Block< const T > &values)

ResultPtr< T >	Insert (Int position, const std::initializer_list< T > &values)

ResultPtr< T >	InsertBlock (Int position, const MoveBlock< T > &values)

template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT< Iterator >	InsertBlock (Iterator position, ARGS &&... args)

template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT< Iterator >	Insert (Iterator position, ARGS &&... args)

ResultPtr< T >	Erase (Int position, Int eraseCnt=1)

Iterator	Erase (Iterator position, Int eraseCnt=1)

ResultMem	SwapErase (Int position, Int eraseCnt=1)

Iterator	SwapErase (Iterator position, Int eraseCnt=1)

template<Bool STRIDED>
MAXON_ATTRIBUTE_FORCE_INLINE Int	GetBlock (Int position, Block< const T, STRIDED > &block) const

template<Bool STRIDED>
MAXON_ATTRIBUTE_FORCE_INLINE Int	GetBlock (Int position, Block< T, STRIDED > &block)

template<Bool STRIDED>
MAXON_ATTRIBUTE_FORCE_INLINE ConstIterator	GetBlock (ConstIterator position, Block< const T, STRIDED > &block) const

template<Bool STRIDED>
MAXON_ATTRIBUTE_FORCE_INLINE Iterator	GetBlock (Iterator position, Block< T, STRIDED > &block)

MAXON_ATTRIBUTE_FORCE_INLINE const T *	GetFirst () const

MAXON_ATTRIBUTE_FORCE_INLINE T *	GetFirst ()

MAXON_ATTRIBUTE_FORCE_INLINE const T *	GetLast () const

MAXON_ATTRIBUTE_FORCE_INLINE T *	GetLast ()

ResultMem	Resize (Int newCnt, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::DEFAULT)

MAXON_ATTRIBUTE_FORCE_INLINE Bool	Pop (T *dst=nullptr)

MAXON_ATTRIBUTE_FORCE_INLINE Int	GetIndex (const T &x) const

ResultMem	EnsureCapacity (Int requestedCapacity, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)

ResultMem	SetCapacityHint (Int requestedCapacity, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)

template<typename BASEARRAY , typename = typename std::enable_if<STD_IS_REPLACEMENT(same, typename std::decay<BASEARRAY>::type, BaseArray)>::type>
MAXON_ATTRIBUTE_FORCE_INLINE Result< void >	AppendAllImpl (BASEARRAY &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank1)

template<typename BLOCK , typename = typename std::enable_if<STD_IS_REPLACEMENT(same, typename std::decay<BLOCK>::type, Block<T>) \|\| STD_IS_REPLACEMENT(same, typename std::decay<BLOCK>::type, Block<const T>)>::type>
MAXON_ATTRIBUTE_FORCE_INLINE Result< void >	AppendAllImpl (BLOCK &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank2)

MAXON_ATTRIBUTE_FORCE_INLINE void	Swap (Iterator a, Iterator b)

Int	GetMemorySize () const

MAXON_ATTRIBUTE_FORCE_INLINE ConstIterator	Begin () const

MAXON_ATTRIBUTE_FORCE_INLINE Iterator	Begin ()

MAXON_ATTRIBUTE_FORCE_INLINE ConstIterator	End () const

MAXON_ATTRIBUTE_FORCE_INLINE Iterator	End ()

ResultMem	MoveAndShrink (BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > &dst, Int position, Int moveCnt)

MAXON_ATTRIBUTE_FORCE_INLINE Block< T >	Disconnect ()

MAXON_ATTRIBUTE_FORCE_INLINE void	Connect (const Block< T > &block, Int capacity=0)

MAXON_ATTRIBUTE_FORCE_INLINE ALLOCATOR &	GetAllocator ()

MAXON_ATTRIBUTE_FORCE_INLINE const ALLOCATOR &	GetAllocator () const

UniqueHash	GetUniqueHashCode () const

Public Member Functions inherited from ArrayBase< BaseArray< T, BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS::NONE, DefaultAllocator >, T, BaseArrayData< T, BASEARRAYFLAGS::NONE, DefaultAllocator, STD_IS_REPLACEMENT(empty, DefaultAllocator)>, DefaultCompare >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE	ArrayBase (ARGS &&... args)

ArrayImpl< BaseArray< T, BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS::NONE, DefaultAllocator > & >	ToArray ()

ArrayImpl< const BaseArray< T, BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS::NONE, DefaultAllocator > & >	ToArray () const

MAXON_ATTRIBUTE_FORCE_INLINE	operator ArrayImpl< BaseArray< T, BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS::NONE, DefaultAllocator > & > ()

MAXON_ATTRIBUTE_FORCE_INLINE	operator ArrayImpl< const BaseArray< T, BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS::NONE, DefaultAllocator > & > () const

Public Member Functions inherited from ArrayBase0< COLLECTION, VALUETYPE, SUPER, HASH >
template<typename... ARGS>
constexpr MAXON_ATTRIBUTE_FORCE_INLINE	ArrayBase0 (ARGS &&... args)

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type	operator< (const COLLECTION2 &other) const

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type	operator<= (const COLLECTION2 &other) const

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type	operator> (const COLLECTION2 &other) const

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type	operator>= (const COLLECTION2 &other) const

template<typename COMPARE = EqualityCompare, typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, COMPARERESULT >::type	Compare (const COLLECTION2 &other, COMPARE &&cmp=COMPARE()) const

Bool	IsValidIndex (Int index) const

Result< void >	CheckValidIndex (Int index) const

Int	FindIndex (typename ByValueParam< VALUETYPE >::type v, Int start) const

Int	FindLastIndex (typename ByValueParam< VALUETYPE >::type v) const

Int	FindLastIndex (typename ByValueParam< VALUETYPE >::type v, Int start) const

Bool	EraseFirst (typename ByValueParam< VALUETYPE >::type v)

Int	EraseAll (typename ByValueParam< VALUETYPE >::type v)

template<typename COLLECTION2 >
Result< void >	AppendAllImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank0)

template<typename COLLECTION2 >
Result< void >	InsertAll (Int index, COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)

template<typename COLLECTION2 >
Result< void >	Add (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)

template<typename COLLECTION2 >
Result< void >	SubtractImpl (COLLECTION2 &&other, OverloadRank0)

template<typename COLLECTION2 , typename COMPARE >
Bool	IsEqualImpl (const COLLECTION2 &other, COMPARE &&cmp, OverloadRank0) const

template<typename COLLECTION2 , typename COMPARE >
COMPARERESULT	CompareImpl (const COLLECTION2 &other, COMPARE &&cmp, OverloadRank0) const

HashInt	GetHashCode () const

UniqueHash	GetUniqueHashCode () const

MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< COLLECTION >	Slice (Int start)

MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< const COLLECTION >	Slice (Int start) const

MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< COLLECTION >	Slice (Int start, Int end)

MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< const COLLECTION >	Slice (Int start, Int end) const

BlockIterator< COLLECTION, VALUETYPE, false, false >	GetBlocks ()

BlockIterator< COLLECTION, VALUETYPE, true, false >	GetBlocks () const

BlockIterator< COLLECTION, VALUETYPE, false, true >	GetStridedBlocks ()

BlockIterator< COLLECTION, VALUETYPE, true, true >	GetStridedBlocks () const

Public Member Functions inherited from Collection< COLLECTION, VALUETYPE, SUPER >
template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE	Collection (ARGS &&... args)

ResultOk< void >	VariadicAppend ()

template<typename V , typename... VALUES>
Result< void >	VariadicAppend (V &&value, VALUES &&... rest)

	operator ValueReceiver< const VALUETYPE & > ()

	operator ValueReceiver< VALUETYPE && > ()

	operator ValueReceiver< typename std::conditional< STD_IS_REPLACEMENT (scalar, VALUETYPE)

DummyParamType &	type ()

template<typename FN >
Result< Bool >	ForEach (FN &&callback) const

template<typename FN >
Result< Bool >	ForEach (FN &&callback)

template<typename H = COLLECTION>
H::Iterator	Find (typename ByValueParam< VALUETYPE >::type v)

template<typename H = COLLECTION>
H::ConstIterator	Find (typename ByValueParam< VALUETYPE >::type v) const

Int	FindIndex (typename ByValueParam< VALUETYPE >::type v) const

MAXON_ATTRIBUTE_FORCE_INLINE Bool	Contains (typename ByValueParam< VALUETYPE >::type v) const

Public Member Functions inherited from BaseCollection< COLLECTION, SUPER >
template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE	BaseCollection (ARGS &&... args)

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type	operator== (const COLLECTION2 &other) const

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type	operator!= (const COLLECTION2 &other) const

template<typename COMPARE = EqualityCompare, typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value &&!STD_IS_REPLACEMENT(same, typename std::decay< COMPARE >::type, EQUALITY), Bool >::type	IsEqual (const COLLECTION2 &other, COMPARE &&cmp=COMPARE()) const

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void >	AppendAll (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void >	CopyFrom (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::FIT_TO_SIZE)

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void >	Subtract (COLLECTION2 &&other)

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void >	Intersect (const COLLECTION2 &other)

template<typename COLLECTION2 >
Bool	Intersects (const COLLECTION2 &other) const

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void >	CopyFromImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, OverloadRank0)

template<typename COLLECTION2 >
Result< void >	AppendAllImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank0)

template<typename COLLECTION2 >
Result< void >	IntersectImpl (COLLECTION2 &&other, OverloadRank0)

MAXON_ATTRIBUTE_FORCE_INLINE Bool	IsEmpty () const

MAXON_ATTRIBUTE_FORCE_INLINE Bool	IsPopulated () const

String	ToString (const FormatStatement *formatStatement=nullptr) const

template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool	ContainsAll (COLLECTION2 &&other) const

template<typename COLLECTION2 >
Bool	ContainsAllImpl (COLLECTION2 &&other, OverloadRank0) const

Private Member Functions
	MAXON_DISALLOW_COPY_AND_ASSIGN (BaseArray)

template<typename COLLECTION2 >
Result< void >	AppendAllImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank0)

template<typename BASEARRAY , typename = typename std::enable_if<STD_IS_REPLACEMENT(same, typename std::decay<BASEARRAY>::type, BaseArray)>::type>
Result< void >	CopyFromImpl (BASEARRAY &&src, COLLECTION_RESIZE_FLAGS resizeFlags, OverloadRank4)

template<typename BLOCK , typename = typename std::enable_if<STD_IS_REPLACEMENT(same, typename std::decay<BLOCK>::type, Block<T>)>::type>
Result< void >	CopyFromImpl (BLOCK &&src, COLLECTION_RESIZE_FLAGS resizeFlags, OverloadRank3)

	BaseArray (const Block< T > &block, Int capacity)

MAXON_WARN_UNUSED T *	IncreaseCapacity (Int increment=1, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)

MAXON_WARN_UNUSED T *	InsertWithoutConstructor (Int idx, Int increment=1)

ResultMem	FitToSize (Int newCapacity)

Friends
class	GenericBaseArray

Additional Inherited Members
Static Public Member Functions inherited from Collection< COLLECTION, VALUETYPE, SUPER >
static const VALUETYPE &	GetMapKey (const VALUETYPE &key)

Public Attributes inherited from Collection< COLLECTION, VALUETYPE, SUPER >
	VALUETYPE

Static Public Attributes inherited from ArrayBase0< COLLECTION, VALUETYPE, SUPER, HASH >
static const COLLECTION_KIND	KIND

Member Typedef Documentation

◆ IsBaseArray

using IsBaseArray = std::true_type

◆ AllocatorType

using AllocatorType = ALLOCATOR

◆ Iterator

using Iterator = BaseIterator<BaseArray, false>

Iterator allows read and write access to array elements.

◆ ConstIterator

using ConstIterator = BaseIterator<const BaseArray, false>

Iterator for read-only access to array elements.

◆ Super

using Super = ArrayBase<BaseArray<T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR>, T, BaseArrayData<T, MEMFLAGS, ALLOCATOR, STD_IS_REPLACEMENT(empty, ALLOCATOR)>, DefaultCompare>

Constructor & Destructor Documentation

◆ BaseArray() [1/5]

MAXON_ATTRIBUTE_FORCE_INLINE BaseArray ( )

Default constructor. Creates an empty array.

◆ BaseArray() [2/5]

MAXON_ATTRIBUTE_FORCE_INLINE BaseArray ( const ALLOCATOR & a )

explicit

This constructor has to be used if an array should use a custom allocator with member variables.

◆ BaseArray() [3/5]

MAXON_ATTRIBUTE_FORCE_INLINE BaseArray ( ALLOCATOR && a )

explicit

This constructor has to be used if an array should move a custom allocator with member variables.

◆ ~BaseArray()

MAXON_ATTRIBUTE_FORCE_INLINE ~BaseArray ( )

Destructs the array with all its elements.

◆ BaseArray() [4/5]

MAXON_ATTRIBUTE_FORCE_INLINE BaseArray ( BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > && src )

Move constructor.

◆ BaseArray() [5/5]

BaseArray	(	const Block< T > &	block,
		Int	capacity
	)

private

Constructs a BaseArray such that it uses the given block as memory buffer.

Parameters

[in]	block	Memory block to use for the array. The array takes ownership of the memory.
[in]	capacity	Capacity of the buffer. If a non-positive value is given, the capacity is assumed to be the same as the size.

Note: The memory pointed to by block must have been allocated by the allocator that the array is using.

Member Function Documentation

◆ MAXON_DISALLOW_COPY_AND_ASSIGN()

MAXON_DISALLOW_COPY_AND_ASSIGN ( BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > )

private

◆ MAXON_OPERATOR_MOVE_ASSIGNMENT()

MAXON_OPERATOR_MOVE_ASSIGNMENT ( BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > )

Move assignment operator.

◆ ToBlock() [1/2]

const Block<const T>& ToBlock ( ) const

Returns a Block<const T> which represents the elements of the array.

Returns: The content of this array as a block.

◆ ToConstBlock()

const Block<const T>& ToConstBlock ( ) const

Returns a Block<const T> which represents the elements of the array.

Returns: The content of this array as a block.

◆ ToBlock() [2/2]

const Block<T>& ToBlock ( )

Returns a Block<T> which represents the elements of the array.

Returns: The content of this array as a block.

◆ operator const Block< const T > &()

operator const Block< const T > & ( ) const

Converts this BaseArray to a Block<const T> which represents the elements of the array.

Returns: The content of this array as a block.

◆ operator const Block< T > &()

operator const Block< T > & ( )

Converts this BaseArray to a Block<T> which represents the elements of the array.

Returns: The content of this array as a block.

◆ operator StridedBlock< const T >()

operator StridedBlock< const T > ( ) const

Converts this BaseArray to a StridedBlock<const T> which represents the elements of the array. The block will have the natural stride of T.

Returns: The content of this array as a strided block.

◆ operator StridedBlock< T >()

operator StridedBlock< T > ( )

Converts this BaseArray to a StridedBlock<T> which represents the elements of the array. The block will have the natural stride of T.

Returns: The content of this array as a strided block.

◆ operator Block< const Byte >()

operator Block< const Byte > ( ) const

Operator for passing a BaseArray to a Block<const Byte> which represents the raw bytes of the array. This operator is only supported when T is a scalar type.

Returns: The content of this array as a raw Byte block.

◆ operator Block< Byte >()

operator Block< Byte > ( )

Operator for passing a BaseArray to a Block<Byte> which represents the raw bytes of the array. This operator is only supported when T is a scalar type.

Returns: The content of this array as a raw Byte block.

◆ Reset()

void Reset ( )

Deletes all elements (calls destructors and frees memory).

◆ Flush()

void Flush ( )

Deletes all elements, but doesn't free memory (calls destructors though).

◆ GetCount()

MAXON_ATTRIBUTE_FORCE_INLINE Int GetCount ( ) const

Gets the number of array elements.

Returns: Number of array elements.

◆ GetCapacityCount()

MAXON_ATTRIBUTE_FORCE_INLINE Int GetCapacityCount ( ) const

Gets the number of elements for which memory has been allocated (this is usually bigger than GetCount()).

Returns: Number of array elements for which memory has been allocated.

◆ operator[]() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE const T& operator[] ( Int idx ) const

Array (subscript) operator for const objects.

Parameters

[in] idx Element index (if it's out of bounds you will get an error in debug code only, otherwise it will crash).

Returns: Array element.

◆ operator[]() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE T& operator[] ( Int idx )

Array (subscript) operator for non-const objects.

Parameters

[in] idx Element index (if it's out of bounds you will get an error in debug code only, otherwise it will crash).

Returns: Array element.

◆ Append() [1/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultRef<T> Append ( ARG && x )

Appends a new element at the end of the array and constructs it using the forwarded value.

Parameters

[in] x Forwarded value to construct the object.

Returns: Element reference or OutOfMemoryError if the allocation failed.

◆ Append() [2/17]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<sizeof...(ARGS) != 1, ResultRef<T> >::type Append ( ARGS &&... args )

Appends a new element at the end of the array and constructs it using the forwarded values.

Parameters

[in] args Forwarded values to construct the object.

Returns: Element reference or OutOfMemoryError if the allocation failed.

◆ AppendBlock() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> AppendBlock ( const Block< const T > & values )

Appends new elements at the end of the array.

Parameters

[in] values Block with values to be copied. If the block points to nullptr, only its count is used, and you have to call the constructor of the new elements manually.

Returns: Element pointer or OutOfMemoryError if the allocation failed.

◆ AppendBlock() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> AppendBlock ( const MoveBlock< T > & values )

Appends new elements at the end of the array.

Parameters

[in] values Block with values to be moved (a MoveBlock must be used to prevent accidental moves of temporary Blocks). If the block points to nullptr, only its count is used, and you have to call the constructor of the new elements manually.

Returns: Element pointer or OutOfMemoryError if the allocation failed.

◆ Append() [3/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( Block< typename std::remove_const< T >::type > & values )

Appends new elements at the end of the array.

Parameters

[in] values Block with values to be copied. If the block points to nullptr, only its count is used, and you have to call the constructor of the new elements manually.

Returns: Element pointer or OutOfMemoryError if the allocation failed.

◆ Append() [4/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( Block< const T > & values )

◆ Append() [5/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( const Block< typename std::remove_const< T >::type > & values )

◆ Append() [6/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( const Block< const T > & values )

◆ Append() [7/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( Block< typename std::remove_const< T >::type > && values )

◆ Append() [8/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( Block< const T > && values )

◆ Append() [9/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( MoveBlock< T > & values )

Appends new elements at the end of the array.

Parameters

[in] values Block with values to be moved (a MoveBlock must be used to prevent accidental moves of temporary Blocks). If the block points to nullptr, only its count is used, and you have to call the constructor of the new elements manually.

Returns: Element pointer or OutOfMemoryError if the allocation failed.

◆ Append() [10/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( const MoveBlock< T > & values )

◆ Append() [11/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( MoveBlock< T > && values )

◆ Append() [12/17]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( typename std::remove_const< T >::type(&) array[N] )

Appends new elements at the end of the array.

Parameters

[in] array A C++ fixed-size array. of the array.

◆ Append() [13/17]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( const T(&) array[N] )

◆ Append() [14/17]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( BaseArray< T, CS, MF, A > & a )

◆ Append() [15/17]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( const BaseArray< T, CS, MF, A > & a )

◆ Append() [16/17]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( BaseArray< T, CS, MF, A > && a )

◆ Append() [17/17]

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Append ( const std::initializer_list< T > & values )

Appends new elements at the end of the array.

Parameters

[in] values Initializer list with values to be copied.

Returns: Element pointer or OutOfMemoryError if the allocation failed.

◆ Insert() [1/16]

MAXON_ATTRIBUTE_FORCE_INLINE ResultRef<T> Insert	(	Int	position,
		ARG &&	x
	)

Inserts a new element at index position and constructs it using the forwarded value.

Parameters

[in]	position	Insert index (the array size will increase and the existing elements are moved).
[in]	x	Forwarded value to construct the object.

Returns: Element reference or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [2/16]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<sizeof...(ARGS) != 1, ResultRef<T> >::type Insert	(	Int	position,
		ARGS &&...	args
	)

Inserts a new element at index position and constructs it using the forwarded values.

Parameters

[in]	position	Insert index (the array size will increase and the existing elements are moved).
[in]	args	Forwarded values to construct the object.

Returns: Element reference or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [3/16]

ResultPtr<T> Insert	(	Int	position,
		Block< typename std::remove_const< T >::type > &	values
	)

◆ Insert() [4/16]

ResultPtr<T> Insert	(	Int	position,
		Block< const T > &	values
	)

◆ Insert() [5/16]

ResultPtr<T> Insert	(	Int	position,
		const Block< typename std::remove_const< T >::type > &	values
	)

◆ Insert() [6/16]

ResultPtr<T> Insert	(	Int	position,
		const Block< const T > &	values
	)

◆ Insert() [7/16]

ResultPtr<T> Insert	(	Int	position,
		Block< typename std::remove_const< T >::type > &&	values
	)

◆ Insert() [8/16]

ResultPtr<T> Insert	(	Int	position,
		Block< const T > &&	values
	)

◆ Insert() [9/16]

ResultPtr<T> Insert	(	Int	position,
		MoveBlock< T > &	values
	)

Inserts new elements at index position (all elements from position on are moved by the the count of values).

Parameters

[in]	position	Insert index (the array size will increase and the existing elements are moved).
[in]	values	Block with values to be moved (a MoveBlock must be used to prevent accidental moves of temporary Blocks). If the block points to nullptr, only its count is used, and you have to call the constructor of the new elements manually.

Returns: Element pointer or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [10/16]

ResultPtr<T> Insert	(	Int	position,
		const MoveBlock< T > &	values
	)

◆ Insert() [11/16]

ResultPtr<T> Insert	(	Int	position,
		MoveBlock< T > &&	values
	)

◆ Insert() [12/16]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Insert	(	Int	position,
		BaseArray< T, CS, MF, A > &	a
	)

◆ Insert() [13/16]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Insert	(	Int	position,
		const BaseArray< T, CS, MF, A > &	a
	)

◆ Insert() [14/16]

MAXON_IMPLICIT MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> Insert	(	Int	position,
		BaseArray< T, CS, MF, A > &&	a
	)

◆ InsertBlock() [1/3]

ResultPtr<T> InsertBlock	(	Int	position,
		const Block< const T > &	values
	)

Inserts new elements at index position (all elements from position on are moved by the the count of values).

Parameters

[in]	position	Insert index (the array size will increase and the existing elements are moved).
[in]	values	Block with values to be copied. If the block points to nullptr, only its count is used, and you have to call the constructor of the new elements manually.

Returns: Element pointer or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [15/16]

ResultPtr<T> Insert	(	Int	position,
		const std::initializer_list< T > &	values
	)

Inserts new elements at index position (all elements from position on are moved by the the count of values).

Parameters

[in]	position	Insert index (the array size will increase and the existing elements are moved).
[in]	values	Initializer list with values to be copied.

Returns: Element pointer or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ InsertBlock() [2/3]

ResultPtr<T> InsertBlock	(	Int	position,
		const MoveBlock< T > &	values
	)

Inserts new elements at index position (all elements from position on are moved by the the count of values).

Parameters

[in]	position	Insert index (the array size will increase and the existing elements are moved).
[in]	values	Block with values to be moved (a MoveBlock must be used to prevent accidental moves of temporary Blocks). If the block points to nullptr, only its count is used, and you have to call the constructor of the new elements manually.

Returns: Element pointer or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ InsertBlock() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT<Iterator> InsertBlock	(	Iterator	position,
		ARGS &&...	args
	)

◆ Insert() [16/16]

MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT<Iterator> Insert	(	Iterator	position,
		ARGS &&...	args
	)

Inserts a new element at iterator position and moves the content of x to it.

Parameters

[in]	position	Insert position.
[in]	args	Values to be forwarded

Returns: Iterator for the new element or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Erase() [1/2]

ResultPtr<T> Erase	(	Int	position,
		Int	eraseCnt = `1`
	)

Erases (removes and deletes) elements.

Parameters

[in]	position	Erase index (Erase() will fail if out of bounds and return nullptr).
[in]	eraseCnt	Number of elements to be erased. If eraseCnt is invalid (higher than allowed or negative) a nullptr will be returned.

Returns: Pointer to the element that is now at position. If position equals the number of elements after Erase() a valid pointer is returned but you are not allowed to access it. OutOfMemoryError is only returned on failure (position was out of bounds).

◆ Erase() [2/2]

Iterator Erase	(	Iterator	position,
		Int	eraseCnt = `1`
	)

Erases (removes and deletes) elements.

Parameters

[in]	position	Erase position.
[in]	eraseCnt	Number of elements to be erased. If eraseCnt is invalid (higher than allowed or negative) an invalid iterator will be returned.

Returns: Iterator for the element that is now at position (its operator Bool() will return false if something failed).

◆ SwapErase() [1/2]

ResultMem SwapErase	(	Int	position,
		Int	eraseCnt = `1`
	)

Erases elements within the array and moves elements from the end to the erased gap. This is generally faster than Erase() because at most eraseCnt elements have to be moved, but it changes the order of elements.

Parameters

[in]	position	Erase index (SwapErase() will fail if out of bounds and return nullptr).
[in]	eraseCnt	Number of elements to be erased. If eraseCnt is invalid (higher than allowed or negative) false will be returned.

Returns: OK on success, FAILED if position was out of bounds.

◆ SwapErase() [2/2]

Iterator SwapErase	(	Iterator	position,
		Int	eraseCnt = `1`
	)

Erases elements within the array and moves elements from the end to the erased gap. This is generally faster than Erase() because at most eraseCnt elements have to be moved, but it changes the order of elements.

Parameters

[in]	position	Erase position.
[in]	eraseCnt	Number of elements to be erased. If eraseCnt is invalid (higher than allowed or negative) an invalid iterator will be returned.

Returns: Iterator for the element that is now at position (its operator Bool() will return false if something failed).

◆ GetBlock() [1/4]

MAXON_ATTRIBUTE_FORCE_INLINE Int GetBlock	(	Int	position,
		Block< const T, STRIDED > &	block
	)		const

Determines a contiguous block of array elements which contains the element at position. For a BaseArray, this yields the whole array as a block.

Parameters

[in]	position	Element index.
[out]	block	Block which contains the element at `position`.

Returns: Start index of the block. The requested element can be found within the block at position - start index.

◆ GetBlock() [2/4]

MAXON_ATTRIBUTE_FORCE_INLINE Int GetBlock	(	Int	position,
		Block< T, STRIDED > &	block
	)

Determines a contiguous block of array elements which contains the element at position. For a BaseArray, this yields the whole array as a block.

Parameters

[in]	position	Element index.
[out]	block	Block which contains the element at `position`.

Returns: Start index of the block. The requested element can be found within the block at position - start index.

◆ GetBlock() [3/4]

MAXON_ATTRIBUTE_FORCE_INLINE ConstIterator GetBlock	(	ConstIterator	position,
		Block< const T, STRIDED > &	block
	)		const

Determines a contiguous block of array elements which contains the element at position. For a BaseArray, this yields the whole array as a block.

Parameters

[in]	position	Element position.
[out]	block	Block which contains the element at `position`.

Returns: Start iterator of the block. The requested element can be found within the block at index position - start iterator.

◆ GetBlock() [4/4]

MAXON_ATTRIBUTE_FORCE_INLINE Iterator GetBlock	(	Iterator	position,
		Block< T, STRIDED > &	block
	)

Determines a contiguous block of array elements which contains the element at position. For a BaseArray, this yields the whole array as a block.

Parameters

[in]	position	Element position.
[out]	block	Block which contains the element at `position`.

Returns: Start iterator of the block. The requested element can be found within the block at index position - start iterator.

◆ GetFirst() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE const T* GetFirst ( ) const

Returns the first element of the array. For the BaseArray this is a pointer to a continuous block of memory which contains all elements of the array. You can use it for operations like writing to a stream or copying or moving memory up to the number of allocated elements.

Returns: Pointer to the first element (nullptr if the array is empty).

◆ GetFirst() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE T* GetFirst ( )

Returns the first element of the array. For the BaseArray this is a pointer to a continuous block of memory which contains all elements of the array. You can use it for operations like reading from a stream or copying or moving memory up to the number of allocated elements.

Returns: Pointer to the first element (nullptr if the array is empty).

◆ GetLast() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE const T* GetLast ( ) const

Returns the last element of the array.

Returns: Pointer to the last element (nullptr if the array is empty).

◆ GetLast() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE T* GetLast ( )

Returns the last element of the array.

Returns: Pointer to the last element (nullptr if the array is empty).

◆ Resize()

ResultMem Resize	(	Int	newCnt,
		COLLECTION_RESIZE_FLAGS	resizeFlags = `COLLECTION_RESIZE_FLAGS::DEFAULT`
	)

Resizes the array to contain newCnt elements. If newCnt is smaller than GetCount() all extra elements are being deleted. If it is greater the array is expanded and the default constructor is called for new elements.

Parameters

[in]	newCnt	New array size.
[in]	resizeFlags	See COLLECTION_RESIZE_FLAGS.

Returns: FAILED if allocation failed.

◆ Pop()

MAXON_ATTRIBUTE_FORCE_INLINE Bool Pop ( T * dst = nullptr )

Deletes the last element.

Parameters

[out] dst Nullptr or pointer to return value.

Returns: True if there was at least one element.

◆ GetIndex()

MAXON_ATTRIBUTE_FORCE_INLINE Int GetIndex ( const T & x ) const

Gets the index of the element. The element must be part of the array, otherwise (e.g. if x is a copy of an array element) InvalidArrayIndex will be returned.

Returns: Index of element or InvalidArrayIndex (not element of this).

◆ EnsureCapacity()

ResultMem EnsureCapacity	(	Int	requestedCapacity,
		COLLECTION_RESIZE_FLAGS	resizeFlags = `COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY`
	)

Increases the internal capacity of this array (if necessary) so that it can hold at least the given number of elements without further memory allocations.

Parameters

[in]	requestedCapacity	The desired internal capacity.
[in]	resizeFlags	If ON_GROW_FIT_TO_SIZE is set, the collection will use only as much memory as needed to hold the data.

Returns: FAILED if allocation failed.

◆ SetCapacityHint()

ResultMem SetCapacityHint	(	Int	requestedCapacity,
		COLLECTION_RESIZE_FLAGS	resizeFlags = `COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY`
	)

Prepares the internal buffer(s) to hold at least the given number of elements with as few further memory allocations as possible.

Note: This is just a hint. It does not guarantee that the collection will be able to store the number of indicated elements. Only for a BaseArray, this does the same as EnsureCapacity().

Parameters

[in]	requestedCapacity	The desired internal capacity.
[in]	resizeFlags	If ON_GROW_FIT_TO_SIZE is set, the collection will use only as much memory as needed to hold the data.

Returns: FAILED if allocation failed.

◆ AppendAllImpl() [1/3]

Result<void> AppendAllImpl	(	COLLECTION2 &&	other,
		COLLECTION_RESIZE_FLAGS	resizeFlags,
		Bool	overwrite,
		OverloadRank0
	)

private

Specialization of AppendAllImpl, used by BaseCollection::AppendAll.

◆ AppendAllImpl() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE Result<void> AppendAllImpl	(	BASEARRAY &&	other,
		COLLECTION_RESIZE_FLAGS	resizeFlags,
		Bool	overwrite,
		OverloadRank1
	)

◆ AppendAllImpl() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE Result<void> AppendAllImpl	(	BLOCK &&	other,
		COLLECTION_RESIZE_FLAGS	resizeFlags,
		Bool	overwrite,
		OverloadRank2
	)

◆ CopyFromImpl() [1/2]

Result<void> CopyFromImpl	(	BASEARRAY &&	src,
		COLLECTION_RESIZE_FLAGS	resizeFlags,
		OverloadRank4
	)

private

Specialization of CopyFromImpl for a BaseArray source, used by BaseCollection::CopyFrom.

◆ CopyFromImpl() [2/2]

Result<void> CopyFromImpl	(	BLOCK &&	src,
		COLLECTION_RESIZE_FLAGS	resizeFlags,
		OverloadRank3
	)

private

Specialization of CopyFromImpl for a Block source, used by BaseCollection::CopyFrom.

◆ Swap()

MAXON_ATTRIBUTE_FORCE_INLINE void Swap	(	Iterator	a,
		Iterator	b
	)

Swaps elements a and b (equivalent to global Swap(array[a], array[b]).

Parameters

[in]	a	Position of element to be swapped.
[in]	b	Position of element to be swapped.

◆ GetMemorySize()

Int GetMemorySize ( ) const

Calculates the memory usage for this array. The array element class must have a public member GetMemorySize that returns an element's size.

Returns: Memory size in bytes.

◆ Begin() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE ConstIterator Begin ( ) const

Gets an iterator for the first element. When you modify the array Begin() will change, it is not a constant value.

Returns: Iterator for the first element (equal to End() if the array is empty).

◆ Begin() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Iterator Begin ( )

Gets an iterator for the first element. When you modify the array Begin() will change, it is not a constant value.

Returns: Iterator for the first element (equal to End() if the array is empty).

◆ End() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE ConstIterator End ( ) const

Gets an iterator for the end (End() - 1 is the last element if the array is not empty). When you modify the array End() will change, it is not a constant value.

Returns: Iterator for the array end (points behind the last element).

◆ End() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Iterator End ( )

Gets an iterator for the end (End() - 1 is the last element if the array is not empty). When you modify the array End() will change, it is not a constant value.

Returns: Iterator for the array end (points behind the last element).

◆ MoveAndShrink()

ResultMem MoveAndShrink	(	BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > &	dst,
		Int	position,
		Int	moveCnt
	)

Moves elements to another (empty) array.

Parameters

[out]	dst	The destination array.
[in]	position	Index of the first element to be moved.
[in]	moveCnt	Number of elements to be moved.

Returns: OK on success.

◆ Disconnect()

MAXON_ATTRIBUTE_FORCE_INLINE Block<T> Disconnect ( )

Disconnects the array's memory buffer and returns its content as a block. Afterwards the array is in the same state as directly after its construction.

Returns: Block of the memory buffer.

Note: The memory needs to be freed with the allocator that the array is using.

◆ Connect()

MAXON_ATTRIBUTE_FORCE_INLINE void Connect	(	const Block< T > &	block,
		Int	capacity = `0`
	)

Sets the array's memory buffer to the given block. The current content of this array is freed before.

Parameters

[in]	block	Memory block to use for the array. The array takes ownership of the memory.
[in]	capacity	Capacity of the buffer. If a non-positive value is given, the capacity is assumed to be the same as the size.

Note: The memory pointed to by block must have been allocated by the allocator that the array is using.

◆ GetAllocator() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE ALLOCATOR& GetAllocator ( )

Returns the allocator as reference. Typically this is used by the arrays and other base classes when multiple of them are "stitched" together as one big object all shall use one main allocator.

Returns: Allocator reference.

◆ GetAllocator() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE const ALLOCATOR& GetAllocator ( ) const

Returns the allocator as reference. Typically this is used by the arrays and other base classes when multiple of them are "stitched" together as one big object all shall use one main allocator.

Returns: Allocator reference.

◆ GetUniqueHashCode()

UniqueHash GetUniqueHashCode ( ) const

◆ IncreaseCapacity()

MAXON_WARN_UNUSED T* IncreaseCapacity	(	Int	increment = `1`,
		COLLECTION_RESIZE_FLAGS	resizeFlags = `COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY`
	)

private

BaseArray specific: Appends uninitialized element(s) at the end of the array.

Parameters

[in]	increment	Number of elements to be appended.
[in]	resizeFlags	If ON_GROW_FIT_TO_SIZE is set, the collection will use only as much memory as needed to hold the data.

Returns: Pointer to the element (the constructor hasn't been called yet) or nullptr if reallocation failed.

◆ InsertWithoutConstructor()

MAXON_WARN_UNUSED T* InsertWithoutConstructor	(	Int	idx,
		Int	increment = `1`
	)

private

BaseArray specific: Inserts uninitialized element(s) at the specified index. This does not call the constructor! Use Insert() unless you deal with PODs that shall not be initialized for a very good reason!

Parameters

[in]	idx	Index at which elements shall be inserted (0 <= idx <= cnt).
[in]	increment	Number of elements to be inserted.

Returns: Pointer to the element (the constructor hasn't been called yet) or nullptr.

◆ FitToSize()

ResultMem FitToSize ( Int newCapacity )

private

Friends And Related Function Documentation

◆ GenericBaseArray

friend class GenericBaseArray

friend

Detailed Description

template<typename T, Int MINCHUNKSIZE = BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS MEMFLAGS = BASEARRAYFLAGS::NONE, typename ALLOCATOR = DefaultAllocator> class maxon::BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >

Public Types

Public Member Functions

Private Member Functions

Friends

Additional Inherited Members

Member Typedef Documentation

◆ IsBaseArray

◆ AllocatorType

◆ Iterator

◆ ConstIterator

◆ Super

Constructor & Destructor Documentation

◆ BaseArray() [1/5]

◆ BaseArray() [2/5]

◆ BaseArray() [3/5]

◆ ~BaseArray()

◆ BaseArray() [4/5]

◆ BaseArray() [5/5]

Member Function Documentation

◆ MAXON_DISALLOW_COPY_AND_ASSIGN()

◆ MAXON_OPERATOR_MOVE_ASSIGNMENT()

◆ ToBlock() [1/2]

◆ ToConstBlock()

◆ ToBlock() [2/2]

◆ operator const Block< const T > &()

◆ operator const Block< T > &()

◆ operator StridedBlock< const T >()

◆ operator StridedBlock< T >()

◆ operator Block< const Byte >()

◆ operator Block< Byte >()

◆ Reset()

◆ Flush()

◆ GetCount()

◆ GetCapacityCount()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ Append() [1/17]

◆ Append() [2/17]

◆ AppendBlock() [1/2]

◆ AppendBlock() [2/2]

◆ Append() [3/17]

◆ Append() [4/17]

◆ Append() [5/17]

◆ Append() [6/17]

◆ Append() [7/17]

◆ Append() [8/17]

◆ Append() [9/17]

◆ Append() [10/17]

◆ Append() [11/17]

◆ Append() [12/17]

◆ Append() [13/17]

◆ Append() [14/17]

◆ Append() [15/17]

◆ Append() [16/17]

◆ Append() [17/17]

◆ Insert() [1/16]

◆ Insert() [2/16]

◆ Insert() [3/16]

◆ Insert() [4/16]

◆ Insert() [5/16]

◆ Insert() [6/16]

◆ Insert() [7/16]

◆ Insert() [8/16]

◆ Insert() [9/16]

◆ Insert() [10/16]

◆ Insert() [11/16]

◆ Insert() [12/16]

◆ Insert() [13/16]

◆ Insert() [14/16]

◆ InsertBlock() [1/3]

◆ Insert() [15/16]

◆ InsertBlock() [2/3]

◆ InsertBlock() [3/3]

◆ Insert() [16/16]

◆ Erase() [1/2]

◆ Erase() [2/2]

◆ SwapErase() [1/2]

◆ SwapErase() [2/2]

template<typename T, Int MINCHUNKSIZE = BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS MEMFLAGS = BASEARRAYFLAGS::NONE, typename ALLOCATOR = DefaultAllocator>
class maxon::BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >