#include <Array.h>

Public Member Functions
	Array () noexcept
	Array (const Array< ElementType > &other) noexcept
template<typename TypeToCreateFrom>
	Array (const TypeToCreateFrom *values) noexcept
template<typename TypeToCreateFrom>
	Array (const TypeToCreateFrom *values, int numValues) noexcept
	~Array () noexcept
Array &	operator= (const Array &other) noexcept
template<class OtherArrayType>
bool	operator== (const OtherArrayType &other) const
template<class OtherArrayType>
bool	operator!= (const OtherArrayType &other) const
void	clear () noexcept
void	clearQuick () noexcept
int	size () const noexcept
bool	isEmpty () const noexcept
ElementType	operator[] (const int index) const
ElementType	getUnchecked (const int index) const
ElementType &	getReference (const int index) const noexcept
ElementType	getFirst () const
ElementType	getLast () const
ElementType *	getRawDataPointer () noexcept
ElementType *	begin () const noexcept
ElementType *	end () const noexcept
int	indexOf (ParameterType elementToLookFor) const
bool	contains (ParameterType elementToLookFor) const
bool	add (const ElementType &newElement) noexcept
bool	insert (int indexToInsertAt, ParameterType newElement) noexcept
bool	insertMultiple (int indexToInsertAt, ParameterType newElement, int numberOfTimesToInsertIt)
bool	addIfNotAlreadyThere (ParameterType newElement)
void	set (const int indexToChange, ParameterType newValue)
void	setUnchecked (const int indexToChange, ParameterType newValue)
template<typename Type>
void	addArray (const Type *elementsToAdd, int numElementsToAdd)
template<typename Type>
void	addNullTerminatedArray (const Type const elementsToAdd)
template<class OtherArrayType>
void	swapWith (OtherArrayType &otherArray) noexcept
template<class OtherArrayType>
void	addArray (const OtherArrayType &arrayToAddFrom, int startIndex=0, int numElementsToAdd=-1)
void	resize (const int targetNumItems)
template<class ElementComparator>
int	addSorted (ElementComparator &comparator, ParameterType newElement)
void	addUsingDefaultSort (ParameterType newElement)
template<typename ElementComparator, typename TargetValueType>
int	indexOfSorted (ElementComparator &comparator, TargetValueType elementToLookFor) const
void	remove (int indexToRemove)
ElementType	removeAndReturn (const int indexToRemove)
void	remove (const ElementType *elementToRemove)
void	removeFirstMatchingValue (ParameterType valueToRemove)
int	removeAllInstancesOf (ParameterType valueToRemove)
template<typename PredicateType>
int	removeIf (PredicateType predicate)
void	removeRange (int startIndex, int numberToRemove)
void	removeLast (int howManyToRemove=1)
template<class OtherArrayType>
void	removeValuesIn (const OtherArrayType &otherArray)
template<class OtherArrayType>
void	removeValuesNotIn (const OtherArrayType &otherArray)
void	swap (const int index1, const int index2)
bool	minimiseStorageOverheads () noexcept
bool	ensureStorageAllocated (const int minNumElements) noexcept
void	sort ()
template<class ElementComparator>
void	sort (ElementComparator &comparator, const bool retainOrderOfEquivalentItems=false)

Private Member Functions
typedef	PARAMETER_TYPE (ElementType) ParameterType
void	removeInternal (const int indexToRemove)
void	deleteAllElements () noexcept
void	minimiseStorageAfterRemoval ()

Private Attributes
ArrayAllocationBase< ElementType >	data
int	numUsed

Detailed Description

template<typename ElementType, size_t minimumAllocatedSize = 0>
class water::Array< ElementType, minimumAllocatedSize >

Holds a resizable array of primitive or copy-by-value objects.

Examples of arrays are: Array<int>, Array<Rectangle> or Array<MyClass*>

The Array class can be used to hold simple, non-polymorphic objects as well as primitive types - to do so, the class must fulfil these requirements:

it must have a copy constructor and assignment operator
it must be able to be relocated in memory by a memcpy without this causing any problems - so objects whose functionality relies on external pointers or references to themselves can not be used.

You can of course have an array of pointers to any kind of object, e.g. Array<MyClass*>, but if you do this, the array doesn't take any ownership of the objects - see the OwnedArray class or the ReferenceCountedArray class for more powerful ways of holding lists of objects.

For holding lists of strings, you can use Array<String>, but it's usually better to use the specialised class StringArray, which provides more useful functions.

See also: OwnedArray, ReferenceCountedArray, StringArray, CriticalSection

Constructor & Destructor Documentation

◆ Array() [1/4]

template<typename ElementType, size_t minimumAllocatedSize = 0>

water::Array< ElementType, minimumAllocatedSize >::Array ( )

inlinenoexcept

Creates an empty array.

◆ Array() [2/4]

template<typename ElementType, size_t minimumAllocatedSize = 0>

water::Array< ElementType, minimumAllocatedSize >::Array ( const Array< ElementType > & other )

inlinenoexcept

Creates a copy of another array.

Parameters

other the array to copy

◆ Array() [3/4]

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<typename TypeToCreateFrom>

water::Array< ElementType, minimumAllocatedSize >::Array ( const TypeToCreateFrom * values )

inlineexplicitnoexcept

Initalises from a null-terminated C array of values.

Parameters

values the array to copy from

◆ Array() [4/4]

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<typename TypeToCreateFrom>

water::Array< ElementType, minimumAllocatedSize >::Array	(	const TypeToCreateFrom *	values,
		int	numValues )

inlinenoexcept

Initalises from a C array of values.

Parameters

values	the array to copy from
numValues	the number of values in the array

◆ ~Array()

template<typename ElementType, size_t minimumAllocatedSize = 0>

water::Array< ElementType, minimumAllocatedSize >::~Array ( )

inlinenoexcept

Destructor.

Member Function Documentation

◆ add()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::add ( const ElementType & newElement )

inlinenoexcept

Appends a new element at the end of the array.

Parameters

newElement the new object to add to the array

See also: set, insert, addIfNotAlreadyThere, addSorted, addUsingDefaultSort, addArray

◆ addArray() [1/2]

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class OtherArrayType>

void water::Array< ElementType, minimumAllocatedSize >::addArray	(	const OtherArrayType &	arrayToAddFrom,
		int	startIndex = 0,
		int	numElementsToAdd = -1 )

inline

Adds elements from another array to the end of this array.

Parameters

arrayToAddFrom	the array from which to copy the elements
startIndex	the first element of the other array to start copying from
numElementsToAdd	how many elements to add from the other array. If this value is negative or greater than the number of available elements, all available elements will be copied.

See also: add

◆ addArray() [2/2]

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<typename Type>

void water::Array< ElementType, minimumAllocatedSize >::addArray	(	const Type *	elementsToAdd,
		int	numElementsToAdd )

inline

Adds elements from an array to the end of this array.

Parameters

elementsToAdd	an array of some kind of object from which elements can be constructed.
numElementsToAdd	how many elements are in this other array

See also: add

◆ addIfNotAlreadyThere()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::addIfNotAlreadyThere ( ParameterType newElement )

inline

Appends a new element at the end of the array as long as the array doesn't already contain it.

If the array already contains an element that matches the one passed in, nothing will be done.

Parameters

newElement the new object to add to the array

Returns: true if the element was added to the array; false otherwise.

◆ addNullTerminatedArray()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<typename Type>

void water::Array< ElementType, minimumAllocatedSize >::addNullTerminatedArray ( const Type *const * elementsToAdd )

inline

Adds elements from a null-terminated array of pointers to the end of this array.

Parameters

elementsToAdd an array of pointers to some kind of object from which elements can be constructed. This array must be terminated by a nullptr

See also: addArray

◆ addSorted()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class ElementComparator>

int water::Array< ElementType, minimumAllocatedSize >::addSorted	(	ElementComparator &	comparator,
		ParameterType	newElement )

inline

Inserts a new element into the array, assuming that the array is sorted.

This will use a comparator to find the position at which the new element should go. If the array isn't sorted, the behaviour of this method will be unpredictable.

Parameters

comparator	the comparator to use to compare the elements - see the sort() method for details about the form this object should take
newElement	the new element to insert to the array

Returns: the index at which the new item was added

See also: addUsingDefaultSort, add, sort

◆ addUsingDefaultSort()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::addUsingDefaultSort ( ParameterType newElement )

inline

Inserts a new element into the array, assuming that the array is sorted.

This will use the DefaultElementComparator class for sorting, so your ElementType must be suitable for use with that class. If the array isn't sorted, the behaviour of this method will be unpredictable.

Parameters

newElement the new element to insert to the array

See also: addSorted, sort

◆ begin()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType * water::Array< ElementType, minimumAllocatedSize >::begin ( ) const

inlinenoexcept

Returns a pointer to the first element in the array. This method is provided for compatibility with standard C++ iteration mechanisms.

◆ clear()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::clear ( )

inlinenoexcept

Removes all elements from the array. This will remove all the elements, and free any storage that the array is using. To clear the array without freeing the storage, use the clearQuick() method instead.

See also: clearQuick

◆ clearQuick()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::clearQuick ( )

inlinenoexcept

Removes all elements from the array without freeing the array's allocated storage.

See also: clear

◆ contains()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::contains ( ParameterType elementToLookFor ) const

inline

Returns true if the array contains at least one occurrence of an object.

Parameters

elementToLookFor the value or object to look for

Returns: true if the item is found

◆ deleteAllElements()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::deleteAllElements ( )

inlineprivatenoexcept

◆ end()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType * water::Array< ElementType, minimumAllocatedSize >::end ( ) const

inlinenoexcept

Returns a pointer to the element which follows the last element in the array. This method is provided for compatibility with standard C++ iteration mechanisms.

◆ ensureStorageAllocated()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::ensureStorageAllocated ( const int minNumElements )

inlinenoexcept

Increases the array's internal storage to hold a minimum number of elements.

Calling this before adding a large known number of elements means that the array won't have to keep dynamically resizing itself as the elements are added, and it'll therefore be more efficient.

◆ getFirst()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType water::Array< ElementType, minimumAllocatedSize >::getFirst ( ) const

inline

Returns the first element in the array, or a default value if the array is empty.

See also: operator[], getUnchecked, getLast

◆ getLast()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType water::Array< ElementType, minimumAllocatedSize >::getLast ( ) const

inline

Returns the last element in the array, or a default value if the array is empty.

See also: operator[], getUnchecked, getFirst

◆ getRawDataPointer()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType * water::Array< ElementType, minimumAllocatedSize >::getRawDataPointer ( )

inlinenoexcept

Returns a pointer to the actual array data. This pointer will only be valid until the next time a non-const method is called on the array.

◆ getReference()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType & water::Array< ElementType, minimumAllocatedSize >::getReference ( const int index ) const

inlinenoexcept

Returns a direct reference to one of the elements in the array, without checking the index passed in.

This is like getUnchecked, but returns a direct reference to the element, so that you can alter it directly. Obviously this can be dangerous, so only use it when absolutely necessary.

Parameters

index the index of the element being requested (0 is the first element in the array)

See also: operator[], getFirst, getLast

◆ getUnchecked()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType water::Array< ElementType, minimumAllocatedSize >::getUnchecked ( const int index ) const

inline

Returns one of the elements in the array, without checking the index passed in.

Unlike the operator[] method, this will try to return an element without checking that the index is within the bounds of the array, so should only be used when you're confident that it will always be a valid index.

Parameters

index the index of the element being requested (0 is the first element in the array)

See also: operator[], getFirst, getLast

◆ indexOf()

template<typename ElementType, size_t minimumAllocatedSize = 0>

int water::Array< ElementType, minimumAllocatedSize >::indexOf ( ParameterType elementToLookFor ) const

inline

Finds the index of the first element which matches the value passed in.

This will search the array for the given object, and return the index of its first occurrence. If the object isn't found, the method will return -1.

Parameters

elementToLookFor the value or object to look for

Returns: the index of the object, or -1 if it's not found

◆ indexOfSorted()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<typename ElementComparator, typename TargetValueType>

int water::Array< ElementType, minimumAllocatedSize >::indexOfSorted	(	ElementComparator &	comparator,
		TargetValueType	elementToLookFor ) const

inline

Finds the index of an element in the array, assuming that the array is sorted.

This will use a comparator to do a binary-chop to find the index of the given element, if it exists. If the array isn't sorted, the behaviour of this method will be unpredictable.

Parameters

comparator	the comparator to use to compare the elements - see the sort() method for details about the form this object should take
elementToLookFor	the element to search for

Returns: the index of the element, or -1 if it's not found

See also: addSorted, sort

◆ insert()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::insert	(	int	indexToInsertAt,
		ParameterType	newElement )

inlinenoexcept

Inserts a new element into the array at a given position.

If the index is less than 0 or greater than the size of the array, the element will be added to the end of the array. Otherwise, it will be inserted into the array, moving all the later elements along to make room.

Parameters

indexToInsertAt	the index at which the new element should be inserted (pass in -1 to add it to the end)
newElement	the new object to add to the array

See also: add, addSorted, addUsingDefaultSort, set

◆ insertMultiple()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::insertMultiple	(	int	indexToInsertAt,
		ParameterType	newElement,
		int	numberOfTimesToInsertIt )

inline

Inserts multiple copies of an element into the array at a given position.

If the index is less than 0 or greater than the size of the array, the element will be added to the end of the array. Otherwise, it will be inserted into the array, moving all the later elements along to make room.

Parameters

indexToInsertAt	the index at which the new element should be inserted
newElement	the new object to add to the array
numberOfTimesToInsertIt	how many copies of the value to insert

See also: insert, add, addSorted, set

◆ isEmpty()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::isEmpty ( ) const

inlinenoexcept

Returns true if the array is empty, false otherwise.

◆ minimiseStorageAfterRemoval()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::minimiseStorageAfterRemoval ( )

inlineprivate

◆ minimiseStorageOverheads()

template<typename ElementType, size_t minimumAllocatedSize = 0>

bool water::Array< ElementType, minimumAllocatedSize >::minimiseStorageOverheads ( )

inlinenoexcept

Reduces the amount of storage being used by the array.

Arrays typically allocate slightly more storage than they need, and after removing elements, they may have quite a lot of unused space allocated. This method will reduce the amount of allocated storage to a minimum.

◆ operator!=()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class OtherArrayType>

bool water::Array< ElementType, minimumAllocatedSize >::operator!= ( const OtherArrayType & other ) const

inline

Compares this array to another one. Two arrays are considered equal if they both contain the same set of elements, in the same order.

Parameters

other the other array to compare with

◆ operator=()

template<typename ElementType, size_t minimumAllocatedSize = 0>

Array & water::Array< ElementType, minimumAllocatedSize >::operator= ( const Array< ElementType, minimumAllocatedSize > & other )

inlinenoexcept

Copies another array.

Parameters

other the array to copy

◆ operator==()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class OtherArrayType>

bool water::Array< ElementType, minimumAllocatedSize >::operator== ( const OtherArrayType & other ) const

inline

Compares this array to another one. Two arrays are considered equal if they both contain the same set of elements, in the same order.

Parameters

other the other array to compare with

◆ operator[]()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType water::Array< ElementType, minimumAllocatedSize >::operator[] ( const int index ) const

inline

Returns one of the elements in the array. If the index passed in is beyond the range of valid elements, this will return a default value.

If you're certain that the index will always be a valid element, you can call getUnchecked() instead, which is faster.

Parameters

index the index of the element being requested (0 is the first element in the array)

See also: getUnchecked, getFirst, getLast

◆ PARAMETER_TYPE()

template<typename ElementType, size_t minimumAllocatedSize = 0>

typedef water::Array< ElementType, minimumAllocatedSize >::PARAMETER_TYPE ( ElementType )

private

◆ remove() [1/2]

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::remove ( const ElementType * elementToRemove )

inline

Removes an element from the array.

This will remove the element pointed to by the given iterator, and move back all the subsequent elements to close the gap. If the iterator passed in does not point to an element within the array, behaviour is undefined.

Parameters

elementToRemove a pointer to the element to remove

See also: removeFirstMatchingValue, removeAllInstancesOf, removeRange, removeIf

◆ remove() [2/2]

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::remove ( int indexToRemove )

inline

Removes an element from the array.

This will remove the element at a given index, and move back all the subsequent elements to close the gap. If the index passed in is out-of-range, nothing will happen.

Parameters

indexToRemove the index of the element to remove

See also: removeAndReturn, removeFirstMatchingValue, removeAllInstancesOf, removeRange

◆ removeAllInstancesOf()

template<typename ElementType, size_t minimumAllocatedSize = 0>

int water::Array< ElementType, minimumAllocatedSize >::removeAllInstancesOf ( ParameterType valueToRemove )

inline

Removes items from the array.

This will remove all occurrences of the given element from the array. If no such items are found, no action is taken.

Parameters

valueToRemove the object to try to remove

Returns: how many objects were removed.

See also: remove, removeRange, removeIf

◆ removeAndReturn()

template<typename ElementType, size_t minimumAllocatedSize = 0>

ElementType water::Array< ElementType, minimumAllocatedSize >::removeAndReturn ( const int indexToRemove )

inline

Removes an element from the array.

This will remove the element at a given index, and move back all the subsequent elements to close the gap. If the index passed in is out-of-range, nothing will happen.

Parameters

indexToRemove the index of the element to remove

Returns: the element that has been removed

See also: removeFirstMatchingValue, removeAllInstancesOf, removeRange

◆ removeFirstMatchingValue()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::removeFirstMatchingValue ( ParameterType valueToRemove )

inline

Removes an item from the array.

This will remove the first occurrence of the given element from the array. If the item isn't found, no action is taken.

Parameters

valueToRemove the object to try to remove

See also: remove, removeRange, removeIf

◆ removeIf()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<typename PredicateType>

int water::Array< ElementType, minimumAllocatedSize >::removeIf ( PredicateType predicate )

inline

Removes items from the array.

This will remove all objects from the array that match a condition. If no such items are found, no action is taken.

Parameters

predicate the condition when to remove an item. Must be a callable type that takes an ElementType and returns a bool

Returns: how many objects were removed.

See also: remove, removeRange, removeAllInstancesOf

◆ removeInternal()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::removeInternal ( const int indexToRemove )

inlineprivate

◆ removeLast()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::removeLast ( int howManyToRemove = 1 )

inline

Removes the last n elements from the array.

Parameters

howManyToRemove how many elements to remove from the end of the array

See also: remove, removeFirstMatchingValue, removeAllInstancesOf, removeRange

◆ removeRange()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::removeRange	(	int	startIndex,
		int	numberToRemove )

inline

Removes a range of elements from the array.

This will remove a set of elements, starting from the given index, and move subsequent elements down to close the gap.

If the range extends beyond the bounds of the array, it will be safely clipped to the size of the array.

Parameters

startIndex	the index of the first element to remove
numberToRemove	how many elements should be removed

See also: remove, removeFirstMatchingValue, removeAllInstancesOf, removeIf

◆ removeValuesIn()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class OtherArrayType>

void water::Array< ElementType, minimumAllocatedSize >::removeValuesIn ( const OtherArrayType & otherArray )

inline

Removes any elements which are also in another array.

Parameters

otherArray the other array in which to look for elements to remove

See also: removeValuesNotIn, remove, removeFirstMatchingValue, removeAllInstancesOf, removeRange

◆ removeValuesNotIn()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class OtherArrayType>

void water::Array< ElementType, minimumAllocatedSize >::removeValuesNotIn ( const OtherArrayType & otherArray )

inline

Removes any elements which are not found in another array.

Only elements which occur in this other array will be retained.

Parameters

otherArray the array in which to look for elements NOT to remove

See also: removeValuesIn, remove, removeFirstMatchingValue, removeAllInstancesOf, removeRange

◆ resize()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::resize ( const int targetNumItems )

inline

This will enlarge or shrink the array to the given number of elements, by adding or removing items from its end.

If the array is smaller than the given target size, empty elements will be appended until its size is as specified. If its size is larger than the target, items will be removed from its end to shorten it.

◆ set()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::set	(	const int	indexToChange,
		ParameterType	newValue )

inline

Replaces an element with a new value.

If the index is less than zero, this method does nothing. If the index is beyond the end of the array, the item is added to the end of the array.

Parameters

indexToChange	the index whose value you want to change
newValue	the new value to set for this index.

See also: add, insert

◆ setUnchecked()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::setUnchecked	(	const int	indexToChange,
		ParameterType	newValue )

inline

Replaces an element with a new value without doing any bounds-checking.

This just sets a value directly in the array's internal storage, so you'd better make sure it's in range!

Parameters

indexToChange	the index whose value you want to change
newValue	the new value to set for this index.

See also: set, getUnchecked

◆ size()

template<typename ElementType, size_t minimumAllocatedSize = 0>

int water::Array< ElementType, minimumAllocatedSize >::size ( ) const

inlinenoexcept

Returns the current number of elements in the array.

◆ sort() [1/2]

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::sort ( )

inline

Sorts the array using a default comparison operation. If the type of your elements isn't supported by the DefaultElementComparator class then you may need to use the other version of sort, which takes a custom comparator.

◆ sort() [2/2]

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class ElementComparator>

void water::Array< ElementType, minimumAllocatedSize >::sort	(	ElementComparator &	comparator,
		const bool	retainOrderOfEquivalentItems = false )

inline

Sorts the elements in the array.

This will use a comparator object to sort the elements into order. The object passed must have a method of the form:

int compareElements (ElementType first, ElementType second);

..and this method must return:

a value of < 0 if the first comes before the second
a value of 0 if the two objects are equivalent
a value of > 0 if the second comes before the first

To improve performance, the compareElements() method can be declared as static or const.

Parameters

comparator	the comparator to use for comparing elements.
retainOrderOfEquivalentItems	if this is true, then items which the comparator says are equivalent will be kept in the order in which they currently appear in the array. This is slower to perform, but may be important in some cases. If it's false, a faster algorithm is used, but equivalent elements may be rearranged.

See also: addSorted, indexOfSorted, sortArray

◆ swap()

template<typename ElementType, size_t minimumAllocatedSize = 0>

void water::Array< ElementType, minimumAllocatedSize >::swap	(	const int	index1,
		const int	index2 )

inline

Swaps over two elements in the array.

This swaps over the elements found at the two indexes passed in. If either index is out-of-range, this method will do nothing.

Parameters

index1	index of one of the elements to swap
index2	index of the other element to swap

◆ swapWith()

template<typename ElementType, size_t minimumAllocatedSize = 0>

template<class OtherArrayType>

void water::Array< ElementType, minimumAllocatedSize >::swapWith ( OtherArrayType & otherArray )

inlinenoexcept

This swaps the contents of this array with those of another array.

If you need to exchange two arrays, this is vastly quicker than using copy-by-value because it just swaps their internal pointers.

Member Data Documentation

◆ data

template<typename ElementType, size_t minimumAllocatedSize = 0>

ArrayAllocationBase<ElementType> water::Array< ElementType, minimumAllocatedSize >::data

private

◆ numUsed

template<typename ElementType, size_t minimumAllocatedSize = 0>

int water::Array< ElementType, minimumAllocatedSize >::numUsed

private

The documentation for this class was generated from the following file:

/home/runner/work/lmms-fork/lmms-fork/plugins/CarlaBase/carla/source/modules/water/containers/Array.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Array() [1/4]

◆ Array() [2/4]

◆ Array() [3/4]

◆ Array() [4/4]

◆ ~Array()

Member Function Documentation

◆ add()

◆ addArray() [1/2]

◆ addArray() [2/2]

◆ addIfNotAlreadyThere()

◆ addNullTerminatedArray()

◆ addSorted()

◆ addUsingDefaultSort()

◆ begin()

◆ clear()

◆ clearQuick()

◆ contains()

◆ deleteAllElements()

◆ end()

◆ ensureStorageAllocated()

◆ getFirst()

◆ getLast()

◆ getRawDataPointer()

◆ getReference()

◆ getUnchecked()

◆ indexOf()

◆ indexOfSorted()

◆ insert()

◆ insertMultiple()

◆ isEmpty()

◆ minimiseStorageAfterRemoval()

◆ minimiseStorageOverheads()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ operator[]()

◆ PARAMETER_TYPE()

◆ remove() [1/2]

◆ remove() [2/2]

◆ removeAllInstancesOf()

◆ removeAndReturn()

◆ removeFirstMatchingValue()

◆ removeIf()

◆ removeInternal()

◆ removeLast()

◆ removeRange()

◆ removeValuesIn()

◆ removeValuesNotIn()

◆ resize()

◆ set()

◆ setUnchecked()

◆ size()

◆ sort() [1/2]

◆ sort() [2/2]

◆ swap()

◆ swapWith()

Member Data Documentation

◆ data

◆ numUsed