Public Types | Public Member Functions | Private Attributes | List of all members
mn::container::basic_fixed_array< T, N > Class Template Reference

A standard container for storing a fixed size sequence of elements. More...

#include <mn_fixed_array.hpp>

Public Types

using self_type = basic_fixed_array< T, N >
 
using value_type = T
 
using pointer = T *
 
using const_pointer = const T *
 
using reference = T &
 
using const_reference = const T &
 
using iterator = T *
 
using const_iterator = const T *
 
using size_type = mn::size_t
 
using difference_type = mn::ptrdiff_t
 

Public Member Functions

 basic_fixed_array ()
 
 basic_fixed_array (const value_type &val)
 
 basic_fixed_array (const self_type &other)
 
iterator begin () noexcept
 
constexpr const_iterator begin () const noexcept
 
iterator end () noexcept
 
constexpr const_iterator end () const noexcept
 
reference front () noexcept
 
const_reference front () const noexcept
 
reference back () noexcept
 
const_reference back () const noexcept
 
size_type size () const noexcept
 
reference at (size_type pos)
 
const_reference at (size_type pos) const
 
void fill (const value_type &val)
 
void swap (self_type &other) noexcept
 
reference operator[] (size_type pos) noexcept
 
constexpr const_reference operator[] (size_type pos) const noexcept
 
bool is_equele (const self_type &other)
 

Private Attributes

value_type m_nData [N]
 

Detailed Description

template<typename T, size_t N>
class mn::container::basic_fixed_array< T, N >

A standard container for storing a fixed size sequence of elements.

Note
Sets support random access iterators.
Template Parameters
TType of element.
NNumber of elements.

Member Typedef Documentation

◆ const_iterator

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::const_iterator = const T*

◆ const_pointer

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::const_pointer = const T*

◆ const_reference

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::const_reference = const T&

◆ difference_type

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::difference_type = mn::ptrdiff_t

◆ iterator

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::iterator = T*

◆ pointer

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::pointer = T*

◆ reference

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::reference = T&

◆ self_type

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::self_type = basic_fixed_array<T, N>

◆ size_type

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::size_type = mn::size_t

◆ value_type

template<typename T , size_t N>
using mn::container::basic_fixed_array< T, N >::value_type = T

Constructor & Destructor Documentation

◆ basic_fixed_array() [1/3]

template<typename T , size_t N>
mn::container::basic_fixed_array< T, N >::basic_fixed_array ( )
inline

◆ basic_fixed_array() [2/3]

template<typename T , size_t N>
mn::container::basic_fixed_array< T, N >::basic_fixed_array ( const value_type &  val)
inline

◆ basic_fixed_array() [3/3]

template<typename T , size_t N>
mn::container::basic_fixed_array< T, N >::basic_fixed_array ( const self_type &  other)
inline

Member Function Documentation

◆ at() [1/2]

template<typename T , size_t N>
reference mn::container::basic_fixed_array< T, N >::at ( size_type  pos)
inline

◆ at() [2/2]

template<typename T , size_t N>
const_reference mn::container::basic_fixed_array< T, N >::at ( size_type  pos) const
inline

◆ back() [1/2]

template<typename T , size_t N>
const_reference mn::container::basic_fixed_array< T, N >::back ( ) const
inlinenoexcept

◆ back() [2/2]

template<typename T , size_t N>
reference mn::container::basic_fixed_array< T, N >::back ( )
inlinenoexcept

◆ begin() [1/2]

template<typename T , size_t N>
constexpr const_iterator mn::container::basic_fixed_array< T, N >::begin ( ) const
inlineconstexprnoexcept

◆ begin() [2/2]

template<typename T , size_t N>
iterator mn::container::basic_fixed_array< T, N >::begin ( )
inlinenoexcept

◆ end() [1/2]

template<typename T , size_t N>
constexpr const_iterator mn::container::basic_fixed_array< T, N >::end ( ) const
inlineconstexprnoexcept

◆ end() [2/2]

template<typename T , size_t N>
iterator mn::container::basic_fixed_array< T, N >::end ( )
inlinenoexcept

◆ fill()

template<typename T , size_t N>
void mn::container::basic_fixed_array< T, N >::fill ( const value_type &  val)
inline

◆ front() [1/2]

template<typename T , size_t N>
const_reference mn::container::basic_fixed_array< T, N >::front ( ) const
inlinenoexcept

◆ front() [2/2]

template<typename T , size_t N>
reference mn::container::basic_fixed_array< T, N >::front ( )
inlinenoexcept

◆ is_equele()

template<typename T , size_t N>
bool mn::container::basic_fixed_array< T, N >::is_equele ( const self_type &  other)
inline

◆ operator[]() [1/2]

template<typename T , size_t N>
constexpr const_reference mn::container::basic_fixed_array< T, N >::operator[] ( size_type  pos) const
inlineconstexprnoexcept

◆ operator[]() [2/2]

template<typename T , size_t N>
reference mn::container::basic_fixed_array< T, N >::operator[] ( size_type  pos)
inlinenoexcept

◆ size()

template<typename T , size_t N>
size_type mn::container::basic_fixed_array< T, N >::size ( ) const
inlinenoexcept

◆ swap()

template<typename T , size_t N>
void mn::container::basic_fixed_array< T, N >::swap ( self_type &  other)
inlinenoexcept

Member Data Documentation

◆ m_nData

template<typename T , size_t N>
value_type mn::container::basic_fixed_array< T, N >::m_nData[N]
private
The documentation for this class was generated from the following file: