#include <ArrayVector.h>

Public Types
using	size_type = std::size_t
using	difference_type = std::ptrdiff_t
using	value_type = T
using	reference = T&
using	const_reference = const T&
using	pointer = T*
using	const_pointer = const T*
using	iterator = pointer
using	const_iterator = const_pointer
using	reverse_iterator = std::reverse_iterator<iterator>
using	const_reverse_iterator = std::reverse_iterator<const_iterator>

Public Member Functions
	ArrayVector ()=default
	ArrayVector (const ArrayVector &other) noexcept(std::is_nothrow_copy_constructible_v< T >)
	ArrayVector (ArrayVector &&other) noexcept(std::is_nothrow_move_constructible_v< T >)
	ArrayVector (size_type count, const T &value) noexcept(std::is_nothrow_copy_constructible_v< T >)
	ArrayVector (size_type count) noexcept(std::is_nothrow_default_constructible_v< T >)
template<std::input_iterator It>
	ArrayVector (It first, It last)
	ArrayVector (std::initializer_list< T > il) noexcept(std::is_nothrow_copy_constructible_v< T >)
	~ArrayVector ()
ArrayVector &	operator= (const ArrayVector &other) noexcept(std::is_nothrow_copy_assignable_v< T > &&std::is_nothrow_copy_constructible_v< T >)
ArrayVector &	operator= (ArrayVector &&other) noexcept(std::is_nothrow_move_assignable_v< T > &&std::is_nothrow_move_constructible_v< T >)
ArrayVector &	operator= (std::initializer_list< T > il) noexcept(std::is_nothrow_copy_assignable_v< T > &&std::is_nothrow_copy_constructible_v< T >)
void	assign (size_type count, const T &value) noexcept(std::is_nothrow_copy_assignable_v< T > &&std::is_nothrow_copy_constructible_v< T >)
template<std::input_iterator It>
void	assign (It first, It last)
reference	at (size_type index)
const_reference	at (size_type index) const
reference	operator[] (size_type index) noexcept
const_reference	operator[] (size_type index) const noexcept
reference	front () noexcept
const_reference	front () const noexcept
reference	back () noexcept
const_reference	back () const noexcept
pointer	data () noexcept
const_pointer	data () const noexcept
iterator	begin () noexcept
const_iterator	begin () const noexcept
const_iterator	cbegin () const noexcept
iterator	end () noexcept
const_iterator	end () const noexcept
const_iterator	cend () const noexcept
reverse_iterator	rbegin () noexcept
const_reverse_iterator	rbegin () const noexcept
const_reverse_iterator	crbegin () const noexcept
reverse_iterator	rend () noexcept
const_reverse_iterator	rend () const noexcept
const_reverse_iterator	crend () const noexcept
bool	empty () const noexcept
bool	full () const noexcept
size_type	size () const noexcept
size_type	max_size () const noexcept
size_type	capacity () const noexcept
void	clear () noexcept
iterator	insert (const_iterator pos, const T &value)
iterator	insert (const_iterator pos, T &&value)
iterator	insert (const_iterator pos, size_type count, const T &value)
template<std::input_iterator It>
iterator	insert (const_iterator pos, It first, It last)
iterator	insert (const_iterator pos, std::initializer_list< T > il)
template<typename... Args>
iterator	emplace (const_iterator pos, Args &&... args)
iterator	erase (const_iterator pos)
iterator	erase (const_iterator first, const_iterator last)
void	push_back (const T &value)
void	push_back (T &&value)
template<typename... Args>
reference	emplace_back (Args &&... args)
void	pop_back ()
void	resize (size_type size)
void	resize (size_type size, const value_type &value)
void	swap (ArrayVector &other) noexcept(std::is_nothrow_swappable_v< T > &&std::is_nothrow_move_constructible_v< T >)

Private Attributes
std::byte	m_data [std::max(N *sizeof(T), std::size_t{1})]
size_type	m_size = 0

Friends
void	swap (ArrayVector &a, ArrayVector &b) noexcept(std::is_nothrow_swappable_v< T > &&std::is_nothrow_move_constructible_v< T >)
constexpr auto	operator<=> (const ArrayVector &l, const ArrayVector &r)
bool	operator== (const ArrayVector &l, const ArrayVector &r)

Detailed Description

template<typename T, std::size_t N>
class lmms::ArrayVector< T, N >

A container that stores up to a maximum of N elements of type T directly within itself, rather than separately on the heap. Useful when a dynamically resizeable container is needed for use in real-time code. Can be thought of as a hybrid between std::array and std::vector. The interface follows that of std::vector - see standard C++ documentation.

TODO C++26: Replace uses of this class with std::inplace_vector