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>
constexpr JPL::StaticArray< T, Capacity >::StaticArray ( )
constexprdefaultnoexcept

◆ StaticArray() [2/5]

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

◆ StaticArray() [3/5]

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

◆ ~StaticArray()

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

◆ StaticArray() [4/5]

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

◆ StaticArray() [5/5]

template<class T , std::size_t Capacity>
constexpr 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>
constexpr 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>
constexpr JPL_INLINE const_reference JPL::StaticArray< T, Capacity >::back ( ) const
inlineconstexprnoexcept

◆ back() [2/2]

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

◆ begin() [1/2]

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

◆ begin() [2/2]

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

◆ cbegin()

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

◆ cend()

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

◆ clear()

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

◆ data() [1/2]

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

◆ data() [2/2]

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

◆ emplace_back()

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

◆ empty()

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

◆ end() [1/2]

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

◆ end() [2/2]

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

◆ front() [1/2]

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

◆ front() [2/2]

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

◆ operator=() [1/2]

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

◆ operator=() [2/2]

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

◆ operator[]() [1/2]

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

◆ operator[]() [2/2]

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

◆ pop_back() [1/2]

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

◆ pop_back() [2/2]

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

◆ push_back()

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

◆ rbegin()

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

◆ rend()

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

◆ resize() [1/2]

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

◆ resize() [2/2]

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

◆ size()

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

◆ size_bytes()

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