MySQL  8.0.19
Source Code Documentation
stdx Namespace Reference

Namespaces

 base
 
 impl
 
 literals
 
 string_view_literals
 

Classes

class  basic_string_view
 
struct  conjunction
 
struct  conjunction< P1, Pn... >
 
struct  conjunction<>
 
struct  disjunction
 
struct  disjunction< P1 >
 
struct  disjunction< P1, Pn... >
 
class  expected
 
class  ExpectedImpl
 
class  ExpectedImpl< T, void >
 
class  ExpectedImpl< void, E >
 
class  ExpectedImpl< void, void >
 
class  ExpectedImplBase
 
struct  in_place_t
 
struct  negation
 
class  unexpected
 
class  unexpected< void >
 

Typedefs

using string_view = basic_string_view< char >
 
using wstring_view = basic_string_view< wchar_t >
 
using u16string_view = basic_string_view< char16_t >
 
using u32string_view = basic_string_view< char32_t >
 

Enumerations

enum  endian { endian::little = __ORDER_LITTLE_ENDIAN__, endian::big = __ORDER_BIG_ENDIAN__, endian::native = __BYTE_ORDER__ }
 

Functions

template<typename E >
constexpr auto make_unexpected (E &&e) -> unexpected< std::decay_t< E >>
 
constexpr auto make_unexpected ()
 
template<class E1 , class E2 >
bool operator== (const unexpected< E1 > &a, const unexpected< E2 > &b)
 
template<>
bool operator== (const unexpected< void > &, const unexpected< void > &)
 
template<class E1 , class E2 >
bool operator!= (const unexpected< E1 > &a, const unexpected< E2 > &b)
 
template<class T1 , class E1 , class T2 , class E2 >
bool operator== (const expected< T1, E1 > &a, const expected< T2, E2 > &b)
 
template<class T1 , class T2 >
std::enable_if_t< base::and_< base::not_< std::is_void< T1 > >, base::not_< std::is_void< T2 > > >::value, booloperator== (const expected< T1, void > &a, const expected< T2, void > &b)
 
template<class E1 , class E2 >
std::enable_if_t< base::and_< base::not_< std::is_void< E1 > >, base::not_< std::is_void< E2 > > >::value, booloperator== (const expected< void, E1 > &a, const expected< void, E2 > &b)
 
template<>
bool operator==<void, void, void, void > (const expected< void, void > &a, const expected< void, void > &b)
 
template<class T1 , class E1 , class T2 , class E2 >
bool operator!= (const expected< T1, E1 > &a, const expected< T2, E2 > &b)
 
template<class T1 , class E1 , class E2 >
bool operator== (const expected< T1, E1 > &a, const unexpected< E2 > &b)
 
template<class T1 , class E1 , class E2 >
bool operator== (const unexpected< E2 > &a, const expected< T1, E1 > &b)
 
template<class T1 , class E1 , class E2 >
bool operator!= (const expected< T1, E1 > &a, const unexpected< E2 > &b)
 
template<class T1 , class E1 , class E2 >
bool operator!= (const unexpected< E2 > &a, const expected< T1, E1 > &b)
 
template<class charT , class traits >
constexpr bool operator== (basic_string_view< charT, traits > a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator== (basic_string_view< charT, traits > a, impl::identity< basic_string_view< charT, traits >> b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator== (impl::identity< basic_string_view< charT, traits >> a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits >
constexpr bool operator!= (basic_string_view< charT, traits > a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator!= (basic_string_view< charT, traits > a, impl::identity< basic_string_view< charT, traits >> b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator!= (impl::identity< basic_string_view< charT, traits >> a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits >
constexpr bool operator> (basic_string_view< charT, traits > a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator> (basic_string_view< charT, traits > a, impl::identity< basic_string_view< charT, traits >> b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator> (impl::identity< basic_string_view< charT, traits >> a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits >
constexpr bool operator< (basic_string_view< charT, traits > a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator< (basic_string_view< charT, traits > a, impl::identity< basic_string_view< charT, traits >> b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator< (impl::identity< basic_string_view< charT, traits >> a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits >
constexpr bool operator<= (basic_string_view< charT, traits > a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator<= (basic_string_view< charT, traits > a, impl::identity< basic_string_view< charT, traits >> b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator<= (impl::identity< basic_string_view< charT, traits >> a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits >
constexpr bool operator>= (basic_string_view< charT, traits > a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator>= (basic_string_view< charT, traits > a, impl::identity< basic_string_view< charT, traits >> b) noexcept
 
template<class charT , class traits MSVC_ORDER>
constexpr bool operator>= (impl::identity< basic_string_view< charT, traits >> a, basic_string_view< charT, traits > b) noexcept
 
template<class charT , class traits = std::char_traits<charT>, class Allocator = std::allocator<charT>>
std::basic_string< charT, traits, Allocator > to_string (basic_string_view< charT, traits > str, const Allocator &a=Allocator())
 
template<class charT , class traits >
std::basic_ostream< charT, traits > & operator<< (std::basic_ostream< charT, traits > &o, basic_string_view< charT, traits > sv)
 
constexpr basic_string_view< char > operator""_sv (const char *str, size_t len) noexcept
 
constexpr basic_string_view< wchar_t > operator""_sv (const wchar_t *str, size_t len) noexcept
 
constexpr basic_string_view< char16_t > operator""_sv (const char16_t *str, size_t len) noexcept
 
constexpr basic_string_view< char32_t > operator""_sv (const char32_t *str, size_t len) noexcept
 

Variables

static constexpr in_place_t in_place {}
 

Typedef Documentation

◆ string_view

using stdx::string_view = typedef basic_string_view<char>

◆ u16string_view

using stdx::u16string_view = typedef basic_string_view<char16_t>

◆ u32string_view

using stdx::u32string_view = typedef basic_string_view<char32_t>

◆ wstring_view

using stdx::wstring_view = typedef basic_string_view<wchar_t>

Enumeration Type Documentation

◆ endian

enum stdx::endian
strong
Enumerator
little 
big 
native 

Function Documentation

◆ make_unexpected() [1/2]

constexpr auto stdx::make_unexpected ( )
constexpr

◆ make_unexpected() [2/2]

template<typename E >
constexpr auto stdx::make_unexpected ( E &&  e) -> unexpected<std::decay_t<E>>
constexpr

◆ operator!=() [1/7]

template<class charT , class traits >
constexpr bool stdx::operator!= ( basic_string_view< charT, traits >  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator!=() [2/7]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator!= ( basic_string_view< charT, traits >  a,
impl::identity< basic_string_view< charT, traits >>  b 
)
constexprnoexcept

◆ operator!=() [3/7]

template<class T1 , class E1 , class T2 , class E2 >
bool stdx::operator!= ( const expected< T1, E1 > &  a,
const expected< T2, E2 > &  b 
)
inline

◆ operator!=() [4/7]

template<class T1 , class E1 , class E2 >
bool stdx::operator!= ( const expected< T1, E1 > &  a,
const unexpected< E2 > &  b 
)
inline

◆ operator!=() [5/7]

template<class E1 , class E2 >
bool stdx::operator!= ( const unexpected< E1 > &  a,
const unexpected< E2 > &  b 
)
inline

◆ operator!=() [6/7]

template<class T1 , class E1 , class E2 >
bool stdx::operator!= ( const unexpected< E2 > &  a,
const expected< T1, E1 > &  b 
)

◆ operator!=() [7/7]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator!= ( impl::identity< basic_string_view< charT, traits >>  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator<() [1/3]

template<class charT , class traits >
constexpr bool stdx::operator< ( basic_string_view< charT, traits >  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator<() [2/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator< ( basic_string_view< charT, traits >  a,
impl::identity< basic_string_view< charT, traits >>  b 
)
constexprnoexcept

◆ operator<() [3/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator< ( impl::identity< basic_string_view< charT, traits >>  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator<<()

template<class charT , class traits >
std::basic_ostream<charT, traits>& stdx::operator<< ( std::basic_ostream< charT, traits > &  o,
basic_string_view< charT, traits >  sv 
)

◆ operator<=() [1/3]

template<class charT , class traits >
constexpr bool stdx::operator<= ( basic_string_view< charT, traits >  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator<=() [2/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator<= ( basic_string_view< charT, traits >  a,
impl::identity< basic_string_view< charT, traits >>  b 
)
constexprnoexcept

◆ operator<=() [3/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator<= ( impl::identity< basic_string_view< charT, traits >>  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator==() [1/10]

template<class charT , class traits >
constexpr bool stdx::operator== ( basic_string_view< charT, traits >  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator==() [2/10]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator== ( basic_string_view< charT, traits >  a,
impl::identity< basic_string_view< charT, traits >>  b 
)
constexprnoexcept

◆ operator==() [3/10]

template<class T1 , class E1 , class T2 , class E2 >
bool stdx::operator== ( const expected< T1, E1 > &  a,
const expected< T2, E2 > &  b 
)
inline

◆ operator==() [4/10]

template<class T1 , class E1 , class E2 >
bool stdx::operator== ( const expected< T1, E1 > &  a,
const unexpected< E2 > &  b 
)
inline

◆ operator==() [5/10]

template<class T1 , class T2 >
std::enable_if_t<base::and_<base::not_<std::is_void<T1> >, base::not_<std::is_void<T2> > >::value, bool> stdx::operator== ( const expected< T1, void > &  a,
const expected< T2, void > &  b 
)
inline

◆ operator==() [6/10]

template<class E1 , class E2 >
std::enable_if_t<base::and_<base::not_<std::is_void<E1> >, base::not_<std::is_void<E2> > >::value, bool> stdx::operator== ( const expected< void, E1 > &  a,
const expected< void, E2 > &  b 
)
inline

◆ operator==() [7/10]

template<class E1 , class E2 >
bool stdx::operator== ( const unexpected< E1 > &  a,
const unexpected< E2 > &  b 
)
inline

◆ operator==() [8/10]

template<class T1 , class E1 , class E2 >
bool stdx::operator== ( const unexpected< E2 > &  a,
const expected< T1, E1 > &  b 
)
inline

◆ operator==() [9/10]

template<>
bool stdx::operator== ( const unexpected< void > &  ,
const unexpected< void > &   
)
inline

◆ operator==() [10/10]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator== ( impl::identity< basic_string_view< charT, traits >>  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator==<void, void, void, void >()

template<>
bool stdx::operator==<void, void, void, void > ( const expected< void, void > &  a,
const expected< void, void > &  b 
)
inline

◆ operator>() [1/3]

template<class charT , class traits >
constexpr bool stdx::operator> ( basic_string_view< charT, traits >  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator>() [2/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator> ( basic_string_view< charT, traits >  a,
impl::identity< basic_string_view< charT, traits >>  b 
)
constexprnoexcept

◆ operator>() [3/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator> ( impl::identity< basic_string_view< charT, traits >>  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator>=() [1/3]

template<class charT , class traits >
constexpr bool stdx::operator>= ( basic_string_view< charT, traits >  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ operator>=() [2/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator>= ( basic_string_view< charT, traits >  a,
impl::identity< basic_string_view< charT, traits >>  b 
)
constexprnoexcept

◆ operator>=() [3/3]

template<class charT , class traits MSVC_ORDER>
constexpr bool stdx::operator>= ( impl::identity< basic_string_view< charT, traits >>  a,
basic_string_view< charT, traits >  b 
)
constexprnoexcept

◆ to_string()

template<class charT , class traits = std::char_traits<charT>, class Allocator = std::allocator<charT>>
std::basic_string<charT, traits, Allocator> stdx::to_string ( basic_string_view< charT, traits >  str,
const Allocator &  a = Allocator() 
)

Variable Documentation

◆ in_place

constexpr in_place_t stdx::in_place {}
staticconstexpr