Empirical
Classes | Public Types | Public Member Functions | Public Attributes | List of all members
emp::array< T, N > Class Template Reference

#include <array.h>

Inheritance diagram for emp::array< T, N >:

Classes

struct  iterator_wrapper
 Setup an iterator wrapper to make sure that they're valid. More...
 

Public Types

using iterator = iterator_wrapper< typename base_t::iterator >
 
using const_iterator = iterator_wrapper< typename base_t::const_iterator >
 
using reverse_iterator = iterator_wrapper< typename base_t::reverse_iterator >
 
using const_reverse_iterator = iterator_wrapper< typename base_t::const_reverse_iterator >
 
using value_type = T
 
using size_type = typename base_t::size_type
 
using reference = typename base_t::reference
 
using const_reference = typename base_t::const_reference
 

Public Member Functions

 array ()
 
 array (const this_t &_in)
 
 array (std::initializer_list< T > in_list)
 
 array (const base_t &in)
 
template<typename InputIt >
 array (InputIt first, InputIt last)
 
 ~array ()
 
 operator std::array< T, N > ()
 
constexpr size_t size () const
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
this_toperator= (const this_t &)=default
 
T & operator[] (size_t pos)
 
const T & operator[] (size_t pos) const
 
T & back ()
 
const T & back () const
 
T & front ()
 
const T & front () const
 
void fill (const T &val)
 
void resize (size_t new_size)
 
void resize (size_t new_size, const T &val)
 
template<typename... PB_Ts>
void push_back (PB_Ts &&...args)
 
void pop_back ()
 
template<typename... ARGS>
iterator insert (ARGS &&...args)
 
template<typename... ARGS>
iterator erase (ARGS &&...args)
 
template<typename... ARGS>
iterator emplace (ARGS &&...args)
 
template<typename... ARGS>
void emplace_back (ARGS &&...args)
 

Public Attributes

bool valid
 

Detailed Description

template<typename T, size_t N>
class emp::array< T, N >

We are in debug mode, so emp::array has the same interface as std::array, but with extra bounds checking. Using vector as our base since it has the right pieces and is dyanmic.

Member Typedef Documentation

template<typename T, size_t N>
using emp::array< T, N >::const_iterator = iterator_wrapper< typename base_t::const_iterator >
template<typename T, size_t N>
using emp::array< T, N >::const_reference = typename base_t::const_reference
template<typename T, size_t N>
using emp::array< T, N >::const_reverse_iterator = iterator_wrapper< typename base_t::const_reverse_iterator >
template<typename T, size_t N>
using emp::array< T, N >::iterator = iterator_wrapper< typename base_t::iterator >
template<typename T, size_t N>
using emp::array< T, N >::reference = typename base_t::reference
template<typename T, size_t N>
using emp::array< T, N >::reverse_iterator = iterator_wrapper< typename base_t::reverse_iterator >
template<typename T, size_t N>
using emp::array< T, N >::size_type = typename base_t::size_type
template<typename T, size_t N>
using emp::array< T, N >::value_type = T

Constructor & Destructor Documentation

template<typename T, size_t N>
emp::array< T, N >::array ( )
inline
template<typename T, size_t N>
emp::array< T, N >::array ( const this_t _in)
inline
template<typename T, size_t N>
emp::array< T, N >::array ( std::initializer_list< T >  in_list)
inline
template<typename T, size_t N>
emp::array< T, N >::array ( const base_t &  in)
inline
template<typename T, size_t N>
template<typename InputIt >
emp::array< T, N >::array ( InputIt  first,
InputIt  last 
)
inline
template<typename T, size_t N>
emp::array< T, N >::~array ( )
inline

Member Function Documentation

template<typename T, size_t N>
T& emp::array< T, N >::back ( )
inline
template<typename T, size_t N>
const T& emp::array< T, N >::back ( ) const
inline
template<typename T, size_t N>
iterator emp::array< T, N >::begin ( )
inlinenoexcept
template<typename T, size_t N>
const_iterator emp::array< T, N >::begin ( ) const
inlinenoexcept
template<typename T, size_t N>
template<typename... ARGS>
iterator emp::array< T, N >::emplace ( ARGS &&...  args)
inline
template<typename T, size_t N>
template<typename... ARGS>
void emp::array< T, N >::emplace_back ( ARGS &&...  args)
inline
template<typename T, size_t N>
iterator emp::array< T, N >::end ( )
inlinenoexcept
template<typename T, size_t N>
const_iterator emp::array< T, N >::end ( ) const
inlinenoexcept
template<typename T, size_t N>
template<typename... ARGS>
iterator emp::array< T, N >::erase ( ARGS &&...  args)
inline
template<typename T, size_t N>
void emp::array< T, N >::fill ( const T &  val)
inline
template<typename T, size_t N>
T& emp::array< T, N >::front ( )
inline
template<typename T, size_t N>
const T& emp::array< T, N >::front ( ) const
inline
template<typename T, size_t N>
template<typename... ARGS>
iterator emp::array< T, N >::insert ( ARGS &&...  args)
inline
template<typename T, size_t N>
emp::array< T, N >::operator std::array< T, N > ( )
inline
template<typename T, size_t N>
this_t& emp::array< T, N >::operator= ( const this_t )
default
template<typename T, size_t N>
T& emp::array< T, N >::operator[] ( size_t  pos)
inline
template<typename T, size_t N>
const T& emp::array< T, N >::operator[] ( size_t  pos) const
inline
template<typename T, size_t N>
void emp::array< T, N >::pop_back ( )
inline
template<typename T, size_t N>
template<typename... PB_Ts>
void emp::array< T, N >::push_back ( PB_Ts &&...  args)
inline
template<typename T, size_t N>
void emp::array< T, N >::resize ( size_t  new_size)
inline
template<typename T, size_t N>
void emp::array< T, N >::resize ( size_t  new_size,
const T &  val 
)
inline
template<typename T, size_t N>
constexpr size_t emp::array< T, N >::size ( ) const
inline

Member Data Documentation

template<typename T, size_t N>
bool emp::array< T, N >::valid

The documentation for this class was generated from the following file: