mnx::ContentArray Class Reference

Class for content arrays. More...

#include <BaseTypes.h>

Inheritance diagram for mnx::ContentArray:

Public Types
using	BaseArray = Array< ContentObject >
	The base array type.
Public Types inherited from mnx::Array< ContentObject >
using	value_type = ContentObject
	The type for elements in this Array.
using	iterator = iter< Array >
	non-const iterator type
using	const_iterator = iter< const Array >
	const iterator type

Public Member Functions
template<typename T , std::enable_if_t< std::is_base_of_v< ContentObject, T >, int > = 0>
T	get (size_t index) const
	Retrieve an element from the array as a specific type.
template<typename T , typename... Args, std::enable_if_t< std::is_base_of_v< ContentObject, T >, int > = 0>
T	append (Args &&... args)
	Append an element of the specified type.
Public Member Functions inherited from mnx::Array< ContentObject >
	Array (const std::shared_ptr< json > &root, json_pointer pointer)
	Wraps an Array class around an existing JSON array node.
	Array (Base &parent, const std::string_view &key)
	Creates a new Array class as a child of a JSON node.
size_t	size () const
	Get the size of the array.
bool	empty () const
	Check if the array is empty.
void	clear ()
	Clear all elements.
auto	operator[] (size_t index) const
	const operator[]
auto	operator[] (size_t index)
	non-const operator[]
std::enable_if_t<!std::is_base_of_v< Base, U >, void >	push_back (const U &value)
	Append a new value to the array. (Available only for primitive types)
U	append (Args &&... args)
	Create a new element at the end of the array. (Available only for Base types)
void	erase (size_t index)
	Remove an element at a given index.
auto	begin ()
	Returns an iterator to the beginning of the array.
auto	begin () const
	Returns a const iterator to the beginning of the array.
auto	end ()
	Returns an iterator to the end of the array.
auto	end () const
	Returns a const iterator to the end of the array.
Public Member Functions inherited from mnx::Base
	Base (const Base &src)
	Copy constructor.
	Base (Base &&src) noexcept
	Move constructor.
Base &	operator= (const Base &src)
	Copy assignment operator.
Base &	operator= (Base &&src)
	Move assignment operator.
std::string	dump (int indents=-1)
	Dumps the branch to a string. Useful in debugging.
template<typename T >
T	parent () const
	Returns the parent object for this node.
template<typename T >
std::optional< T >	getEnclosingElement () const
	Returns the enclosing array element for this instance.
json_pointer	pointer () const
	Returns the json_pointer for this node.

Additional Inherited Members
Protected Member Functions inherited from mnx::Array< ContentObject >
void	checkIndex (size_t index) const
	validates that an index is not out of range
Protected Member Functions inherited from mnx::Base
json &	ref () const
	Convert this node for retrieval.
json &	ref ()
	Access the JSON node for modification.
const std::shared_ptr< json > &	root () const
	Returns the root.
	Base (const std::shared_ptr< json > &root, json_pointer pointer)
	Wrap a Base instance around a specific JSON reference using a json_pointer.
	Base (json &&jsonRef, Base &parent, const std::string_view &key)
	Construct a Base reference as a child inside a parent node.
template<typename T >
T	getChild (const std::string_view &key) const
	Retrieves and validates a required child node.
template<typename T >
T	setChild (const std::string_view &key, const T &value)
	Sets a child node.
template<typename T >
std::optional< T >	getOptionalChild (const std::string_view &key) const
	Retrieves an optional child node.

Detailed Description

Class for content arrays.

Allows arrays of any type that derives from ContentObject. An exampled of how to get type instances is:

auto next = content[index]; // gets the base ContentObject instance.
if (next.type() == layout::Group::ContentTypeValue) {
    auto group = next.get<layout::Group>(); // gets the instance typed as a layout::Group.
    // process group
} else if (next.type() == layout::Staff::ContentTypeValue) {
    auto staff = next.get<layout::Staff>(); // gets the instance typed as a layout::Staff.
    // process staff
}

To add instances to the array, use the template paramter to specify the type to add.

auto newElement = content.append<layout::Staff>();

The append method automatically gives the instance the correct type value.