mn::container::basic_tuple< N, T > Class Template Reference

#include <mn_tuple.hpp>

Public Types
using	self_type = basic_tuple< N, T >
using	value_type = T
using	const_type = const T
using	reference = T &
using	const_reference = const T &
using	pointer = T *
using	const_pointer = const T *
using	size_type = size_t
using	iterator = pointer
using	const_iterator = const pointer
using	reverse_iterator = mn::reverse_iterator< iterator >
using	const_reverse_iterator = const mn::reverse_iterator< iterator >

Public Member Functions
	basic_tuple ()
	basic_tuple (const self_type &t)
	basic_tuple (mn::initializer_list< value_type > v)
	basic_tuple (const_reference a)
	basic_tuple (const_reference a, const_reference b)
	basic_tuple (const_reference a, const_reference b, const_reference c)
	basic_tuple (const_reference a, const_reference b, const_reference c, const_reference d)
template<typename U >
	basic_tuple (const basic_tuple< N, U > &src)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
size_type	size () const
size_type	max_size () const
bool	empty (void) const
const_reference	at (size_type i) const
reference	at (size_type i)
void	swap (self_type &v)
self_type &	assign (mn::initializer_list< value_type > v)
self_type &	assign (const self_type &src)
template<typename U >
self_type &	operator= (const tuple< N, U > &src)
self_type &	operator= (const self_type &src)
self_type &	operator= (mn::initializer_list< value_type > v)
self_type &	operator+= (mn::initializer_list< value_type > v)
self_type &	operator-= (mn::initializer_list< value_type > v)
self_type &	operator*= (mn::initializer_list< value_type > v)
self_type &	operator/= (mn::initializer_list< value_type > v)
self_type &	operator+= (const_reference v)
self_type &	operator-= (const_reference v)
self_type &	operator*= (const_reference v)
self_type &	operator/= (const_reference v)
self_type	operator+ (const_reference v)
self_type	operator- (const_reference v)
self_type	operator* (const_reference v)
self_type	operator/ (const_reference v)
const_reference	operator[] (size_type i) const
reference	operator[] (size_type i)

Private Attributes
T	m_dDate [N]

Member Typedef Documentation

const_iterator

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::const_iterator = const pointer

const_pointer

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::const_pointer = const T*

const_reference

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::const_reference = const T&

const_reverse_iterator

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::const_reverse_iterator = const mn::reverse_iterator<iterator>

const_type

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::const_type = const T

iterator

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::iterator = pointer

pointer

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::pointer = T*

reference

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::reference = T&

reverse_iterator

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::reverse_iterator = mn::reverse_iterator<iterator>

self_type

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::self_type = basic_tuple<N, T>

size_type

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::size_type = size_t

value_type

template<size_t N, typename T >

using mn::container::basic_tuple< N, T >::value_type = T

Constructor & Destructor Documentation

basic_tuple() [1/8]

template<size_t N, typename T >

mn::container::basic_tuple< N, T >::basic_tuple ( )

inline

basic_tuple() [2/8]

template<size_t N, typename T >

mn::container::basic_tuple< N, T >::basic_tuple ( const self_type &  t )

inline

basic_tuple() [3/8]

template<size_t N, typename T >

mn::container::basic_tuple< N, T >::basic_tuple ( mn::initializer_list< value_type >  v )

inline

basic_tuple() [4/8]

template<size_t N, typename T >

mn::container::basic_tuple< N, T >::basic_tuple ( const_reference  a )

inline

basic_tuple() [5/8]

template<size_t N, typename T >

mn::container::basic_tuple< N, T >::basic_tuple ( const_reference  a, const_reference  b  )

inline

basic_tuple() [6/8]

template<size_t N, typename T >

mn::container::basic_tuple< N, T >::basic_tuple ( const_reference  a, const_reference  b, const_reference  c  )

inline

basic_tuple() [7/8]

template<size_t N, typename T >

mn::container::basic_tuple< N, T >::basic_tuple ( const_reference  a, const_reference  b, const_reference  c, const_reference  d  )

inline

basic_tuple() [8/8]

template<size_t N, typename T >

template<typename U >

mn::container::basic_tuple< N, T >::basic_tuple ( const basic_tuple< N, U > &  src )

inline

Member Function Documentation

assign() [1/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::assign ( const self_type &  src )

inline

assign() [2/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::assign ( mn::initializer_list< value_type >  v )

inline

at() [1/2]

template<size_t N, typename T >

reference mn::container::basic_tuple< N, T >::at ( size_type  i )

inline

at() [2/2]

template<size_t N, typename T >

const_reference mn::container::basic_tuple< N, T >::at ( size_type  i ) const

inline

begin() [1/2]

template<size_t N, typename T >

iterator mn::container::basic_tuple< N, T >::begin ( )

inline

begin() [2/2]

template<size_t N, typename T >

const_iterator mn::container::basic_tuple< N, T >::begin ( ) const

inline

empty()

template<size_t N, typename T >

bool mn::container::basic_tuple< N, T >::empty ( void  ) const

inline

end() [1/2]

template<size_t N, typename T >

iterator mn::container::basic_tuple< N, T >::end ( )

inline

end() [2/2]

template<size_t N, typename T >

const_iterator mn::container::basic_tuple< N, T >::end ( ) const

inline

max_size()

template<size_t N, typename T >

size_type mn::container::basic_tuple< N, T >::max_size ( ) const

inline

operator*()

template<size_t N, typename T >

self_type mn::container::basic_tuple< N, T >::operator* ( const_reference  v )

inline

operator*=() [1/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator*= ( const_reference  v )

inline

operator*=() [2/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator*= ( mn::initializer_list< value_type >  v )

inline

operator+()

template<size_t N, typename T >

self_type mn::container::basic_tuple< N, T >::operator+ ( const_reference  v )

inline

operator+=() [1/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator+= ( const_reference  v )

inline

operator+=() [2/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator+= ( mn::initializer_list< value_type >  v )

inline

operator-()

template<size_t N, typename T >

self_type mn::container::basic_tuple< N, T >::operator- ( const_reference  v )

inline

operator-=() [1/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator-= ( const_reference  v )

inline

operator-=() [2/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator-= ( mn::initializer_list< value_type >  v )

inline

operator/()

template<size_t N, typename T >

self_type mn::container::basic_tuple< N, T >::operator/ ( const_reference  v )

inline

operator/=() [1/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator/= ( const_reference  v )

inline

operator/=() [2/2]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator/= ( mn::initializer_list< value_type >  v )

inline

operator=() [1/3]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator= ( const self_type &  src )

inline

operator=() [2/3]

template<size_t N, typename T >

template<typename U >

self_type& mn::container::basic_tuple< N, T >::operator= ( const tuple< N, U > &  src )

inline

operator=() [3/3]

template<size_t N, typename T >

self_type& mn::container::basic_tuple< N, T >::operator= ( mn::initializer_list< value_type >  v )

inline

operator[]() [1/2]

template<size_t N, typename T >

reference mn::container::basic_tuple< N, T >::operator[] ( size_type  i )

inline

operator[]() [2/2]

template<size_t N, typename T >

const_reference mn::container::basic_tuple< N, T >::operator[] ( size_type  i ) const

inline

size()

template<size_t N, typename T >

size_type mn::container::basic_tuple< N, T >::size ( ) const

inline

swap()

template<size_t N, typename T >

void mn::container::basic_tuple< N, T >::swap ( self_type &  v )

inline

Member Data Documentation

m_dDate

template<size_t N, typename T >

T mn::container::basic_tuple< N, T >::m_dDate[N]

private

---

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

• mn_tuple.hpp