CommonLibSSE NG
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Public Attributes | List of all members
RE::BSTTuple< T1, T2 > Struct Template Reference

#include <BSTTuple.h>

Public Types

using first_type = T1
 
using second_type = T2
 

Public Member Functions

 BSTTuple () noexcept(std::is_nothrow_default_constructible_v< first_type > &&std::is_nothrow_default_constructible_v< second_type >)
 
 explicit (!std::is_convertible_v< const first_type &, first_type >||!std::is_convertible_v< const second_type &, second_type >) BSTTuple(const first_type &a_first
 
const second_type &a_second noexcept (std::is_nothrow_copy_constructible_v< first_type > &&std::is_nothrow_copy_constructible_v< second_type >)
 
template<class U1 , class U2 >
 explicit (!std::is_convertible_v< U1 &&, first_type >||!std::is_convertible_v< U2 &&, second_type >) BSTTuple(U1 &&a_first
 
U2 &&a_second noexcept (std::is_nothrow_constructible_v< first_type, U1 && > &&std::is_nothrow_constructible_v< second_type, U2 && >)
 
template<class U1 , class U2 >
 explicit (!std::is_convertible_v< const U1 &, first_type >||!std::is_convertible_v< const U2 &, second_type >) BSTTuple(const BSTTuple< U1
 
U2 &a_rhs noexcept (std::is_nothrow_constructible_v< first_type, const U1 & > &&std::is_nothrow_constructible_v< second_type, const U2 & >)
 
template<class U1 , class U2 >
 explicit (!std::is_convertible_v< U1 &&, first_type >||!std::is_convertible_v< U2 &&, second_type >) BSTTuple(BSTTuple< U1
 
U2 &&a_rhs noexcept (std::is_nothrow_constructible_v< first_type, U1 && > &&std::is_nothrow_constructible_v< second_type, U2 && >)
 
template<class... Args1, class... Args2>
 BSTTuple (std::piecewise_construct_t, std::tuple< Args1... > a_firstArgs, std::tuple< Args2... > a_secondArgs)
 
 BSTTuple (const BSTTuple &)=default
 
 BSTTuple (BSTTuple &&)=default
 
 ~BSTTuple ()=default
 
BSTTuple & operator= (const BSTTuple &a_rhs) noexcept(std::is_nothrow_copy_assignable_v< first_type > &&std::is_nothrow_copy_assignable_v< second_type >)
 
template<class U1 , class U2 >
requires (std::is_assignable_v<first_type&, const U1&>&& std::is_assignable_v<second_type&, const U2&>)
BSTTuple & operator= (const BSTTuple< U1, U2 > &a_rhs) noexcept(std::is_nothrow_assignable_v< first_type &, const U1 & > &&std::is_nothrow_assignable_v< second_type &, const U2 & >)
 
BSTTuple & operator= (BSTTuple &&a_rhs) noexcept(std::is_nothrow_move_assignable_v< first_type > &&std::is_nothrow_move_assignable_v< second_type >)
 
template<class U1 , class U2 >
requires (std::is_assignable_v<first_type&, U1>&& std::is_assignable_v<second_type&, U2>)
BSTTuple & operator= (BSTTuple< U1, U2 > &&a_rhs) noexcept(std::is_nothrow_assignable_v< first_type &, U1 > &&std::is_nothrow_assignable_v< second_type &, U2 >)
 
 TES_HEAP_REDEFINE_NEW ()
 
void swap (BSTTuple &a_rhs) noexcept(std::is_nothrow_swappable_v< first_type > &&std::is_nothrow_swappable_v< second_type >)
 

Public Attributes

first_type first
 
second_type second
 

Member Typedef Documentation

◆ first_type

template<class T1 , class T2 >
using RE::BSTTuple< T1, T2 >::first_type = T1

◆ second_type

template<class T1 , class T2 >
using RE::BSTTuple< T1, T2 >::second_type = T2

Constructor & Destructor Documentation

◆ BSTTuple() [1/4]

template<class T1 , class T2 >
RE::BSTTuple< T1, T2 >::BSTTuple ( )
inlinenoexcept

◆ BSTTuple() [2/4]

template<class T1 , class T2 >
template<class... Args1, class... Args2>
RE::BSTTuple< T1, T2 >::BSTTuple ( std::piecewise_construct_t  ,
std::tuple< Args1... >  a_firstArgs,
std::tuple< Args2... >  a_secondArgs 
)
inline

◆ BSTTuple() [3/4]

template<class T1 , class T2 >
RE::BSTTuple< T1, T2 >::BSTTuple ( const BSTTuple< T1, T2 > &  )
default

◆ BSTTuple() [4/4]

template<class T1 , class T2 >
RE::BSTTuple< T1, T2 >::BSTTuple ( BSTTuple< T1, T2 > &&  )
default

◆ ~BSTTuple()

template<class T1 , class T2 >
RE::BSTTuple< T1, T2 >::~BSTTuple ( )
default

Member Function Documentation

◆ explicit() [1/4]

template<class T1 , class T2 >
RE::BSTTuple< T1, T2 >::explicit ( !std::is_convertible_v< const first_type &, first_type >||!std::is_convertible_v< const second_type &, second_type >  ) const &

◆ explicit() [2/4]

template<class T1 , class T2 >
template<class U1 , class U2 >
RE::BSTTuple< T1, T2 >::explicit ( !std::is_convertible_v< const U1 &, first_type >||!std::is_convertible_v< const U2 &, second_type >  ) const

◆ explicit() [3/4]

template<class T1 , class T2 >
template<class U1 , class U2 >
RE::BSTTuple< T1, T2 >::explicit ( !std::is_convertible_v< U1 &&, first_type >||!std::is_convertible_v< U2 &&, second_type >  )

◆ explicit() [4/4]

template<class T1 , class T2 >
template<class U1 , class U2 >
RE::BSTTuple< T1, T2 >::explicit ( !std::is_convertible_v< U1 &&, first_type >||!std::is_convertible_v< U2 &&, second_type >  ) &&

◆ noexcept() [1/4]

template<class T1 , class T2 >
U2 &a_rhs RE::BSTTuple< T1, T2 >::noexcept ( std::is_nothrow_constructible_v< first_type, const U1 & > &&std::is_nothrow_constructible_v< second_type, const U2 & >  )
inline

◆ noexcept() [2/4]

template<class T1 , class T2 >
U2 &&a_second RE::BSTTuple< T1, T2 >::noexcept ( std::is_nothrow_constructible_v< first_type, U1 && > &&std::is_nothrow_constructible_v< second_type, U2 && >  )
inline

◆ noexcept() [3/4]

template<class T1 , class T2 >
U2 &&a_rhs RE::BSTTuple< T1, T2 >::noexcept ( std::is_nothrow_constructible_v< first_type, U1 && > &&std::is_nothrow_constructible_v< second_type, U2 && >  )
inline

◆ noexcept() [4/4]

template<class T1 , class T2 >
const second_type &a_second RE::BSTTuple< T1, T2 >::noexcept ( std::is_nothrow_copy_constructible_v< first_type > &&std::is_nothrow_copy_constructible_v< second_type >  )
inline

◆ operator=() [1/4]

template<class T1 , class T2 >
BSTTuple & RE::BSTTuple< T1, T2 >::operator= ( BSTTuple< T1, T2 > &&  a_rhs)
inlinenoexcept

◆ operator=() [2/4]

template<class T1 , class T2 >
template<class U1 , class U2 >
requires (std::is_assignable_v<first_type&, U1>&& std::is_assignable_v<second_type&, U2>)
BSTTuple & RE::BSTTuple< T1, T2 >::operator= ( BSTTuple< U1, U2 > &&  a_rhs)
inlinenoexcept

◆ operator=() [3/4]

template<class T1 , class T2 >
BSTTuple & RE::BSTTuple< T1, T2 >::operator= ( const BSTTuple< T1, T2 > &  a_rhs)
inlinenoexcept

◆ operator=() [4/4]

template<class T1 , class T2 >
template<class U1 , class U2 >
requires (std::is_assignable_v<first_type&, const U1&>&& std::is_assignable_v<second_type&, const U2&>)
BSTTuple & RE::BSTTuple< T1, T2 >::operator= ( const BSTTuple< U1, U2 > &  a_rhs)
inlinenoexcept

◆ swap()

template<class T1 , class T2 >
void RE::BSTTuple< T1, T2 >::swap ( BSTTuple< T1, T2 > &  a_rhs)
inlinenoexcept

◆ TES_HEAP_REDEFINE_NEW()

template<class T1 , class T2 >
RE::BSTTuple< T1, T2 >::TES_HEAP_REDEFINE_NEW ( )

Member Data Documentation

◆ first

template<class T1 , class T2 >
first_type RE::BSTTuple< T1, T2 >::first

◆ second

template<class T1 , class T2 >
second_type RE::BSTTuple< T1, T2 >::second
The documentation for this struct was generated from the following file: