containers

Detailed Description

Classes
class	AbstractFifo
	Encapsulates the logic required to implement a lock-free FIFO. More...
class	AbstractFifo::ScopedReadWrite< mode >
	Class for a scoped reader/writer. More...
class	Array< ElementType, TypeOfCriticalSectionToUse, minimumAllocatedSize >
	Holds a resizable array of primitive or copy-by-value objects. More...
class	ArrayAllocationBase< ElementType, TypeOfCriticalSectionToUse >
	Implements some basic array storage allocation functions. More...
class	ArrayBase< ElementType, TypeOfCriticalSectionToUse >
	A basic object container. More...
class	DynamicObject
	Represents a dynamically implemented object. More...
class	DefaultElementComparator< ElementType >
	A simple ElementComparator class that can be used to sort an array of objects that support the '<' operator. More...
struct	DefaultHashFunctions
	A simple class to generate hash functions for some primitive types, intended for use with the HashMap class. More...
class	HashMap< KeyType, ValueType, HashFunctionType, TypeOfCriticalSectionToUse >
	Holds a set of mappings between some key/value pairs. More...
struct	HashMap< KeyType, ValueType, HashFunctionType, TypeOfCriticalSectionToUse >::Iterator
	Iterates over the items in a HashMap. More...
class	LinkedListPointer< ObjectType >
	Helps to manipulate singly-linked lists of objects. More...
class	LinkedListPointer< ObjectType >::Appender
	Allows efficient repeated insertions into a list. More...
class	ListenerList< ListenerClass, ArrayType >
	Holds a set of objects and can invoke a member function callback on each object in the set with a single call. More...
struct	ListenerList< ListenerClass, ArrayType >::DummyBailOutChecker
	A dummy bail-out checker that always returns false. More...
struct	ListenerList< ListenerClass, ArrayType >::Iterator
	Iterates the listeners in a ListenerList. More...
class	NamedValueSet
	Holds a set of named var objects. More...
struct	NamedValueSet::NamedValue
	Structure for a named var object. More...
class	Optional< Value >
	A simple optional type. More...
class	OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >
	An array designed for holding objects. More...
class	PropertySet
	A set of named property values, which can be strings, integers, floating point, etc. More...
class	ReferenceCountedArray< ObjectClass, TypeOfCriticalSectionToUse >
	Holds a list of objects derived from ReferenceCountedObject, or which implement basic reference-count handling methods. More...
class	ScopedValueSetter< ValueType >
	Helper class providing an RAII-based mechanism for temporarily setting and then re-setting a value. More...
class	SingleThreadedAbstractFifo
	Encapsulates the logic for a single-threaded FIFO. More...
class	SortedSet< ElementType, TypeOfCriticalSectionToUse >
	Holds a set of unique primitive objects, such as ints or doubles. More...
class	SparseSet< Type >
	Holds a set of primitive values, storing them as a set of ranges. More...
class	var
	A variant class, that can be used to hold a range of primitive values. More...
struct	var::NativeFunctionArgs
	This structure is passed to a NativeFunction callback, and contains invocation details about the function's arguments and context. More...
struct	VariantConverter< Type >
	This template-overloaded class can be used to convert between var and custom types. More...

Macros
#define	JUCE_OPTIONAL_OPERATORS   X(==) X(!=) X(<) X(<=) X(>) X(>=)
#define	X(op)
#define	X(op)

Typedefs
using	Nullopt = std::nullopt_t

Functions
template<typename Value >
JUCE_END_IGNORE_WARNINGS_MSVC Optional< std::decay_t< Value > >	makeOptional (Value &&v)
JUCE_API bool	operator== (const var &, const var &)
	Compares the values of two var objects, using the var::equals() comparison.
JUCE_API bool	operator!= (const var &, const var &)
	Compares the values of two var objects, using the var::equals() comparison.
JUCE_API bool	operator< (const var &, const var &)
	Compares the values of two var objects, using the var::equals() comparison.
JUCE_API bool	operator<= (const var &, const var &)
	Compares the values of two var objects, using the var::equals() comparison.
JUCE_API bool	operator> (const var &, const var &)
	Compares the values of two var objects, using the var::equals() comparison.
JUCE_API bool	operator>= (const var &, const var &)
	Compares the values of two var objects, using the var::equals() comparison.
JUCE_API bool	operator== (const var &, const String &)
JUCE_API bool	operator!= (const var &, const String &)
JUCE_API bool	operator== (const var &, const char *)
JUCE_API bool	operator!= (const var &, const char *)
template<typename ElementComparator , typename TargetValueType >
int	Array< ElementType, TypeOfCriticalSectionToUse, minimumAllocatedSize >::indexOfSorted (ElementComparator &comparator, TargetValueType elementToLookFor) const
	Finds the index of an element in the array, assuming that the array is sorted.
template<class ElementComparator >
void	Array< ElementType, TypeOfCriticalSectionToUse, minimumAllocatedSize >::sort (ElementComparator &comparator, bool retainOrderOfEquivalentItems=false)
	Sorts the elements in the array.
template<class ElementComparator >
int	OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::addSorted (ElementComparator &comparator, ObjectClass *newObject) noexcept
	Inserts a new object into the array assuming that the array is sorted.
template<typename ElementComparator >
int	OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::indexOfSorted (ElementComparator &comparator, const ObjectClass *objectToLookFor) const noexcept
	Finds the index of an object in the array, assuming that the array is sorted.
template<class ElementComparator >
void	OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::sort (ElementComparator &comparator, bool retainOrderOfEquivalentItems=false) noexcept
	Sorts the elements in the array.
template<class ElementComparator >
int	ReferenceCountedArray< ObjectClass, TypeOfCriticalSectionToUse >::indexOfSorted (ElementComparator &comparator, const ObjectClass *objectToLookFor) const noexcept
	Finds the index of an object in the array, assuming that the array is sorted.
template<class ElementComparator >
void	ReferenceCountedArray< ObjectClass, TypeOfCriticalSectionToUse >::sort (ElementComparator &comparator, bool retainOrderOfEquivalentItems=false) noexcept
	Sorts the elements in the array.

Variables
constexpr auto	nullopt = std::nullopt

Macro Definition Documentation

JUCE_OPTIONAL_OPERATORS

#define JUCE_OPTIONAL_OPERATORS   X(==) X(!=) X(<) X(<=) X(>) X(>=)

X [1/2]

#define X

(

op

)

Value:

        template <typename T, typename U> friend bool operator op (const Optional<T>&, const Optional<U>&); \
        template <typename T> friend bool operator op (const Optional<T>&, Nullopt); \
        template <typename T> friend bool operator op (Nullopt, const Optional<T>&); \
        template <typename T, typename U> friend bool operator op (const Optional<T>&, const U&); \
        template <typename T, typename U> friend bool operator op (const T&, const Optional<U>&);

X [2/2]

#define X

(

op

)

Value:

    template <typename T, typename U> bool operator op (const Optional<T>& lhs, const Optional<U>& rhs) { return lhs.opt op rhs.opt; } \
    template <typename T> bool operator op (const Optional<T>& lhs, Nullopt rhs) { return lhs.opt op rhs; } \
    template <typename T> bool operator op (Nullopt lhs, const Optional<T>& rhs) { return lhs op rhs.opt; } \
    template <typename T, typename U> bool operator op (const Optional<T>& lhs, const U& rhs) { return lhs.opt op rhs; } \
    template <typename T, typename U> bool operator op (const T& lhs, const Optional<U>& rhs) { return lhs op rhs.opt; }

Typedef Documentation

Nullopt

using Nullopt = std::nullopt_t

Function Documentation

makeOptional()

template<typename Value >

JUCE_END_IGNORE_WARNINGS_MSVC Optional< std::decay_t< Value > > makeOptional

(

Value &&

v

)

operator==() [1/3]

JUCE_API bool operator==	(	const var &	,
		const var &
	)

Compares the values of two var objects, using the var::equals() comparison.

Referenced by ColourGradient::operator!=(), AudioPlayHead::CurrentPositionInfo::operator!=(), AudioPlayHead::LoopPoints::operator!=(), MidiBufferIterator::operator!=(), MPEZoneLayout::operator!=(), AudioPlayHead::PositionInfo::operator!=(), SortedSet< ElementType, TypeOfCriticalSectionToUse >::operator!=(), AudioPlayHead::TimeSignature::operator!=(), and LookAndFeel::playAlertSound().

operator!=() [1/3]

JUCE_API bool operator!=	(	const var &	,
		const var &
	)

Compares the values of two var objects, using the var::equals() comparison.

Referenced by ColourGradient::operator!=().

operator<()

JUCE_API bool operator<	(	const var &	,
		const var &
	)

Compares the values of two var objects, using the var::equals() comparison.

Referenced by LookAndFeel::playAlertSound().

operator<=()

JUCE_API bool operator<=	(	const var &	,
		const var &
	)

Compares the values of two var objects, using the var::equals() comparison.

operator>()

JUCE_API bool operator>	(	const var &	,
		const var &
	)

Compares the values of two var objects, using the var::equals() comparison.

operator>=()

JUCE_API bool operator>=	(	const var &	,
		const var &
	)

Compares the values of two var objects, using the var::equals() comparison.

operator==() [2/3]

JUCE_API bool operator==	(	const var &	,
		const String &
	)

operator!=() [2/3]

JUCE_API bool operator!=	(	const var &	,
		const String &
	)

operator==() [3/3]

JUCE_API bool operator==	(	const var &	,
		const char *
	)

operator!=() [3/3]

JUCE_API bool operator!=	(	const var &	,
		const char *
	)

indexOfSorted() [1/3]

template<typename ElementType , typename TypeOfCriticalSectionToUse , int minimumAllocatedSize>

template<typename ElementComparator , typename TargetValueType >

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

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

sort() [1/3]

template<typename ElementType , typename TypeOfCriticalSectionToUse , int minimumAllocatedSize>

template<class ElementComparator >

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

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

addSorted()

template<class ObjectClass , class TypeOfCriticalSectionToUse >

template<class ElementComparator >

int OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::addSorted ( ElementComparator &  comparator, ObjectClass *  newObject  )

noexcept

Inserts a new object into the array assuming that the array is sorted.

This will use a comparator to find the position at which the new object 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 this object's structure
newObject	the new object to insert to the array

Returns

the index at which the new object was added

See also

add, sort, indexOfSorted

References OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::getLock(), and OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::insert().

indexOfSorted() [2/3]

template<class ObjectClass , class TypeOfCriticalSectionToUse >

template<typename ElementComparator >

int OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::indexOfSorted ( ElementComparator &  comparator, const ObjectClass *  objectToLookFor  ) const

noexcept

Finds the index of an object 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
objectToLookFor	the object to search for

Returns

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

See also

addSorted, sort

References OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::getLock().

sort() [2/3]

template<class ObjectClass , class TypeOfCriticalSectionToUse >

template<typename ElementComparator >

void OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::sort ( ElementComparator &  comparator, bool  retainOrderOfEquivalentItems = false  )

noexcept

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

sortArray, indexOfSorted

References OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::getLock(), and OwnedArray< ObjectClass, TypeOfCriticalSectionToUse >::size().

Referenced by ValueTree::sort().

indexOfSorted() [3/3]

template<class ObjectClass , class TypeOfCriticalSectionToUse >

template<class ElementComparator >

int ReferenceCountedArray< ObjectClass, TypeOfCriticalSectionToUse >::indexOfSorted ( ElementComparator &  comparator, const ObjectClass *  objectToLookFor  ) const

noexcept

Finds the index of an object 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
objectToLookFor	the object to search for

Returns

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

See also

addSorted, sort

sort() [3/3]

template<class ObjectClass , class TypeOfCriticalSectionToUse >

template<class ElementComparator >

void ReferenceCountedArray< ObjectClass, TypeOfCriticalSectionToUse >::sort ( ElementComparator &  comparator, bool  retainOrderOfEquivalentItems = false  )

noexcept

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

sortArray

Variable Documentation

nullopt

constexpr auto nullopt = std::nullopt

constexpr