JPL Spatial
Sound spatialization and propagation library
Loading...
Searching...
No Matches
Public Types | Public Member Functions | List of all members
JPL::StaticArray< T, Capacity > Class Template Reference

#include <JPLSpatial/Containers/StaticArray.h>

Public Types

using element_type = T
 
using value_type = std::remove_cvref_t<T>
 
using size_type = std::size_t
 
using difference_type = ptrdiff_t
 
using pointer = T*
 
using const_pointer = const T*
 
using reference = T&
 
using const_reference = 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

constexpr StaticArray () noexcept=default
 
constexpr StaticArray (const StaticArray &) noexcept=default
 
constexpr StaticArray (StaticArray &&) noexcept=default
 
constexpr StaticArray & operator= (const StaticArray &) noexcept=default
 
constexpr StaticArray & operator= (StaticArray &&) noexcept=default
 
constexpr ~StaticArray () noexcept=default
 
constexpr JPL_INLINE StaticArray (std::size_t size) noexcept
 
constexpr JPL_INLINE StaticArray (std::size_t size, T defaultValue) noexcept
 
constexpr JPL_INLINE size_type size () const
 
constexpr JPL_INLINE size_type size_bytes () const
 
constexpr JPL_INLINE bool empty () const
 
constexpr JPL_INLINE iterator begin () noexcept
 
constexpr JPL_INLINE iterator end () noexcept
 
constexpr JPL_INLINE const_iterator begin () const noexcept
 
constexpr JPL_INLINE const_iterator end () const noexcept
 
constexpr JPL_INLINE const_iterator cbegin () const noexcept
 
constexpr JPL_INLINE const_iterator cend () const noexcept
 
constexpr JPL_INLINE reverse_iterator rbegin () const noexcept
 
constexpr JPL_INLINE reverse_iterator rend () const noexcept
 
constexpr JPL_INLINE reference front () noexcept
 
constexpr JPL_INLINE reference back () noexcept
 
constexpr JPL_INLINE const_reference front () const noexcept
 
constexpr JPL_INLINE const_reference back () const noexcept
 
constexpr JPL_INLINE pointer data () noexcept
 
constexpr JPL_INLINE const_pointer data () const noexcept
 
constexpr JPL_INLINE reference operator[] (const size_type offset) noexcept
 
constexpr JPL_INLINE const_reference operator[] (const size_type offset) const noexcept
 
constexpr JPL_INLINE void resize (std::size_t newSize) noexcept
 
constexpr JPL_INLINE void resize (std::size_t newSize, const T &valueToInsert) noexcept
 
constexpr JPL_INLINE void assign (std::size_t count, const T &value) noexcept
 
constexpr JPL_INLINE void clear () noexcept
 
constexpr JPL_INLINE void push_back (const T &value)
 
template<class... Args>
constexpr JPL_INLINE reference emplace_back (Args &&... args)
 
constexpr JPL_INLINE bool pop_back (T &outValue) noexcept
 
constexpr JPL_INLINE bool pop_back () noexcept
 

Member Typedef Documentation

◆ const_iterator

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::const_iterator = const_pointer

◆ const_pointer

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::const_pointer = const T*

◆ const_reference

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::const_reference = const T&

◆ const_reverse_iterator

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::const_reverse_iterator = std::reverse_iterator<const_iterator>

◆ difference_type

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::difference_type = ptrdiff_t

◆ element_type

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::element_type = T

◆ iterator

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::iterator = pointer

◆ pointer

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::pointer = T*

◆ reference

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::reference = T&

◆ reverse_iterator

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::reverse_iterator = std::reverse_iterator<iterator>

◆ size_type

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::size_type = std::size_t

◆ value_type

template<class T , std::size_t Capacity>
using JPL::StaticArray< T, Capacity >::value_type = std::remove_cvref_t<T>

Constructor & Destructor Documentation

◆ StaticArray() [1/5]

template<class T , std::size_t Capacity>
JPL::StaticArray< T, Capacity >::StaticArray ( )
constexprdefaultnoexcept

◆ StaticArray() [2/5]

template<class T , std::size_t Capacity>
JPL::StaticArray< T, Capacity >::StaticArray ( const StaticArray< T, Capacity > & )
constexprdefaultnoexcept

◆ StaticArray() [3/5]

template<class T , std::size_t Capacity>
JPL::StaticArray< T, Capacity >::StaticArray ( StaticArray< T, Capacity > && )
constexprdefaultnoexcept

◆ ~StaticArray()

template<class T , std::size_t Capacity>
JPL::StaticArray< T, Capacity >::~StaticArray ( )
constexprdefaultnoexcept

◆ StaticArray() [4/5]

template<class T , std::size_t Capacity>
JPL_INLINE JPL::StaticArray< T, Capacity >::StaticArray ( std::size_t size)
inlineexplicitconstexprnoexcept

◆ StaticArray() [5/5]

template<class T , std::size_t Capacity>
JPL_INLINE JPL::StaticArray< T, Capacity >::StaticArray ( std::size_t size,
T defaultValue )
inlineexplicitconstexprnoexcept

Member Function Documentation

◆ assign()

template<class T , std::size_t Capacity>
JPL_INLINE void JPL::StaticArray< T, Capacity >::assign ( std::size_t count,
const T & value )
inlineconstexprnoexcept

◆ back() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE const_reference JPL::StaticArray< T, Capacity >::back ( ) const
inlinenodiscardconstexprnoexcept

◆ back() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE reference JPL::StaticArray< T, Capacity >::back ( )
inlinenodiscardconstexprnoexcept

◆ begin() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE const_iterator JPL::StaticArray< T, Capacity >::begin ( ) const
inlinenodiscardconstexprnoexcept

◆ begin() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE iterator JPL::StaticArray< T, Capacity >::begin ( )
inlinenodiscardconstexprnoexcept

◆ cbegin()

template<class T , std::size_t Capacity>
JPL_INLINE const_iterator JPL::StaticArray< T, Capacity >::cbegin ( ) const
inlinenodiscardconstexprnoexcept

◆ cend()

template<class T , std::size_t Capacity>
JPL_INLINE const_iterator JPL::StaticArray< T, Capacity >::cend ( ) const
inlinenodiscardconstexprnoexcept

◆ clear()

template<class T , std::size_t Capacity>
JPL_INLINE void JPL::StaticArray< T, Capacity >::clear ( )
inlineconstexprnoexcept

◆ data() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE const_pointer JPL::StaticArray< T, Capacity >::data ( ) const
inlinenodiscardconstexprnoexcept

◆ data() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE pointer JPL::StaticArray< T, Capacity >::data ( )
inlinenodiscardconstexprnoexcept

◆ emplace_back()

template<class T , std::size_t Capacity>
template<class... Args>
JPL_INLINE reference JPL::StaticArray< T, Capacity >::emplace_back ( Args &&... args)
inlineconstexpr

◆ empty()

template<class T , std::size_t Capacity>
JPL_INLINE bool JPL::StaticArray< T, Capacity >::empty ( ) const
inlinenodiscardconstexpr

◆ end() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE const_iterator JPL::StaticArray< T, Capacity >::end ( ) const
inlinenodiscardconstexprnoexcept

◆ end() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE iterator JPL::StaticArray< T, Capacity >::end ( )
inlinenodiscardconstexprnoexcept

◆ front() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE const_reference JPL::StaticArray< T, Capacity >::front ( ) const
inlinenodiscardconstexprnoexcept

◆ front() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE reference JPL::StaticArray< T, Capacity >::front ( )
inlinenodiscardconstexprnoexcept

◆ operator=() [1/2]

template<class T , std::size_t Capacity>
StaticArray & JPL::StaticArray< T, Capacity >::operator= ( const StaticArray< T, Capacity > & )
constexprdefaultnoexcept

◆ operator=() [2/2]

template<class T , std::size_t Capacity>
StaticArray & JPL::StaticArray< T, Capacity >::operator= ( StaticArray< T, Capacity > && )
constexprdefaultnoexcept

◆ operator[]() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE const_reference JPL::StaticArray< T, Capacity >::operator[] ( const size_type offset) const
inlinenodiscardconstexprnoexcept

◆ operator[]() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE reference JPL::StaticArray< T, Capacity >::operator[] ( const size_type offset)
inlinenodiscardconstexprnoexcept

◆ pop_back() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE bool JPL::StaticArray< T, Capacity >::pop_back ( )
inlineconstexprnoexcept

◆ pop_back() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE bool JPL::StaticArray< T, Capacity >::pop_back ( T & outValue)
inlineconstexprnoexcept

◆ push_back()

template<class T , std::size_t Capacity>
JPL_INLINE void JPL::StaticArray< T, Capacity >::push_back ( const T & value)
inlineconstexpr

◆ rbegin()

template<class T , std::size_t Capacity>
JPL_INLINE reverse_iterator JPL::StaticArray< T, Capacity >::rbegin ( ) const
inlinenodiscardconstexprnoexcept

◆ rend()

template<class T , std::size_t Capacity>
JPL_INLINE reverse_iterator JPL::StaticArray< T, Capacity >::rend ( ) const
inlinenodiscardconstexprnoexcept

◆ resize() [1/2]

template<class T , std::size_t Capacity>
JPL_INLINE void JPL::StaticArray< T, Capacity >::resize ( std::size_t newSize)
inlineconstexprnoexcept

◆ resize() [2/2]

template<class T , std::size_t Capacity>
JPL_INLINE void JPL::StaticArray< T, Capacity >::resize ( std::size_t newSize,
const T & valueToInsert )
inlineconstexprnoexcept

◆ size()

template<class T , std::size_t Capacity>
JPL_INLINE size_type JPL::StaticArray< T, Capacity >::size ( ) const
inlinenodiscardconstexpr

◆ size_bytes()

template<class T , std::size_t Capacity>
JPL_INLINE size_type JPL::StaticArray< T, Capacity >::size_bytes ( ) const
inlinenodiscardconstexpr
The documentation for this class was generated from the following file: