LMMS
Loading...
Searching...
No Matches
Public Member Functions | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse > Class Template Reference

#include <juce_ArrayBase.h>

Inheritance diagram for juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >:

Public Member Functions

 ArrayBase ()=default
 ~ArrayBase ()
 ArrayBase (ArrayBase &&other) noexcept
ArrayBase & operator= (ArrayBase &&other) noexcept
template<class OtherElementType, class OtherCriticalSection, typename = AllowConversion<OtherElementType, OtherCriticalSection>>
 ArrayBase (ArrayBase< OtherElementType, OtherCriticalSection > &&other) noexcept
template<class OtherElementType, class OtherCriticalSection, typename = AllowConversion<OtherElementType, OtherCriticalSection>>
ArrayBase & operator= (ArrayBase< OtherElementType, OtherCriticalSection > &&other) noexcept
template<class OtherArrayType>
bool operator== (const OtherArrayType &other) const noexcept
template<class OtherArrayType>
bool operator!= (const OtherArrayType &other) const noexcept
ElementType & operator[] (const int index) noexcept
const ElementType & operator[] (const int index) const noexcept
ElementType getValueWithDefault (const int index) const noexcept
ElementType getFirst () const noexcept
ElementType getLast () const noexcept
ElementType * begin () noexcept
const ElementType * begin () const noexcept
ElementType * end () noexcept
const ElementType * end () const noexcept
ElementType * data () noexcept
const ElementType * data () const noexcept
int size () const noexcept
int capacity () const noexcept
void setAllocatedSize (int numElements)
void ensureAllocatedSize (int minNumElements)
void shrinkToNoMoreThan (int maxNumElements)
void clear ()
void swapWith (ArrayBase &other) noexcept
void add (const ElementType &newElement)
void add (ElementType &&newElement)
template<typename... OtherElements>
void add (const ElementType &firstNewElement, OtherElements &&... otherElements)
template<typename... OtherElements>
void add (ElementType &&firstNewElement, OtherElements &&... otherElements)
template<typename Type>
void addArray (const Type *elementsToAdd, int numElementsToAdd)
template<typename TypeToCreateFrom>
void addArray (const std::initializer_list< TypeToCreateFrom > &items)
template<class OtherArrayType>
void addArray (const OtherArrayType &arrayToAddFrom)
template<class OtherArrayType>
std::enable_if<!std::is_pointer< OtherArrayType >::value, int >::type addArray (const OtherArrayType &arrayToAddFrom, int startIndex, int numElementsToAdd=-1)
void insert (int indexToInsertAt, ParameterType newElement, int numberOfTimesToInsertIt)
void insertArray (int indexToInsertAt, const ElementType *newElements, int numberOfElements)
void removeElements (int indexToRemoveAt, int numElementsToRemove)
void swap (int index1, int index2)
void move (int currentIndex, int newIndex) noexcept

Private Types

using ParameterType = typename TypeHelpers::ParameterType<ElementType>::type
template<class OtherElementType, class OtherCriticalSection>
using AllowConversion
template<typename T>
using IsTriviallyCopyable = std::is_trivially_copyable<T>
template<typename T>
using TriviallyCopyableVoid = typename std::enable_if<IsTriviallyCopyable<T>::value, void>::type
template<typename T>
using NonTriviallyCopyableVoid = typename std::enable_if<! IsTriviallyCopyable<T>::value, void>::type

Private Member Functions

template<typename T = ElementType>
TriviallyCopyableVoid< T > addArrayInternal (const ElementType *otherElements, int numElements)
template<typename Type, typename T = ElementType>
TriviallyCopyableVoid< T > addArrayInternal (const Type *otherElements, int numElements)
template<typename Type, typename T = ElementType>
NonTriviallyCopyableVoid< T > addArrayInternal (const Type *otherElements, int numElements)
template<typename T = ElementType>
TriviallyCopyableVoid< T > setAllocatedSizeInternal (int numElements)
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > setAllocatedSizeInternal (int numElements)
ElementType * createInsertSpace (int indexToInsertAt, int numElements)
template<typename T = ElementType>
TriviallyCopyableVoid< T > createInsertSpaceInternal (int indexToInsertAt, int numElements)
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > createInsertSpaceInternal (int indexToInsertAt, int numElements)
template<typename T = ElementType>
TriviallyCopyableVoid< T > removeElementsInternal (int indexToRemoveAt, int numElementsToRemove)
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > removeElementsInternal (int indexToRemoveAt, int numElementsToRemove)
template<typename T = ElementType>
TriviallyCopyableVoid< T > moveInternal (int currentIndex, int newIndex) noexcept
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > moveInternal (int currentIndex, int newIndex) noexcept
template<typename... Elements>
void addImpl (Elements &&... toAdd)
template<typename... Elements>
void addAssumingCapacityIsReady (Elements &&... toAdd)
template<typename T = ElementType>
std::enable_if< std::is_move_assignable< T >::value, void >::type moveAssignElement (ElementType *destination, ElementType &&source)
template<typename T = ElementType>
std::enable_if<!std::is_move_assignable< T >::value, void >::type moveAssignElement (ElementType *destination, ElementType &&source)
void checkSourceIsNotAMember (const ElementType &element)

Private Attributes

HeapBlock< ElementType > elements
int numAllocated = 0
int numUsed = 0

Friends

template<class OtherElementType, class OtherCriticalSection>
class ArrayBase

Detailed Description

template<class ElementType, class TypeOfCriticalSectionToUse>
class juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >

A basic object container.

This class isn't really for public use - it's used by the other array classes, but might come in handy for some purposes.

It inherits from a critical section class to allow the arrays to use the "empty base class optimisation" pattern to reduce their footprint.

See also
Array, OwnedArray, ReferenceCountedArray

@tags{Core}

Member Typedef Documentation

◆ AllowConversion

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherElementType, class OtherCriticalSection>
using juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::AllowConversion
private
Initial value:
typename std::enable_if<! std::is_same<std::tuple<ElementType, TypeOfCriticalSectionToUse>,
std::tuple<OtherElementType, OtherCriticalSection>>::value>::type
type
CAdPlugDatabase::CRecord::RecordType type
Definition adplugdb.cpp:93
value
static PuglViewHint int value
Definition pugl.h:1708

◆ IsTriviallyCopyable

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T>
using juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::IsTriviallyCopyable = std::is_trivially_copyable<T>
private

◆ NonTriviallyCopyableVoid

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T>
using juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::NonTriviallyCopyableVoid = typename std::enable_if<! IsTriviallyCopyable<T>::value, void>::type
private

◆ ParameterType

template<class ElementType, class TypeOfCriticalSectionToUse>
using juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::ParameterType = typename TypeHelpers::ParameterType<ElementType>::type
private

◆ TriviallyCopyableVoid

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T>
using juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::TriviallyCopyableVoid = typename std::enable_if<IsTriviallyCopyable<T>::value, void>::type
private

Constructor & Destructor Documentation

◆ ArrayBase() [1/3]

template<class ElementType, class TypeOfCriticalSectionToUse>
juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::ArrayBase ( )
default

◆ ~ArrayBase()

template<class ElementType, class TypeOfCriticalSectionToUse>
juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::~ArrayBase ( )
inline

◆ ArrayBase() [2/3]

template<class ElementType, class TypeOfCriticalSectionToUse>
juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::ArrayBase ( ArrayBase< ElementType, TypeOfCriticalSectionToUse > && other)
inlinenoexcept

◆ ArrayBase() [3/3]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherElementType, class OtherCriticalSection, typename = AllowConversion<OtherElementType, OtherCriticalSection>>
juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::ArrayBase ( ArrayBase< OtherElementType, OtherCriticalSection > && other)
inlinenoexcept

Converting move constructor. Only enabled when the other array has a different type to this one. If you see a compile error here, it's probably because you're attempting a conversion that HeapBlock won't allow.

Member Function Documentation

◆ add() [1/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename... OtherElements>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::add ( const ElementType & firstNewElement,
OtherElements &&... otherElements )
inline

◆ add() [2/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::add ( const ElementType & newElement)
inline

◆ add() [3/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename... OtherElements>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::add ( ElementType && firstNewElement,
OtherElements &&... otherElements )
inline

◆ add() [4/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::add ( ElementType && newElement)
inline

◆ addArray() [1/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherArrayType>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addArray ( const OtherArrayType & arrayToAddFrom)
inline

◆ addArray() [2/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherArrayType>
std::enable_if<!std::is_pointer< OtherArrayType >::value, int >::type juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addArray ( const OtherArrayType & arrayToAddFrom,
int startIndex,
int numElementsToAdd = -1 )
inline

◆ addArray() [3/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename TypeToCreateFrom>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addArray ( const std::initializer_list< TypeToCreateFrom > & items)
inline

◆ addArray() [4/4]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename Type>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addArray ( const Type * elementsToAdd,
int numElementsToAdd )
inline

◆ addArrayInternal() [1/3]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
TriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addArrayInternal ( const ElementType * otherElements,
int numElements )
inlineprivate

◆ addArrayInternal() [2/3]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename Type, typename T = ElementType>
NonTriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addArrayInternal ( const Type * otherElements,
int numElements )
inlineprivate

◆ addArrayInternal() [3/3]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename Type, typename T = ElementType>
TriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addArrayInternal ( const Type * otherElements,
int numElements )
inlineprivate

◆ addAssumingCapacityIsReady()

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename... Elements>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addAssumingCapacityIsReady ( Elements &&... toAdd)
inlineprivate

◆ addImpl()

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename... Elements>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::addImpl ( Elements &&... toAdd)
inlineprivate

◆ begin() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
const ElementType * juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::begin ( ) const
inlinenoexcept

◆ begin() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType * juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::begin ( )
inlinenoexcept

◆ capacity()

template<class ElementType, class TypeOfCriticalSectionToUse>
int juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::capacity ( ) const
inlinenoexcept

◆ checkSourceIsNotAMember()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::checkSourceIsNotAMember ( const ElementType & element)
inlineprivate

◆ clear()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::clear ( )
inline

◆ createInsertSpace()

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType * juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::createInsertSpace ( int indexToInsertAt,
int numElements )
inlineprivate

◆ createInsertSpaceInternal() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::createInsertSpaceInternal ( int indexToInsertAt,
int numElements )
inlineprivate

◆ createInsertSpaceInternal() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
TriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::createInsertSpaceInternal ( int indexToInsertAt,
int numElements )
inlineprivate

◆ data() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
const ElementType * juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::data ( ) const
inlinenoexcept

◆ data() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType * juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::data ( )
inlinenoexcept

◆ end() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
const ElementType * juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::end ( ) const
inlinenoexcept

◆ end() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType * juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::end ( )
inlinenoexcept

◆ ensureAllocatedSize()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::ensureAllocatedSize ( int minNumElements)
inline

◆ getFirst()

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::getFirst ( ) const
inlinenoexcept

◆ getLast()

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::getLast ( ) const
inlinenoexcept

◆ getValueWithDefault()

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::getValueWithDefault ( const int index) const
inlinenoexcept

◆ insert()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::insert ( int indexToInsertAt,
ParameterType newElement,
int numberOfTimesToInsertIt )
inline

◆ insertArray()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::insertArray ( int indexToInsertAt,
const ElementType * newElements,
int numberOfElements )
inline

◆ move()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::move ( int currentIndex,
int newIndex )
inlinenoexcept

◆ moveAssignElement() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
std::enable_if<!std::is_move_assignable< T >::value, void >::type juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::moveAssignElement ( ElementType * destination,
ElementType && source )
inlineprivate

◆ moveAssignElement() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
std::enable_if< std::is_move_assignable< T >::value, void >::type juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::moveAssignElement ( ElementType * destination,
ElementType && source )
inlineprivate

◆ moveInternal() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::moveInternal ( int currentIndex,
int newIndex )
inlineprivatenoexcept

◆ moveInternal() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
TriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::moveInternal ( int currentIndex,
int newIndex )
inlineprivatenoexcept

◆ operator!=()

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherArrayType>
bool juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::operator!= ( const OtherArrayType & other) const
inlinenoexcept

◆ operator=() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
ArrayBase & juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::operator= ( ArrayBase< ElementType, TypeOfCriticalSectionToUse > && other)
inlinenoexcept

◆ operator=() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherElementType, class OtherCriticalSection, typename = AllowConversion<OtherElementType, OtherCriticalSection>>
ArrayBase & juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::operator= ( ArrayBase< OtherElementType, OtherCriticalSection > && other)
inlinenoexcept

Converting move assignment operator. Only enabled when the other array has a different type to this one. If you see a compile error here, it's probably because you're attempting a conversion that HeapBlock won't allow.

◆ operator==()

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherArrayType>
bool juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::operator== ( const OtherArrayType & other) const
inlinenoexcept

◆ operator[]() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
const ElementType & juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::operator[] ( const int index) const
inlinenoexcept

◆ operator[]() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
ElementType & juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::operator[] ( const int index)
inlinenoexcept

◆ removeElements()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::removeElements ( int indexToRemoveAt,
int numElementsToRemove )
inline

◆ removeElementsInternal() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::removeElementsInternal ( int indexToRemoveAt,
int numElementsToRemove )
inlineprivate

◆ removeElementsInternal() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
TriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::removeElementsInternal ( int indexToRemoveAt,
int numElementsToRemove )
inlineprivate

◆ setAllocatedSize()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::setAllocatedSize ( int numElements)
inline

◆ setAllocatedSizeInternal() [1/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
NonTriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::setAllocatedSizeInternal ( int numElements)
inlineprivate

◆ setAllocatedSizeInternal() [2/2]

template<class ElementType, class TypeOfCriticalSectionToUse>
template<typename T = ElementType>
TriviallyCopyableVoid< T > juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::setAllocatedSizeInternal ( int numElements)
inlineprivate

◆ shrinkToNoMoreThan()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::shrinkToNoMoreThan ( int maxNumElements)
inline

◆ size()

template<class ElementType, class TypeOfCriticalSectionToUse>
int juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::size ( ) const
inlinenoexcept

◆ swap()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::swap ( int index1,
int index2 )
inline

◆ swapWith()

template<class ElementType, class TypeOfCriticalSectionToUse>
void juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::swapWith ( ArrayBase< ElementType, TypeOfCriticalSectionToUse > & other)
inlinenoexcept

◆ ArrayBase

template<class ElementType, class TypeOfCriticalSectionToUse>
template<class OtherElementType, class OtherCriticalSection>
friend class ArrayBase
friend

Member Data Documentation

◆ elements

template<class ElementType, class TypeOfCriticalSectionToUse>
HeapBlock<ElementType> juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::elements
private

◆ numAllocated

template<class ElementType, class TypeOfCriticalSectionToUse>
int juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::numAllocated = 0
private

◆ numUsed

template<class ElementType, class TypeOfCriticalSectionToUse>
int juce::ArrayBase< ElementType, TypeOfCriticalSectionToUse >::numUsed = 0
private
The documentation for this class was generated from the following file:
Generated on for LMMS by doxygen 1.16.1