mn::container::basic_pair< TFIRST, TSECOND > Struct Template Reference

#include <mn_pair.hpp>

+ Inheritance diagram for mn::container::basic_pair< TFIRST, TSECOND >:

Public Types

using first_type = TFIRST
 
using pointer_first = TFIRST *
 
using reference_first = TFIRST &
 
using const_reference_first = const TFIRST &
 
using second_type = TSECOND
 
using pointer_second = TSECOND *
 
using reference_second = TSECOND &
 
using const_reference_second = const TSECOND &
 
using self_type = basic_pair< TFIRST, TSECOND >
 

Public Member Functions

 basic_pair ()
 
 basic_pair (const reference_first a) noexcept
 
 basic_pair (const reference_first a, reference_second b)
 
 basic_pair (const self_type &other) noexcept
 
void swap (const self_type &other) noexcept
 
self_typeoperator= (const self_type &rhs) noexcept
 
bool operator== (const self_type &rhs) noexcept
 
bool operator!= (const self_type &rhs) noexcept
 

Public Attributes

first_type first
 
second_type second
 

Member Typedef Documentation

◆ const_reference_first

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::const_reference_first = const TFIRST&

◆ const_reference_second

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::const_reference_second = const TSECOND&

◆ first_type

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::first_type = TFIRST

◆ pointer_first

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::pointer_first = TFIRST*

◆ pointer_second

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::pointer_second = TSECOND*

◆ reference_first

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::reference_first = TFIRST&

◆ reference_second

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::reference_second = TSECOND&

◆ second_type

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::second_type = TSECOND

◆ self_type

template<typename TFIRST , typename TSECOND >
using mn::container::basic_pair< TFIRST, TSECOND >::self_type = basic_pair<TFIRST, TSECOND>

Constructor & Destructor Documentation

◆ basic_pair() [1/4]

template<typename TFIRST , typename TSECOND >
mn::container::basic_pair< TFIRST, TSECOND >::basic_pair ( )
inline

◆ basic_pair() [2/4]

template<typename TFIRST , typename TSECOND >
mn::container::basic_pair< TFIRST, TSECOND >::basic_pair ( const reference_first  a)
inlineexplicitnoexcept

◆ basic_pair() [3/4]

template<typename TFIRST , typename TSECOND >
mn::container::basic_pair< TFIRST, TSECOND >::basic_pair ( const reference_first  a,
reference_second  b 
)
inline

◆ basic_pair() [4/4]

template<typename TFIRST , typename TSECOND >
mn::container::basic_pair< TFIRST, TSECOND >::basic_pair ( const self_type other)
inlinenoexcept

Member Function Documentation

◆ operator!=()

template<typename TFIRST , typename TSECOND >
bool mn::container::basic_pair< TFIRST, TSECOND >::operator!= ( const self_type rhs)
inlinenoexcept

◆ operator=()

template<typename TFIRST , typename TSECOND >
self_type& mn::container::basic_pair< TFIRST, TSECOND >::operator= ( const self_type rhs)
inlinenoexcept

◆ operator==()

template<typename TFIRST , typename TSECOND >
bool mn::container::basic_pair< TFIRST, TSECOND >::operator== ( const self_type rhs)
inlinenoexcept

◆ swap()

template<typename TFIRST , typename TSECOND >
void mn::container::basic_pair< TFIRST, TSECOND >::swap ( const self_type other)
inlinenoexcept

Member Data Documentation

◆ first

template<typename TFIRST , typename TSECOND >
first_type mn::container::basic_pair< TFIRST, TSECOND >::first

◆ second

template<typename TFIRST , typename TSECOND >
second_type mn::container::basic_pair< TFIRST, TSECOND >::second

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