BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > Class Template Reference

#include <basearray.h>

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

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
TType of the array elements.
MINCHUNKSIZEThe minimum number of elements upon array creation.
MEMFLAGSUse BASEARRAYFLAGS::NONE unless you know the object can be moved and/or copied.
ALLOCATORClass 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 AllocatorType = ALLOCATOR
 
using Iterator = BaseIterator< BaseArray, false >
 
using ConstIterator = BaseIterator< const BaseArray, false >
 
using Super = ArrayBase< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value >, DefaultCompare >
 
- Public Types inherited from Collection< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value > >
using Super = BaseCollection< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value > >
 
using ValueType = T
 
- Public Types inherited from BaseCollection< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value > >
using IsCollection = std::true_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< 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_scalar<DUMMY>::value>::type>
 operator Block< const Byte > () const
 
template<typename DUMMY = T, typename = typename std::enable_if<std::is_scalar<DUMMY>::value>::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)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T > Append ()
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T > Append (const T &x)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T > Append (T &&x)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T > Append (const Block< const T > &values)
 
ResultPtr< T > Append (const MoveBlock< T > &values)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T > Append (const std::initializer_list< T > &values)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T > Insert (Int position)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT< IteratorInsert (Iterator position)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T > Insert (Int position, const T &x)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT< IteratorInsert (Iterator position, const T &x)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< T > Insert (Int position, T &&x)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT< IteratorInsert (Iterator position, T &&x)
 
ResultPtr< T > Insert (Int position, const Block< const T > &values)
 
ResultPtr< T > Insert (Int position, const std::initializer_list< T > &values)
 
ResultPtr< T > Insert (Int position, const MoveBlock< T > &values)
 
ResultMemT< IteratorInsert (Iterator position, const Block< const T > &values)
 
ResultMemT< IteratorInsert (Iterator position, const std::initializer_list< T > &values)
 
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)
 
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
 
- Public Member Functions inherited from ArrayBase< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value >, DefaultCompare >
MAXON_ATTRIBUTE_FORCE_INLINE ArrayBase (ARGS &&... args)
 
ArrayImpl< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > &> ToArray ()
 
ArrayImpl< const BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > &> ToArray () const
 
MAXON_ATTRIBUTE_FORCE_INLINE operator ArrayImpl< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > &> ()
 
MAXON_ATTRIBUTE_FORCE_INLINE operator ArrayImpl< const BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > &> () const
 
- Public Member Functions inherited from ArrayBase0< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value >, DefaultCompare >
MAXON_ATTRIBUTE_FORCE_INLINE ArrayBase0 (ARGS &&... args)
 
Bool IsValidIndex (Int index) const
 
Result< void > CheckValidIndex (Int index) const
 
Int FindIndex (typename ByValueParam< T >::type v, Int start) const
 
Int FindLastIndex (typename ByValueParam< T >::type v) const
 
Int FindLastIndex (typename ByValueParam< T >::type v, Int start) const
 
Bool EraseFirst (typename ByValueParam< T >::type v)
 
Int EraseAll (typename ByValueParam< T >::type v)
 
Result< void > AppendAllImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank0)
 
Result< void > InsertAll (Int index, COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)
 
Result< void > Add (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)
 
Result< void > SubtractImpl (COLLECTION2 &&other, OverloadRank0)
 
Bool IsEqualImpl (const COLLECTION2 &other, COMPARE &&cmp, OverloadRank0) const
 
UInt GetHashCode () const
 
MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > > Slice (Int start)
 
MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< const BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > > Slice (Int start) const
 
MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > > Slice (Int start, Int end)
 
MAXON_ATTRIBUTE_FORCE_INLINE AutoIterator< const BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > > Slice (Int start, Int end) const
 
BlockIterator< false, false > GetBlocks ()
 
BlockIterator< true, false > GetBlocks () const
 
BlockIterator< false, true > GetStridedBlocks ()
 
BlockIterator< true, true > GetStridedBlocks () const
 
- Public Member Functions inherited from Collection< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value > >
MAXON_ATTRIBUTE_FORCE_INLINE Collection (ARGS &&... args)
 
ResultOk< void > VariadicAppend ()
 
Result< void > VariadicAppend (V &&value, VALUES &&... rest)
 
 operator ValueReceiver< const T &> ()
 
 operator ValueReceiver< T &&> ()
 
 operator ValueReceiver< typename std::conditional< std::is_scalar< T >::value, T, DummyParamType &>::type > ()
 
Result< BoolForEach (FN &&callback)
 
H::Iterator Find (typename ByValueParam< T >::type v)
 
H::ConstIterator Find (typename ByValueParam< T >::type v) const
 
Int FindIndex (typename ByValueParam< T >::type v) const
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool Contains (typename ByValueParam< T >::type v) const
 
- Public Member Functions inherited from BaseCollection< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value > >
MAXON_ATTRIBUTE_FORCE_INLINE BaseCollection (ARGS &&... args)
 
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type operator== (const COLLECTION2 &other) const
 
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type operator!= (const COLLECTION2 &other) const
 
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value &&!std::is_same< typename std::decay< COMPARE >::type, EQUALITY >::value, Bool >::type IsEqual (const COLLECTION2 &other, COMPARE &&cmp=COMPARE()) const
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > AppendAll (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > CopyFrom (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::FIT_TO_SIZE)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > Subtract (COLLECTION2 &&other)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > Intersect (const COLLECTION2 &other)
 
Bool Intersects (const COLLECTION2 &other) const
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > CopyFromImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, OverloadRank0)
 
Result< void > AppendAllImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank0)
 
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) const
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool ContainsAll (COLLECTION2 &&other) const
 
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_same<typename std::decay<BASEARRAY>::type, BaseArray>::value>::type>
Result< void > CopyFromImpl (BASEARRAY &&src, COLLECTION_RESIZE_FLAGS resizeFlags, OverloadRank4)
 
template<typename BLOCK , typename = typename std::enable_if<std::is_same<typename std::decay<BLOCK>::type, Block<T>>::value>::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< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value > >
static const T & GetMapKey (const T &key)
 
- Static Public Attributes inherited from ArrayBase0< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >, T, BaseArrayData< T, ALLOCATOR, std::is_empty< ALLOCATOR >::value >, DefaultCompare >
static const COLLECTION_KIND KIND
 

Member Typedef Documentation

◆ 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, ALLOCATOR, std::is_empty<ALLOCATOR>::value>, DefaultCompare>

Constructor & Destructor Documentation

◆ BaseArray() [1/5]

Default constructor. Creates an empty arry.

◆ 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()

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]blockMemory block to use for the array. The array takes ownership of the memory.
[in]capacityCapacity 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.

◆ 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 ( void  )

Deletes all elements (calls destructors and frees memory).

◆ Flush()

void Flush ( void  )

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

◆ GetCount()

MAXON_ATTRIBUTE_FORCE_INLINE Int GetCount ( void  ) 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]idxElement 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]idxElement 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/6]

Adds a new element at the end of the array.

Returns
Element reference or OutOfMemoryError if the allocation failed.

◆ Append() [2/6]

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

Adds a new element at the end of the array and initializes it with a copy of x.

Parameters
[in]xValue to be copied.
Returns
Element reference or OutOfMemoryError if the allocation failed.

◆ Append() [3/6]

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

Adds a new element at the end of the array and moves the content of x to it.

Parameters
[in]xValue to be moved.
Returns
Element reference or OutOfMemoryError if the allocation failed.

◆ Append() [4/6]

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

Appends new elements at the end of the array.

Parameters
[in]valuesBlock 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() [5/6]

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

Appends new elements at the end of the array.

Parameters
[in]valuesBlock 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() [6/6]

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

Appends new elements at the end of the array.

Parameters
[in]valuesInitializer list with values to be copied.
Returns
Element pointer or OutOfMemoryError if the allocation failed.

◆ Insert() [1/11]

MAXON_ATTRIBUTE_FORCE_INLINE ResultRef<T> Insert ( Int  position)

Inserts a new default element at index position.

Parameters
[in]positionInsert index (the array size will increase and the existing elements are moved).
Returns
Element reference or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [2/11]

Inserts a new default element at iterator position.

Parameters
[in]positionInsert position.
Returns
Iterator for the new element or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [3/11]

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

Inserts a new element at index position and initializes it with a copy of x.

Parameters
[in]positionInsert index (the array size will increase and the existing elements are moved).
[in]xValue to be copied.
Returns
Element reference or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [4/11]

MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT<Iterator> Insert ( Iterator  position,
const T &  x 
)

Inserts a new element at iterator position and initializes it with a copy of x.

Parameters
[in]positionInsert position.
[in]xValue to be copied.
Returns
Iterator for the new element or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [5/11]

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

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

Parameters
[in]positionInsert index (the array size will increase and the existing elements are moved).
[in]xValue to be moved.
Returns
Element reference or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [6/11]

MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT<Iterator> Insert ( Iterator  position,
T &&  x 
)

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

Parameters
[in]positionInsert position.
[in]xValue to be moved.
Returns
Iterator for the new element or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [7/11]

ResultPtr<T> Insert ( 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]positionInsert index (the array size will increase and the existing elements are moved).
[in]valuesBlock 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() [8/11]

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]positionInsert index (the array size will increase and the existing elements are moved).
[in]valuesInitializer list with values to be copied.
Returns
Element pointer or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [9/11]

ResultPtr<T> Insert ( 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]positionInsert index (the array size will increase and the existing elements are moved).
[in]valuesBlock 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/11]

ResultMemT<Iterator> Insert ( Iterator  position,
const Block< const T > &  values 
)

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

Parameters
[in]positionInsert position.
[in]valuesBlock 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
Iterator for the new element or OutOfMemoryError if the allocation failed (or position is out of boundaries).

◆ Insert() [11/11]

ResultMemT<Iterator> Insert ( Iterator  position,
const std::initializer_list< T > &  values 
)

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

Parameters
[in]positionInsert position.
[in]valuesInitializer list with values to be copied.
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]positionErase index (Erase() will fail if out of bounds and return nullptr).
[in]eraseCntNumber 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]positionErase position.
[in]eraseCntNumber 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]positionErase index (SwapErase() will fail if out of bounds and return nullptr).
[in]eraseCntNumber 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]positionErase position.
[in]eraseCntNumber 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]positionElement index.
[out]blockBlock 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]positionElement index.
[out]blockBlock 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]positionElement position.
[out]blockBlock 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]positionElement position.
[out]blockBlock 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]

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]

Returns the last element of the array.

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

◆ Resize()

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]newCntNew array size.
[in]resizeFlagsSee COLLECTION_RESIZE_FLAGS.
Returns
FAILED if allocation failed.

◆ Pop()

MAXON_ATTRIBUTE_FORCE_INLINE Bool Pop ( T *  dst = nullptr)

Deletes the last element.

Parameters
[out]dstNullptr 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]requestedCapacityThe desired internal capacity.
[in]resizeFlagsIf 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]requestedCapacityThe desired internal capacity.
[in]resizeFlagsIf 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()

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

Specialization of AppendAllImpl, used by BaseCollection::AppendAll.

◆ 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()

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

Parameters
[in]aPosition of element to be swapped.
[in]bPosition of element to be swapped.

◆ GetMemorySize()

Int GetMemorySize ( void  ) 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]

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]

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]

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]

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]dstThe destination array.
[in]positionIndex of the first element to be moved.
[in]moveCntNumber of elements to be moved.
Returns
OK on success.

◆ 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]blockMemory block to use for the array. The array takes ownership of the memory.
[in]capacityCapacity 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.

◆ 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]incrementNumber of elements to be appended.
[in]resizeFlagsIf 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.

◆ 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]idxIndex at which elements shall be inserted (0 <= idx <= cnt).
[in]incrementNumber 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