QuickCppLib 0.10
Eliminate all the tedious hassle when making state-of-the-art C++ 14 - 23 libraries!
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Functions | Variables
std::experimental Namespace Reference

Namespaces

namespace  detail_
 

Classes

class  bad_optional_access
 
struct  constexpr_optional_base
 
union  constexpr_storage_t
 
struct  in_place_t
 
struct  is_assignable
 
struct  is_nothrow_move_assignable
 
struct  is_nothrow_move_constructible
 
struct  nullopt_t
 
class  optional
 
class  optional< T & >
 
class  optional< T && >
 
struct  optional_base
 
struct  Safe
 
union  storage_t
 
struct  trivial_init_t
 
struct  Unsafe
 
struct  Val
 
struct  VoidNothrowBoth
 

Typedefs

template<typename T >
using is_trivially_destructible = std::has_trivial_destructor< T >
 
template<class T >
using OptionalBase = typename std::conditional< is_trivially_destructible< T >::value, constexpr_optional_base< typename std::remove_const< T >::type >, optional_base< typename std::remove_const< T >::type > >::type
 

Functions

template<class T >
constexpr T && constexpr_forward (typename std::remove_reference< T >::type &t) noexcept
 
template<class T >
constexpr T && constexpr_forward (typename std::remove_reference< T >::type &&t) noexcept
 
template<class T >
constexpr std::remove_reference< T >::type && constexpr_move (T &&t) noexcept
 
template<class T >
constexpr bool operator== (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator!= (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator< (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator> (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator<= (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator>= (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator== (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator== (nullopt_t, const optional< T > &x) noexcept
 
template<class T >
constexpr bool operator!= (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator!= (nullopt_t, const optional< T > &x) noexcept
 
template<class T >
constexpr bool operator< (const optional< T > &, nullopt_t) noexcept
 
template<class T >
constexpr bool operator< (nullopt_t, const optional< T > &x) noexcept
 
template<class T >
constexpr bool operator<= (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator<= (nullopt_t, const optional< T > &) noexcept
 
template<class T >
constexpr bool operator> (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator> (nullopt_t, const optional< T > &) noexcept
 
template<class T >
constexpr bool operator>= (const optional< T > &, nullopt_t) noexcept
 
template<class T >
constexpr bool operator>= (nullopt_t, const optional< T > &x) noexcept
 
template<class T >
constexpr bool operator== (const optional< T > &x, const T &v)
 
template<class T >
constexpr bool operator== (const T &v, const optional< T > &x)
 
template<class T >
constexpr bool operator!= (const optional< T > &x, const T &v)
 
template<class T >
constexpr bool operator!= (const T &v, const optional< T > &x)
 
template<class T >
constexpr bool operator< (const optional< T > &x, const T &v)
 
template<class T >
constexpr bool operator> (const T &v, const optional< T > &x)
 
template<class T >
constexpr bool operator> (const optional< T > &x, const T &v)
 
template<class T >
constexpr bool operator< (const T &v, const optional< T > &x)
 
template<class T >
constexpr bool operator>= (const optional< T > &x, const T &v)
 
template<class T >
constexpr bool operator<= (const T &v, const optional< T > &x)
 
template<class T >
constexpr bool operator<= (const optional< T > &x, const T &v)
 
template<class T >
constexpr bool operator>= (const T &v, const optional< T > &x)
 
template<class T >
constexpr bool operator== (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator== (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator!= (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator!= (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator< (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator> (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator> (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator< (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator>= (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator<= (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator<= (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator>= (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator== (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator== (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator!= (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator!= (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator< (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator> (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator> (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator< (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator>= (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator<= (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator<= (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator>= (const T &v, const optional< const T & > &x)
 
template<class T >
void swap (optional< T > &x, optional< T > &y) noexcept(noexcept(x.swap(y)))
 
template<class T >
constexpr optional< typename decay< T >::type > make_optional (T &&v)
 
template<class X >
constexpr optional< X & > make_optional (reference_wrapper< X > v)
 

Variables

constexpr struct std::experimental::trivial_init_t trivial_init
 
constexpr struct std::experimental::in_place_t in_place
 
constexpr nullopt_t nullopt {nullopt_t::init()}
 

Typedef Documentation

◆ is_trivially_destructible

template<typename T >
using std::experimental::is_trivially_destructible = typedef std::has_trivial_destructor<T>

◆ OptionalBase

template<class T >
using std::experimental::OptionalBase = typedef typename std::conditional< is_trivially_destructible<T>::value, constexpr_optional_base<typename std::remove_const<T>::type>, optional_base<typename std::remove_const<T>::type> >::type

Function Documentation

◆ constexpr_forward() [1/2]

template<class T >
constexpr T && std::experimental::constexpr_forward ( typename std::remove_reference< T >::type &  t)
inlineconstexprnoexcept
183{
184 return static_cast<T&&>(t);
185}
std::experimental::optional
Definition optional.hpp:365

◆ constexpr_forward() [2/2]

template<class T >
constexpr T && std::experimental::constexpr_forward ( typename std::remove_reference< T >::type &&  t)
inlineconstexprnoexcept
188{
189 static_assert(!std::is_lvalue_reference<T>::value, "!!");
190 return static_cast<T&&>(t);
191}

◆ constexpr_move()

template<class T >
constexpr std::remove_reference< T >::type && std::experimental::constexpr_move ( T &&  t)
inlineconstexprnoexcept
194{
195 return static_cast<typename std::remove_reference<T>::type&&>(t);
196}

◆ operator==() [1/9]

template<class T >
constexpr bool std::experimental::operator== ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr
736{
737 return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
738}

◆ operator!=() [1/9]

template<class T >
constexpr bool std::experimental::operator!= ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr
741{
742 return !(x == y);
743}

◆ operator<() [1/9]

template<class T >
constexpr bool std::experimental::operator< ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr
746{
747 return (!y) ? false : (!x) ? true : *x < *y;
748}

◆ operator>() [1/9]

template<class T >
constexpr bool std::experimental::operator> ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr
751{
752 return (y < x);
753}

◆ operator<=() [1/9]

template<class T >
constexpr bool std::experimental::operator<= ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr
756{
757 return !(y < x);
758}

◆ operator>=() [1/9]

template<class T >
constexpr bool std::experimental::operator>= ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr
761{
762 return !(x < y);
763}

◆ operator==() [2/9]

template<class T >
constexpr bool std::experimental::operator== ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept
768{
769 return (!x);
770}

◆ operator==() [3/9]

template<class T >
constexpr bool std::experimental::operator== ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept
773{
774 return (!x);
775}

◆ operator!=() [2/9]

template<class T >
constexpr bool std::experimental::operator!= ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept
778{
779 return bool(x);
780}

◆ operator!=() [3/9]

template<class T >
constexpr bool std::experimental::operator!= ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept
783{
784 return bool(x);
785}

◆ operator<() [2/9]

template<class T >
constexpr bool std::experimental::operator< ( const optional< T > &  ,
nullopt_t   
)
constexprnoexcept
788{
789 return false;
790}

◆ operator<() [3/9]

template<class T >
constexpr bool std::experimental::operator< ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept
793{
794 return bool(x);
795}

◆ operator<=() [2/9]

template<class T >
constexpr bool std::experimental::operator<= ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept
798{
799 return (!x);
800}

◆ operator<=() [3/9]

template<class T >
constexpr bool std::experimental::operator<= ( nullopt_t  ,
const optional< T > &   
)
constexprnoexcept
803{
804 return true;
805}

◆ operator>() [2/9]

template<class T >
constexpr bool std::experimental::operator> ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept
808{
809 return bool(x);
810}

◆ operator>() [3/9]

template<class T >
constexpr bool std::experimental::operator> ( nullopt_t  ,
const optional< T > &   
)
constexprnoexcept
813{
814 return false;
815}

◆ operator>=() [2/9]

template<class T >
constexpr bool std::experimental::operator>= ( const optional< T > &  ,
nullopt_t   
)
constexprnoexcept
818{
819 return true;
820}

◆ operator>=() [3/9]

template<class T >
constexpr bool std::experimental::operator>= ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept
823{
824 return (!x);
825}

◆ operator==() [4/9]

template<class T >
constexpr bool std::experimental::operator== ( const optional< T > &  x,
const T &  v 
)
constexpr
831{
832 return bool(x) ? *x == v : false;
833}

◆ operator==() [5/9]

template<class T >
constexpr bool std::experimental::operator== ( const T &  v,
const optional< T > &  x 
)
constexpr
836{
837 return bool(x) ? v == *x : false;
838}

◆ operator!=() [4/9]

template<class T >
constexpr bool std::experimental::operator!= ( const optional< T > &  x,
const T &  v 
)
constexpr
841{
842 return bool(x) ? *x != v : true;
843}

◆ operator!=() [5/9]

template<class T >
constexpr bool std::experimental::operator!= ( const T &  v,
const optional< T > &  x 
)
constexpr
846{
847 return bool(x) ? v != *x : true;
848}

◆ operator<() [4/9]

template<class T >
constexpr bool std::experimental::operator< ( const optional< T > &  x,
const T &  v 
)
constexpr
851{
852 return bool(x) ? *x < v : true;
853}

◆ operator>() [4/9]

template<class T >
constexpr bool std::experimental::operator> ( const T &  v,
const optional< T > &  x 
)
constexpr
856{
857 return bool(x) ? v > *x : true;
858}

◆ operator>() [5/9]

template<class T >
constexpr bool std::experimental::operator> ( const optional< T > &  x,
const T &  v 
)
constexpr
861{
862 return bool(x) ? *x > v : false;
863}

◆ operator<() [5/9]

template<class T >
constexpr bool std::experimental::operator< ( const T &  v,
const optional< T > &  x 
)
constexpr
866{
867 return bool(x) ? v < *x : false;
868}

◆ operator>=() [4/9]

template<class T >
constexpr bool std::experimental::operator>= ( const optional< T > &  x,
const T &  v 
)
constexpr
871{
872 return bool(x) ? *x >= v : false;
873}

◆ operator<=() [4/9]

template<class T >
constexpr bool std::experimental::operator<= ( const T &  v,
const optional< T > &  x 
)
constexpr
876{
877 return bool(x) ? v <= *x : false;
878}

◆ operator<=() [5/9]

template<class T >
constexpr bool std::experimental::operator<= ( const optional< T > &  x,
const T &  v 
)
constexpr
881{
882 return bool(x) ? *x <= v : true;
883}

◆ operator>=() [5/9]

template<class T >
constexpr bool std::experimental::operator>= ( const T &  v,
const optional< T > &  x 
)
constexpr
886{
887 return bool(x) ? v >= *x : true;
888}

◆ operator==() [6/9]

template<class T >
constexpr bool std::experimental::operator== ( const optional< T & > &  x,
const T &  v 
)
constexpr
893{
894 return bool(x) ? *x == v : false;
895}

◆ operator==() [7/9]

template<class T >
constexpr bool std::experimental::operator== ( const T &  v,
const optional< T & > &  x 
)
constexpr
898{
899 return bool(x) ? v == *x : false;
900}

◆ operator!=() [6/9]

template<class T >
constexpr bool std::experimental::operator!= ( const optional< T & > &  x,
const T &  v 
)
constexpr
903{
904 return bool(x) ? *x != v : true;
905}

◆ operator!=() [7/9]

template<class T >
constexpr bool std::experimental::operator!= ( const T &  v,
const optional< T & > &  x 
)
constexpr
908{
909 return bool(x) ? v != *x : true;
910}

◆ operator<() [6/9]

template<class T >
constexpr bool std::experimental::operator< ( const optional< T & > &  x,
const T &  v 
)
constexpr
913{
914 return bool(x) ? *x < v : true;
915}

◆ operator>() [6/9]

template<class T >
constexpr bool std::experimental::operator> ( const T &  v,
const optional< T & > &  x 
)
constexpr
918{
919 return bool(x) ? v > *x : true;
920}

◆ operator>() [7/9]

template<class T >
constexpr bool std::experimental::operator> ( const optional< T & > &  x,
const T &  v 
)
constexpr
923{
924 return bool(x) ? *x > v : false;
925}

◆ operator<() [7/9]

template<class T >
constexpr bool std::experimental::operator< ( const T &  v,
const optional< T & > &  x 
)
constexpr
928{
929 return bool(x) ? v < *x : false;
930}

◆ operator>=() [6/9]

template<class T >
constexpr bool std::experimental::operator>= ( const optional< T & > &  x,
const T &  v 
)
constexpr
933{
934 return bool(x) ? *x >= v : false;
935}

◆ operator<=() [6/9]

template<class T >
constexpr bool std::experimental::operator<= ( const T &  v,
const optional< T & > &  x 
)
constexpr
938{
939 return bool(x) ? v <= *x : false;
940}

◆ operator<=() [7/9]

template<class T >
constexpr bool std::experimental::operator<= ( const optional< T & > &  x,
const T &  v 
)
constexpr
943{
944 return bool(x) ? *x <= v : true;
945}

◆ operator>=() [7/9]

template<class T >
constexpr bool std::experimental::operator>= ( const T &  v,
const optional< T & > &  x 
)
constexpr
948{
949 return bool(x) ? v >= *x : true;
950}

◆ operator==() [8/9]

template<class T >
constexpr bool std::experimental::operator== ( const optional< const T & > &  x,
const T &  v 
)
constexpr
954{
955 return bool(x) ? *x == v : false;
956}

◆ operator==() [9/9]

template<class T >
constexpr bool std::experimental::operator== ( const T &  v,
const optional< const T & > &  x 
)
constexpr
959{
960 return bool(x) ? v == *x : false;
961}

◆ operator!=() [8/9]

template<class T >
constexpr bool std::experimental::operator!= ( const optional< const T & > &  x,
const T &  v 
)
constexpr
964{
965 return bool(x) ? *x != v : true;
966}

◆ operator!=() [9/9]

template<class T >
constexpr bool std::experimental::operator!= ( const T &  v,
const optional< const T & > &  x 
)
constexpr
969{
970 return bool(x) ? v != *x : true;
971}

◆ operator<() [8/9]

template<class T >
constexpr bool std::experimental::operator< ( const optional< const T & > &  x,
const T &  v 
)
constexpr
974{
975 return bool(x) ? *x < v : true;
976}

◆ operator>() [8/9]

template<class T >
constexpr bool std::experimental::operator> ( const T &  v,
const optional< const T & > &  x 
)
constexpr
979{
980 return bool(x) ? v > *x : true;
981}

◆ operator>() [9/9]

template<class T >
constexpr bool std::experimental::operator> ( const optional< const T & > &  x,
const T &  v 
)
constexpr
984{
985 return bool(x) ? *x > v : false;
986}

◆ operator<() [9/9]

template<class T >
constexpr bool std::experimental::operator< ( const T &  v,
const optional< const T & > &  x 
)
constexpr
989{
990 return bool(x) ? v < *x : false;
991}

◆ operator>=() [8/9]

template<class T >
constexpr bool std::experimental::operator>= ( const optional< const T & > &  x,
const T &  v 
)
constexpr
994{
995 return bool(x) ? *x >= v : false;
996}

◆ operator<=() [8/9]

template<class T >
constexpr bool std::experimental::operator<= ( const T &  v,
const optional< const T & > &  x 
)
constexpr
999{
1000 return bool(x) ? v <= *x : false;
1001}

◆ operator<=() [9/9]

template<class T >
constexpr bool std::experimental::operator<= ( const optional< const T & > &  x,
const T &  v 
)
constexpr
1004{
1005 return bool(x) ? *x <= v : true;
1006}

◆ operator>=() [9/9]

template<class T >
constexpr bool std::experimental::operator>= ( const T &  v,
const optional< const T & > &  x 
)
constexpr
1009{
1010 return bool(x) ? v >= *x : true;
1011}

◆ swap()

template<class T >
void std::experimental::swap ( optional< T > &  x,
optional< T > &  y 
)
noexcept
1017{
1018 x.swap(y);
1019}
std::experimental::optional::swap
void swap(optional< T > &rhs) noexcept(is_nothrow_move_constructible< T >::value &&noexcept(detail_::swap_ns::adl_swap(declval< T & >(), declval< T & >())))
Definition optional.hpp:502

◆ make_optional() [1/2]

template<class T >
constexpr optional< typename decay< T >::type > std::experimental::make_optional ( T &&  v)
constexpr
1024{
1025 return optional<typename decay<T>::type>(constexpr_forward<T>(v));
1026}

◆ make_optional() [2/2]

template<class X >
constexpr optional< X & > std::experimental::make_optional ( reference_wrapper< X >  v)
constexpr
1030{
1031 return optional<X&>(v.get());
1032}

Variable Documentation

◆ trivial_init

constexpr struct std::experimental::trivial_init_t std::experimental::trivial_init

◆ in_place

constexpr struct std::experimental::in_place_t std::experimental::in_place

◆ nullopt

constexpr nullopt_t std::experimental::nullopt {nullopt_t::init()}
constexpr
268{nullopt_t::init()};
std::experimental::nullopt_t::init
Definition optional.hpp:265