#pragma once
#ifndef _TYPE_TRAITS_
#define _TYPE_TRAITS_
#ifndef RC_INVOKED
#include <xstddef>
#pragma pack(push,_CRT_PACKING)
#pragma warning(push,_STL_WARNING_LEVEL)
#pragma warning(disable: _STL_DISABLED_WARNINGS)
#pragma warning(disable:
4455
4494
4619
4643
4702
4984
4988
)
_STL_DISABLE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new
#pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
#pragma warning(disable:
4180
)
template
<
class
,
...
>
struct
{
static_assert
(
<
>,
"integer_sequence<T, I...> requires T to be an integral type."
);
using
=
;
_NODISCARD static constexpr size_t size() noexcept
static
constexpr
()
noexcept
{
return
(
sizeof
...(
));
}
};
template
<
class
,
>
using
= __make_integer_seq<
,
,
>;
template
<
...
>
using
=
<
,
...>;
template
<
>
using
=
<
,
>;
template
<
class
...
>
using
=
<
sizeof
...(
)>;
template
<
bool
,
class
,
class
...
>
struct
{
using
=
;
};
template
<
class
,
class
,
class
...
>
struct
<
true
,
,
,
...>
{
using
=
typename
<
::value,
,
...>::
;
};
template
<
class
...
>
struct
:
{
};
template
<
class
,
class
...
>
struct
<
,
...>
:
<
::value,
,
...>::
{
};
template
<
class
...
>
_INLINE_VAR constexpr bool conjunction_v = conjunction<_Traits...>::value;
constexpr
bool
=
<
...>::
;
template
<
bool
,
class
,
class
...
>
struct
{
using
=
;
};
template
<
class
,
class
,
class
...
>
struct
<
false
,
,
,
...>
{
using
=
typename
<
::value,
,
...>::
;
};
template
<
class
...
>
struct
:
{
};
template
<
class
,
class
...
>
struct
<
,
...>
:
<
::value,
,
...>::
{
};
template
<
class
...
>
_INLINE_VAR constexpr bool disjunction_v = disjunction<_Traits...>::value;
constexpr
bool
=
<
...>::
;
template
<
class
>
struct
:
<!
static_cast
<
bool
>(
::value)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool negation_v = negation<_Trait>::value;
template
<
class
,
class
...
>
_INLINE_VAR constexpr bool _Is_any_of_v = disjunction_v<is_same<_Ty, _Types>...>;
constexpr
bool
=
<
<
,
>...>;
template
<
class
...
>
struct
{
};
template
<
class
>
struct
<
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty1 argument_type;
};
template
<
class
,
class
>
struct
<
,
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty1 first_argument_type;
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty2 second_argument_type;
};
template
<
class
>
struct
{
using
=
;
};
#define _IS_FUNCTION(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
template<class _Ret, \
class... _Types> \
struct _Is_function<_Ret CALL_OPT (_Types...) CV_OPT REF_OPT NOEXCEPT_OPT> \
: _Arg_types<_Types...> \
{ /* determine whether _Ty is a function */ \
using _Bool_type = true_type; \
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ret result_type; \
};
_NON_MEMBER_CALL_CV_REF_NOEXCEPT(_IS_FUNCTION)
template
<
class
,
class
...
>
struct
<
__cdecl
(
...) > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...) > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...) > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...) > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
const
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
const
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
const
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
const
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
const
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
const
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
const
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
const
volatile
> :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...) & > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...) & > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...) & > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...) & > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
const
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
const
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
const
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
const
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
const
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
const
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
const
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
const
volatile
& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...) && > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...) && > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...) && > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...) && > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
const
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
const
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
const
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
const
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
volatile
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
volatile
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
volatile
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
volatile
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)
const
volatile
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)
const
volatile
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)
const
volatile
&& > :
<
...> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)
const
volatile
&& > :
<
...> {
using
=
;
typedef
; };
#undef _IS_FUNCTION
#define _IS_FUNCTION_ELLIPSIS(CV_REF_NOEXCEPT_OPT) \
template<class _Ret, \
class... _Types> \
struct _Is_function<_Ret (_Types..., ...) CV_REF_NOEXCEPT_OPT> \
{ /* no calling conventions for ellipsis */ \
using _Bool_type = true_type; \
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ret result_type; \
};
_CLASS_DEFINE_CV_REF_NOEXCEPT(_IS_FUNCTION_ELLIPSIS)
template
<
class
,
class
...
>
struct
<
(
..., ...) > {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
const
> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
volatile
> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
const
volatile
> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...) &> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
const
&> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
volatile
&> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
const
volatile
&> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...) &&> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
const
&&> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
volatile
&&> {
using
=
;
typedef
; };
template
<
class
,
class
...
>
struct
<
(
..., ...)
const
volatile
&&> {
using
=
;
typedef
; };
#undef _IS_FUNCTION_ELLIPSIS
template
<
class
>
struct
:
<
>::
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_function_v = is_function<_Ty>::value;
template
<
class
>
struct
{
using
=
;
};
#define _IS_MEMFUNPTR(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
template<class _Ret, \
class _Arg0, \
class... _Types> \
struct _Is_memfunptr<_Ret (CALL_OPT _Arg0::*)(_Types...) CV_OPT REF_OPT NOEXCEPT_OPT> \
: _Arg_types<CV_OPT _Arg0 *, _Types...> \
{ /* base class for member function pointer predicates */ \
using _Bool_type = true_type; \
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ret result_type; \
using _Class_type = _Arg0; \
using _Guide_type = enable_if<!is_same_v<int REF_OPT, int&&>, _Ret (_Types...)>; \
};
_MEMBER_CALL_CV_REF_NOEXCEPT(_IS_MEMFUNPTR)
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...) > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...) > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...) > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...) > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...) > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
const
> :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
const
> :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
const
> :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
const
> :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
const
> :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
volatile
> :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
volatile
> :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
volatile
> :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
volatile
> :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
volatile
> :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
const
volatile
> :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
const
volatile
> :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
const
volatile
> :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
const
volatile
> :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
const
volatile
> :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...) & > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...) & > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...) & > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...) & > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...) & > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
const
& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
const
& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
const
& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
const
& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
const
& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
volatile
& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
volatile
& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
volatile
& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
volatile
& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
volatile
& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
const
volatile
& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
const
volatile
& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
const
volatile
& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
const
volatile
& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
const
volatile
& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...) && > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...) && > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...) && > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...) && > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...) && > :
<
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
const
&& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
const
&& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
const
&& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
const
&& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
const
&& > :
<
const
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
volatile
&& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
volatile
&& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
volatile
&& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
volatile
&& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
volatile
&& > :
<
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__cdecl
::*)(
...)
const
volatile
&& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__fastcall
::*)(
...)
const
volatile
&& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__stdcall
::*)(
...)
const
volatile
&& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__thiscall
::*)(
...)
const
volatile
&& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
template
<
class
,
class
,
class
...
>
struct
<
(
__vectorcall
::*)(
...)
const
volatile
&& > :
<
const
volatile
*,
...> {
using
=
;
typedef
;
using
=
;
using
=
<!
<
int
&&,
int
&&>,
(
...)>; };
#undef _IS_MEMFUNPTR
#define _IS_MEMFUNPTR_ELLIPSIS(CV_REF_NOEXCEPT_OPT) \
template<class _Ret, \
class _Arg0, \
class... _Types> \
struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) CV_REF_NOEXCEPT_OPT> \
{ /* no calling conventions for ellipsis */ \
using _Bool_type = true_type; \
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ret result_type; \
using _Class_type = _Arg0; \
using _Guide_type = enable_if<false>; \
};
_CLASS_DEFINE_CV_REF_NOEXCEPT(_IS_MEMFUNPTR_ELLIPSIS)
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...) > {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
const
> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
volatile
> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
const
volatile
> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...) &> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
const
&> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
volatile
&> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
const
volatile
&> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...) &&> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
const
&&> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
volatile
&&> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
template
<
class
,
class
,
class
...
>
struct
<
(
::*)(
..., ...)
const
volatile
&&> {
using
=
;
typedef
;
using
=
;
using
=
<
false
>; };
#undef _IS_MEMFUNPTR_ELLIPSIS
template
<
class
>
struct
:
{
};
#define _IS_VOID(CV_OPT) \
template<> \
struct is_void<CV_OPT void> \
: true_type \
{ /* determine whether _Ty is void */ \
};
_CLASS_DEFINE_CV(_IS_VOID)
template
<>
struct
<
void
> :
{ };
template
<>
struct
<
const
void
> :
{ };
template
<>
struct
<
volatile
void
> :
{ };
template
<>
struct
<
const
volatile
void
> :
{ };
#undef _IS_VOID
template
<
class
>
_INLINE_VAR constexpr bool is_void_v = is_void<_Ty>::value;
template
<
class
...
>
using
=
void
;
template
<
class
>
struct
{
using
=
const
;
};
template
<
class
>
using
=
const
;
template
<
class
>
struct
{
using
=
volatile
;
};
template
<
class
>
using
=
volatile
;
template
<
class
>
struct
{
using
=
const
volatile
;
};
template
<
class
>
using
=
const
volatile
;
template
<
class
,
class
=
void
>
struct
{
using
=
;
using
=
;
};
template
<
class
>
struct
<
,
<
&>>
{
using
=
&;
using
=
&&;
};
template
<
class
>
struct
{
using
=
typename
<
>::
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
struct
{
using
=
typename
<
>::
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
<
>
()
noexcept
;
template
<
class
>
struct
{
using
=
;
};
template
<
class
,
>
struct
<
[
]>
{
using
=
;
};
template
<
class
>
struct
<
[]>
{
using
=
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
struct
{
using
=
;
};
template
<
class
,
>
struct
<
[
]>
{
using
=
typename
<
>::
;
};
template
<
class
>
struct
<
[]>
{
using
=
typename
<
>::
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
struct
{
using
=
;
};
#define _REMOVE_POINTER(CV_OPT) \
template<class _Ty> \
struct remove_pointer<_Ty * CV_OPT> \
{ /* remove pointer */ \
using type = _Ty; \
};
_CLASS_DEFINE_CV(_REMOVE_POINTER)
template
<
class
>
struct
<
* > {
using
=
; };
template
<
class
>
struct
<
*
const
> {
using
=
; };
template
<
class
>
struct
<
*
volatile
> {
using
=
; };
template
<
class
>
struct
<
*
const
volatile
> {
using
=
; };
#undef _REMOVE_POINTER
template
<
class
>
using
=
typename
<
>::
;
template
<
class
,
class
=
void
>
struct
{
using
=
;
};
template
<
class
>
struct
<
,
<
<
> *>>
{
using
=
<
> *;
};
template
<
class
>
struct
{
using
=
typename
<
>::
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
struct
:
{
};
template
<
class
,
>
struct
<
[
]>
:
{
};
template
<
class
>
struct
<
[]>
:
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_array_v = is_array<_Ty>::value;
template
<
class
>
struct
:
{
};
template
<
class
>
struct
<
&>
:
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Ty>::value;
template
<
class
>
struct
:
{
};
template
<
class
>
struct
<
&&>
:
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Ty>::value;
template
<
class
>
struct
:
{
};
template
<
class
>
struct
<
&>
:
{
};
template
<
class
>
struct
<
&&>
:
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_reference_v = is_reference<_Ty>::value;
template
<
class
,
bool
=
<
>::
::
>
struct
_Is_member_object_pointer
:
{
};
template
<
class
,
class
>
struct
_Is_member_object_pointer
<
::*,
false
>
:
{
using
=
;
};
template
<
class
>
struct
:
_Is_member_object_pointer
<
<
>>::
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Ty>::value;
constexpr
bool
is_member_object_pointer_v
=
<
>::
;
template
<
class
>
struct
is_member_function_pointer
:
<
<
>>::
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Ty>::value;
constexpr
bool
is_member_function_pointer_v
=
is_member_function_pointer
<
>::
;
template
<
class
>
struct
:
{
};
template
<
class
>
struct
<
*>
:
{
};
template
<
class
>
struct
<
*
const
>
:
{
};
template
<
class
>
struct
<
*
volatile
>
:
{
};
template
<
class
>
struct
<
*
const
volatile
>
:
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_pointer_v = is_pointer<_Ty>::value;
template
<
class
>
struct
:
<
<
<
>,
>>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_null_pointer_v = is_same_v<remove_cv_t<_Ty>, nullptr_t>;
template
<
class
>
struct
:
<__is_union(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_union_v = __is_union(_Ty);
constexpr
bool
= __is_union(
);
template
<
class
>
struct
:
<__is_class(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_class_v = __is_class(_Ty);
constexpr
bool
= __is_class(
);
template
<
class
>
struct
:
<
<
>
||
<
>
||
<
>>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_fundamental_v = is_fundamental<_Ty>::value;
template
<
class
>
struct
:
<!
<
>
&& !
<
>
&& !
<
>>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_object_v = is_object<_Ty>::value;
template
<
class
,
class
>
struct
:
<__is_convertible_to(
,
)>
{
};
template
<
class
,
class
>
_INLINE_VAR constexpr bool is_convertible_v = __is_convertible_to(_From, _To);
constexpr
bool
= __is_convertible_to(
,
);
template
<
class
>
struct
:
<__is_enum(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_enum_v = __is_enum(_Ty);
constexpr
bool
= __is_enum(
);
template
<
class
>
struct
:
<!
<
>>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_compound_v = is_compound<_Ty>::value;
template
<
class
>
struct
:
<
is_member_object_pointer_v
<
>
||
is_member_function_pointer_v
<
>>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_member_pointer_v = is_member_pointer<_Ty>::value;
template
<
class
>
struct
:
<
<
>
||
<
>
||
<
>
||
<
>
||
<
>>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_scalar_v = is_scalar<_Ty>::value;
template
<
class
>
struct
:
{
};
template
<
class
>
struct
<
const
>
:
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_const_v = is_const<_Ty>::value;
template
<
class
>
struct
:
{
};
template
<
class
>
struct
<
volatile
>
:
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_volatile_v = is_volatile<_Ty>::value;
template
<
class
>
struct
:
<__is_pod(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_pod_v = __is_pod(_Ty);
constexpr
bool
= __is_pod(
);
template
<
class
>
struct
:
<__is_empty(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_empty_v = __is_empty(_Ty);
constexpr
bool
= __is_empty(
);
template
<
class
>
struct
:
<__is_polymorphic(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_polymorphic_v = __is_polymorphic(_Ty);
constexpr
bool
= __is_polymorphic(
);
template
<
class
>
struct
:
<__is_abstract(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_abstract_v = __is_abstract(_Ty);
constexpr
bool
= __is_abstract(
);
template
<
class
>
struct
:
<__is_final(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_final_v = __is_final(_Ty);
constexpr
bool
= __is_final(
);
template
<
class
>
struct
:
<__is_standard_layout(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_standard_layout_v = __is_standard_layout(_Ty);
constexpr
bool
= __is_standard_layout(
);
template
<
class
>
struct _CXX17_DEPRECATE_IS_LITERAL_TYPE is_literal_type
:
<__is_literal_type(
)>
{
};
#pragma warning(push)
#pragma warning(disable: 4996) // was declared deprecated
#pragma warning(disable:
4996
)
template
<
class
>
_CXX17_DEPRECATE_IS_LITERAL_TYPE _INLINE_VAR constexpr bool is_literal_type_v = __is_literal_type(_Ty);
constexpr
bool
= __is_literal_type(
);
#pragma warning(pop)
template
<
class
>
struct
:
<__is_trivial(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivial_v = __is_trivial(_Ty);
constexpr
bool
= __is_trivial(
);
template
<
class
>
struct
:
<__is_trivially_copyable(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Ty);
constexpr
bool
= __is_trivially_copyable(
);
template
<
class
>
struct
:
<__has_virtual_destructor(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Ty);
constexpr
bool
= __has_virtual_destructor(
);
#if _HAS_CXX17
// STRUCT TEMPLATE has_unique_object_representations
template<class _Ty>
struct has_unique_object_representations
: bool_constant<__has_unique_object_representations(_Ty)>
{ // determine whether _Ty has unique object representations
};
template<class _Ty>
_INLINE_VAR constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Ty);
// STRUCT TEMPLATE is_aggregate
template<class _Ty>
struct is_aggregate
: bool_constant<__is_aggregate(_Ty)>
{ // determine whether _Ty is an aggregate
};
template<class _Ty>
_INLINE_VAR constexpr bool is_aggregate_v = __is_aggregate(_Ty);
#endif /* _HAS_CXX17 */
template
<
class
,
class
...
>
struct
:
<__is_constructible(
,
...)>
{
};
template
<
class
,
class
...
>
_INLINE_VAR constexpr bool is_constructible_v = __is_constructible(_Ty, _Args...);
constexpr
bool
= __is_constructible(
,
...);
template
<
class
>
struct
:
<__is_constructible(
,
<
const
>)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_copy_constructible_v = __is_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
constexpr
bool
= __is_constructible(
,
<
const
>);
template
<
class
>
struct
:
<__is_constructible(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_default_constructible_v = __is_constructible(_Ty);
constexpr
bool
is_default_constructible_v
= __is_constructible(
);
template
<
class
,
class
=
void
>
struct
_Is_implicitly_default_constructible
:
{
};
template
<
class
>
void
_Implicitly_default_construct
(
const
&);
template
<
class
>
struct
_Is_implicitly_default_constructible
<
,
<
decltype
(
_Implicitly_default_construct
<
>({}))>>
:
{
};
template
<
class
>
struct
:
<__is_constructible(
,
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_move_constructible_v = __is_constructible(_Ty, _Ty);
constexpr
bool
= __is_constructible(
,
);
template
<
class
,
class
>
struct
:
<__is_assignable(
,
)>
{
};
template
<
class
,
class
>
_INLINE_VAR constexpr bool is_assignable_v = __is_assignable(_To, _From);
constexpr
bool
= __is_assignable(
,
);
template
<
class
>
struct
:
<__is_assignable(
<
>,
<
const
>)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_copy_assignable_v =
__is_assignable(
<
>,
<
const
>);
template
<
class
>
struct
:
<__is_assignable(
<
>,
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_move_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, _Ty);
constexpr
bool
= __is_assignable(
<
>,
);
template
<
class
>
struct
:
<__is_destructible(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_destructible_v = __is_destructible(_Ty);
constexpr
bool
= __is_destructible(
);
template
<
class
,
class
...
>
struct
is_trivially_constructible
:
<__is_trivially_constructible(
,
...)>
{
};
template
<
class
,
class
...
>
_INLINE_VAR constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Ty, _Args...);
constexpr
bool
is_trivially_constructible_v
= __is_trivially_constructible(
,
...);
template
<
class
>
struct
is_trivially_copy_constructible
:
<__is_trivially_constructible(
,
<
const
>)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivially_copy_constructible_v =
constexpr
bool
is_trivially_copy_constructible_v
=
__is_trivially_constructible(
,
<
const
>);
template
<
class
>
struct
is_trivially_default_constructible
:
<__is_trivially_constructible(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Ty);
constexpr
bool
is_trivially_default_constructible_v
= __is_trivially_constructible(
);
template
<
class
>
struct
is_trivially_move_constructible
:
<__is_trivially_constructible(
,
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Ty, _Ty);
constexpr
bool
is_trivially_move_constructible_v
= __is_trivially_constructible(
,
);
template
<
class
,
class
>
struct
:
<__is_trivially_assignable(
,
)>
{
};
template
<
class
,
class
>
_INLINE_VAR constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_To, _From);
constexpr
bool
is_trivially_assignable_v
= __is_trivially_assignable(
,
);
template
<
class
>
struct
is_trivially_copy_assignable
:
<__is_trivially_assignable(
<
>,
<
const
>)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivially_copy_assignable_v =
constexpr
bool
is_trivially_copy_assignable_v
=
__is_trivially_assignable(
<
>,
<
const
>);
template
<
class
>
struct
is_trivially_move_assignable
:
<__is_trivially_assignable(
<
>,
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivially_move_assignable_v =
constexpr
bool
is_trivially_move_assignable_v
=
__is_trivially_assignable(
<
>,
);
template
<
class
>
struct
is_trivially_destructible
:
<__is_trivially_destructible(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Ty);
constexpr
bool
is_trivially_destructible_v
= __is_trivially_destructible(
);
template
<
class
,
class
...
>
struct
:
<__is_nothrow_constructible(
,
...)>
{
};
template
<
class
,
class
...
>
_INLINE_VAR constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Ty, _Args...);
constexpr
bool
is_nothrow_constructible_v
= __is_nothrow_constructible(
,
...);
template
<
class
>
struct
is_nothrow_copy_constructible
:
<__is_nothrow_constructible(
,
<
const
>)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_nothrow_copy_constructible_v =
constexpr
bool
is_nothrow_copy_constructible_v
=
__is_nothrow_constructible(
,
<
const
>);
template
<
class
>
struct
is_nothrow_default_constructible
:
<__is_nothrow_constructible(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Ty);
constexpr
bool
is_nothrow_default_constructible_v
= __is_nothrow_constructible(
);
template
<
class
>
struct
is_nothrow_move_constructible
:
<__is_nothrow_constructible(
,
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Ty, _Ty);
constexpr
bool
is_nothrow_move_constructible_v
= __is_nothrow_constructible(
,
);
template
<
class
,
class
>
struct
:
<__is_nothrow_assignable(
,
)>
{
};
template
<
class
,
class
>
_INLINE_VAR constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_To, _From);
constexpr
bool
= __is_nothrow_assignable(
,
);
template
<
class
>
struct
is_nothrow_copy_assignable
:
<__is_nothrow_assignable(
<
>,
<
const
>)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_nothrow_copy_assignable_v =
constexpr
bool
is_nothrow_copy_assignable_v
=
__is_nothrow_assignable(
<
>,
<
const
>);
template
<
class
>
struct
is_nothrow_move_assignable
:
<__is_nothrow_assignable(
<
>,
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty);
constexpr
bool
is_nothrow_move_assignable_v
= __is_nothrow_assignable(
<
>,
);
template
<
class
>
struct
:
<__is_nothrow_destructible(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_nothrow_destructible_v = __is_nothrow_destructible(_Ty);
constexpr
bool
is_nothrow_destructible_v
= __is_nothrow_destructible(
);
#pragma warning(push)
#pragma warning(disable: 4296) // expression is always false
#pragma warning(disable:
4296
)
template
<
class
,
bool
=
<
>>
struct
{
using
=
<
>;
using
=
<
(-
1
) <
(
0
)>;
using
=
<
(
0
) <
(-
1
)>;
};
#pragma warning(pop)
template
<
class
>
struct
<
,
false
>
{
using
=
typename
<
>::
;
using
=
;
};
template
<
class
>
struct
:
<
>::
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_signed_v = is_signed<_Ty>::value;
template
<
class
>
struct
:
<
>::
{
};
template
<
class
>
_INLINE_VAR constexpr bool is_unsigned_v = is_unsigned<_Ty>::value;
template
<
class
>
using
=
<
<
>
&& !
<
<
>,
bool
>>;
template
<
class
>
struct
{
static_assert
(
<
>::
||
<
>,
"make_signed<T>/make_unsigned<T> require that T shall be a (possibly "
"cv-qualified) integral type or enumeration but not a bool type."
);
using
=
<
<
,
long
,
unsigned
long
>,
long
,
<
sizeof
(
)
1
,
signed
char
,
<
sizeof
(
)
2
,
short
,
<
sizeof
(
)
4
,
int
,
long
long
>>>>;
using
=
<
<
,
long
,
unsigned
long
>,
unsigned
long
,
<
sizeof
(
)
1
,
unsigned
char
,
<
sizeof
(
)
2
,
unsigned
short
,
<
sizeof
(
)
4
,
unsigned
int
,
unsigned
long
long
>>>>;
};
template
<
class
>
struct
<
const
>
{
using
=
const
typename
<
>::
;
using
=
const
typename
<
>::
;
};
template
<
class
>
struct
<
volatile
>
{
using
=
volatile
typename
<
>::
;
using
=
volatile
typename
<
>::
;
};
template
<
class
>
struct
<
const
volatile
>
{
using
=
const
volatile
typename
<
>::
;
using
=
const
volatile
typename
<
>::
;
};
template
<
class
>
struct
{
using
=
typename
<
>::
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
struct
{
using
=
typename
<
>::
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
constexpr
<
>
(
)
{
return
(
static_cast
<
<
>>(
));
}
template
<
class
>
struct
:
<
, alignof(
)>
{
};
template
<
class
>
_INLINE_VAR constexpr size_t alignment_of_v = alignof(_Ty);
#define _FITS(_Ty) _Align <= alignof(_Ty)
#define _NEXT_ALIGN(_Ty) \
using type = typename _Aligned<_Len, _Align, _Ty, _FITS(_Ty)>::type
template
<
class
,
>
union
{
;
char
[
];
};
template
<
,
,
class
,
bool
>
struct
;
template
<
,
,
class
>
struct
<
,
,
,
true
>
{
using
=
<
,
>;
};
template
<
,
>
struct
<
,
,
double
,
false
>
{
#ifdef _ENABLE_EXTENDED_ALIGNED_STORAGE
struct type
{
alignas(_Align) char _Space[_Len];
};
#else /* ^^^ _ENABLE_EXTENDED_ALIGNED_STORAGE / !_ENABLE_EXTENDED_ALIGNED_STORAGE vvv */
#ifndef _DISABLE_EXTENDED_ALIGNED_STORAGE
static_assert
(
<
>,
"You've instantiated std::aligned_storage<Len, Align> with an extended alignment (in other "
"words, Align > alignof(max_align_t)). Before VS 2017 15.8, the member type would "
"non-conformingly have an alignment of only alignof(max_align_t). VS 2017 15.8 was fixed to "
"handle this correctly, but the fix inherently changes layout and breaks binary compatibility "
"(*only* for uses of aligned_storage with extended alignments). "
"Please define either "
"(1) _ENABLE_EXTENDED_ALIGNED_STORAGE to acknowledge that you understand this message and "
"that you actually want a type with an extended alignment, or "
"(2) _DISABLE_EXTENDED_ALIGNED_STORAGE to silence this message and get the old non-conformant "
"behavior."
);
#endif /* !_DISABLE_EXTENDED_ALIGNED_STORAGE */
using
=
<
,
>;
#endif /* _ENABLE_EXTENDED_ALIGNED_STORAGE */
};
template
<
,
>
struct
<
,
,
int
,
false
>
{
_NEXT_ALIGN(double);
using
=
typename
<
,
,
double
,
<= alignof(
double
)>::
;
};
template
<
,
>
struct
<
,
,
short
,
false
>
{
_NEXT_ALIGN(int);
using
=
typename
<
,
,
int
,
<= alignof(
int
)>::
;
};
template
<
,
>
struct
<
,
,
char
,
false
>
{
_NEXT_ALIGN(short);
using
=
typename
<
,
,
short
,
<= alignof(
short
)>::
;
};
template
<
,
= alignof(
)>
struct
{
using type = typename _Aligned<_Len, _Align, char, _FITS(char)>::type;
using
=
typename
<
,
,
char
,
<= alignof(
char
)>::
;
};
#undef _FITS
#undef _NEXT_ALIGN
template
<
,
= alignof(
)>
using
=
typename
<
,
>::
;
template
<
...
>
struct
;
template
<>
struct
<>
:
<
,
0
>
{
};
template
<
>
struct
<
>
:
<
,
>
{
};
template
<
,
,
...
>
struct
<
,
,
...>
:
<(
?
:
),
...>::
{
};
template
<
,
class
...
>
struct
{
static
constexpr
=
<
,
sizeof
(
)...>::
;
static
constexpr
=
<alignof(
)...>::
;
using
=
<
,
>;
};
template
<
,
class
...
>
using
=
typename
<
,
...>::
;
template
<
class
>
struct
{
using
= __underlying_type(
);
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
>
struct
:
<
,
0
>
{
};
template
<
class
,
>
struct
<
[
]>
:
<
,
<
>::
+
1
>
{
};
template
<
class
>
struct
<
[]>
:
<
,
<
>::
+
1
>
{
};
template
<
class
>
_INLINE_VAR constexpr size_t rank_v = rank<_Ty>::value;
template
<
class
,
unsigned
int
>
struct
:
<
,
0
>
{
};
template
<
class
,
>
struct
<
[
],
0
>
:
<
,
>
{
};
template
<
class
,
unsigned
int
,
>
struct
<
[
],
>
:
<
,
-
1
>
{
};
template
<
class
,
unsigned
int
>
struct
<
[],
>
:
<
,
-
1
>
{
};
template
<
class
,
unsigned
int
=
0
>
struct
:
<
,
>
{
};
template
<
class
,
unsigned
int
=
0
>
_INLINE_VAR constexpr size_t extent_v = extent<_Ty, _Ix>::value;
template
<
class
,
class
>
struct
:
<__is_base_of(
,
)>
{
};
template
<
class
,
class
>
_INLINE_VAR constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);
constexpr
bool
= __is_base_of(
,
);
template
<
class
>
struct
{
using
=
<
>;
using
=
<
<
>,
<
<
>>,
<
<
>,
<
>,
<
>>>;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
,
class
,
class
=
void
>
struct
{
};
template
<
class
,
class
>
struct _Decayed_cond_oper<_Ty1, _Ty2, void_t<decltype(false ? _STD declval<_Ty1>() : _STD declval<_Ty2>())>>
struct
<
,
,
<
decltype
(
false
? ::
std
::
<
>() : ::
std
::
<
>())>>
{
using type = decay_t<decltype(false ? _STD declval<_Ty1>() : _STD declval<_Ty2>())>;
using
=
<
decltype
(
false
? ::
std
::
<
>() : ::
std
::
<
>())>;
};
template
<
class
...
>
struct
;
template
<
class
...
>
using
=
typename
<
...>::type;
template
<>
struct
<>
{
};
template
<
class
>
struct
<
>
:
<
,
>
{
};
template
<
class
,
class
,
class
=
<
>,
class
=
<
>>
struct
:
<
,
>
{
};
template
<
class
,
class
>
struct
<
,
,
,
>
:
<
,
>
{
};
template
<
class
,
class
>
struct
<
,
>
:
<
,
>
{
};
template
<
class
,
class
,
class
,
class
...
>
struct
{
};
template
<
class
,
class
,
class
...
>
struct
<
<
<
,
>>,
,
,
...>
:
<
<
,
>,
...>
{
};
template
<
class
,
class
,
class
...
>
struct
<
,
,
...>
:
<
void
,
,
,
...>
{
};
#if _HAS_IDENTITY_STRUCT
template
<
class
>
struct _DEPRECATE_IDENTITY_STRUCT identity
struct
[[deprecated(
"warning STL4003: "
"The non-Standard std::identity struct is deprecated and will be REMOVED. You can "
"define _SILENCE_IDENTITY_STRUCT_DEPRECATION_WARNING to acknowledge that you have received this warning."
)]]
{
using
=
;
const
&
(
const
&
)
const
{
return
(
);
}
};
#endif /* _HAS_IDENTITY_STRUCT */
template
<
class
>
struct
{
using
=
;
};
template
<
class
>
using
=
typename
<
>::
;
template
<
class
,
template
<
class
...>
class
>
_INLINE_VAR constexpr bool _Is_specialization_v = false;
template
<
template
<
class
...>
class
,
class
...
>
_INLINE_VAR constexpr bool _Is_specialization_v<_Template<_Types...>, _Template> = true;
constexpr
bool
<
<
...>,
> =
true
;
template
<
class
,
template
<
class
...>
class
>
struct
:
<
<
,
>>
{};
template
<
class
>
_NODISCARD constexpr _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept
constexpr
&&
(
<
>&
)
noexcept
{
return
(
static_cast
<
&&>(
));
}
template
<
class
>
_NODISCARD constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept
constexpr
&&
(
<
>&&
)
noexcept
{
static_assert
(!
<
>,
"bad forward call"
);
return
(
static_cast
<
&&>(
));
}
template
<
class
>
_NODISCARD constexpr remove_reference_t<_Ty>&&
(
&&
)
noexcept
{
return
(
static_cast
<
<
>&&>(
));
}
template
<
class
>
_NODISCARD constexpr conditional_t<!is_nothrow_move_constructible_v<_Ty> && is_copy_constructible_v<_Ty>,
constexpr
<!
is_nothrow_move_constructible_v
<
> &&
<
>,
const
&,
&&>
(
&
)
noexcept
{
return (_STD move(_Arg));
}
template
<
class
>
class
;
#define _CONCATX(x, y) x ## y
#define _CONCAT(x, y) _CONCATX(x, y)
#define _IMPLEMENT_INVOKE(NAME_PREFIX, CONSTEXPR) \
/* FUNCTION TEMPLATE invoke */ \
struct _CONCAT(NAME_PREFIX, _Invoker_pmf_object) \
{ /* INVOKE a pointer to member function on an object */ \
template<class _Decayed, \
class _Ty1, \
class... _Types2> \
static CONSTEXPR auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2) \
_NOEXCEPT_COND(_NOEXCEPT_OPER((_STD forward<_Ty1>(_Arg1).*_Pmf)(_STD forward<_Types2>(_Args2)...))) \
-> decltype((_STD forward<_Ty1>(_Arg1).*_Pmf)(_STD forward<_Types2>(_Args2)...)) \
{ /* INVOKE a pointer to member function on an object */ \
return ((_STD forward<_Ty1>(_Arg1).*_Pmf)(_STD forward<_Types2>(_Args2)...)); \
} \
}; \
\
struct _CONCAT(NAME_PREFIX, _Invoker_pmf_refwrap) \
{ /* INVOKE a pointer to member function on a reference_wrapper */ \
template<class _Decayed, \
class _Ty1, \
class... _Types2> \
static CONSTEXPR auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2) \
_NOEXCEPT_COND(_NOEXCEPT_OPER((_STD forward<_Ty1>(_Arg1).get().*_Pmf)(_STD forward<_Types2>(_Args2)...))) \
-> decltype((_STD forward<_Ty1>(_Arg1).get().*_Pmf)(_STD forward<_Types2>(_Args2)...)) \
{ /* INVOKE a pointer to member function on a reference_wrapper */ \
return ((_STD forward<_Ty1>(_Arg1).get().*_Pmf)(_STD forward<_Types2>(_Args2)...)); \
} \
}; \
\
struct _CONCAT(NAME_PREFIX, _Invoker_pmf_pointer) \
{ /* INVOKE a pointer to member function on a [smart] pointer */ \
template<class _Decayed, \
class _Ty1, \
class... _Types2> \
static CONSTEXPR auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2) \
_NOEXCEPT_COND(_NOEXCEPT_OPER(((*_STD forward<_Ty1>(_Arg1)).*_Pmf)(_STD forward<_Types2>(_Args2)...))) \
-> decltype(((*_STD forward<_Ty1>(_Arg1)).*_Pmf)(_STD forward<_Types2>(_Args2)...)) \
{ /* INVOKE a pointer to member function on a [smart] pointer */ \
return (((*_STD forward<_Ty1>(_Arg1)).*_Pmf)(_STD forward<_Types2>(_Args2)...)); \
} \
}; \
\
struct _CONCAT(NAME_PREFIX, _Invoker_pmd_object) \
{ /* INVOKE a pointer to member data on an object */ \
template<class _Decayed, \
class _Ty1> \
static CONSTEXPR auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) \
_NOEXCEPT_COND(_NOEXCEPT_OPER(_STD forward<_Ty1>(_Arg1).*_Pmd)) \
-> decltype(_STD forward<_Ty1>(_Arg1).*_Pmd) \
{ /* INVOKE a pointer to member data on an object */ \
return (_STD forward<_Ty1>(_Arg1).*_Pmd); \
} \
}; \
\
struct _CONCAT(NAME_PREFIX, _Invoker_pmd_refwrap) \
{ /* INVOKE a pointer to member data on a reference_wrapper */ \
template<class _Decayed, \
class _Ty1> \
static CONSTEXPR auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) \
_NOEXCEPT_COND(_NOEXCEPT_OPER(_STD forward<_Ty1>(_Arg1).get().*_Pmd)) \
-> decltype(_STD forward<_Ty1>(_Arg1).get().*_Pmd) \
{ /* INVOKE a pointer to member data on a reference_wrapper */ \
return (_STD forward<_Ty1>(_Arg1).get().*_Pmd); \
} \
}; \
\
struct _CONCAT(NAME_PREFIX, _Invoker_pmd_pointer) \
{ /* INVOKE a pointer to member data on a [smart] pointer */ \
template<class _Decayed, \
class _Ty1> \
static CONSTEXPR auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) \
_NOEXCEPT_COND(_NOEXCEPT_OPER((*_STD forward<_Ty1>(_Arg1)).*_Pmd)) \
-> decltype((*_STD forward<_Ty1>(_Arg1)).*_Pmd) \
{ /* INVOKE a pointer to member data on a [smart] pointer */ \
return ((*_STD forward<_Ty1>(_Arg1)).*_Pmd); \
} \
}; \
\
struct _CONCAT(NAME_PREFIX, _Invoker_functor) \
{ /* INVOKE a function object */ \
template<class _Callable, \
class... _Types> \
static CONSTEXPR auto _Call(_Callable&& _Obj, _Types&&... _Args) \
_NOEXCEPT_COND(_NOEXCEPT_OPER(_STD forward<_Callable>(_Obj)(_STD forward<_Types>(_Args)...))) \
-> decltype(_STD forward<_Callable>(_Obj)(_STD forward<_Types>(_Args)...)) \
{ /* INVOKE a function object */ \
return (_STD forward<_Callable>(_Obj)(_STD forward<_Types>(_Args)...)); \
} \
}; \
\
template<class _Callable, \
class _Ty1, \
class _Removed_cvref = remove_cv_t<remove_reference_t<_Callable>>, \
bool _Is_pmf = is_member_function_pointer_v<_Removed_cvref>, \
bool _Is_pmd = is_member_object_pointer_v<_Removed_cvref>> \
struct _CONCAT(NAME_PREFIX, _Invoker1); \
\
template<class _Callable, \
class _Ty1, \
class _Removed_cvref> \
struct _CONCAT(NAME_PREFIX, _Invoker1)<_Callable, _Ty1, _Removed_cvref, true, false> \
: conditional_t<is_base_of_v< \
typename _Is_memfunptr<_Removed_cvref>::_Class_type, \
remove_reference_t<_Ty1>>, \
_CONCAT(NAME_PREFIX, _Invoker_pmf_object), \
conditional_t<_Is_specialization_v<remove_cv_t<remove_reference_t<_Ty1>>, reference_wrapper>, \
_CONCAT(NAME_PREFIX, _Invoker_pmf_refwrap), \
_CONCAT(NAME_PREFIX, _Invoker_pmf_pointer) \
>> \
{ /* pointer to member function */ \
}; \
\
template<class _Callable, \
class _Ty1, \
class _Removed_cvref> \
struct _CONCAT(NAME_PREFIX, _Invoker1)<_Callable, _Ty1, _Removed_cvref, false, true> \
: conditional_t<is_base_of_v< \
typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, \
remove_reference_t<_Ty1>>, \
_CONCAT(NAME_PREFIX, _Invoker_pmd_object), \
conditional_t<_Is_specialization_v<remove_cv_t<remove_reference_t<_Ty1>>, reference_wrapper>, \
_CONCAT(NAME_PREFIX, _Invoker_pmd_refwrap), \
_CONCAT(NAME_PREFIX, _Invoker_pmd_pointer) \
>> \
{ /* pointer to member data */ \
}; \
\
template<class _Callable, \
class _Ty1, \
class _Removed_cvref> \
struct _CONCAT(NAME_PREFIX, _Invoker1)<_Callable, _Ty1, _Removed_cvref, false, false> \
: _CONCAT(NAME_PREFIX, _Invoker_functor) \
{ /* function object */ \
}; \
\
template<class _Callable, \
class... _Types> \
struct _CONCAT(NAME_PREFIX, _Invoker); \
\
template<class _Callable> \
struct _CONCAT(NAME_PREFIX, _Invoker)<_Callable> \
: _CONCAT(NAME_PREFIX, _Invoker_functor) \
{ /* zero arguments */ \
}; \
\
template<class _Callable, \
class _Ty1, \
class... _Types2> \
struct _CONCAT(NAME_PREFIX, _Invoker)<_Callable, _Ty1, _Types2...> \
: _CONCAT(NAME_PREFIX, _Invoker1)<_Callable, _Ty1> \
{ /* one or more arguments */ \
}; \
\
template<class _Callable, \
class... _Types> \
CONSTEXPR auto _CONCAT(NAME_PREFIX, invoke)(_Callable&& _Obj, _Types&&... _Args) \
_NOEXCEPT_COND(_NOEXCEPT_OPER(_CONCAT(NAME_PREFIX, _Invoker)<_Callable, _Types...>::_Call( \
_STD forward<_Callable>(_Obj), _STD forward<_Types>(_Args)...))) \
-> decltype(_CONCAT(NAME_PREFIX, _Invoker)<_Callable, _Types...>::_Call( \
_STD forward<_Callable>(_Obj), _STD forward<_Types>(_Args)...)) \
{ /* INVOKE a callable object */ \
return (_CONCAT(NAME_PREFIX, _Invoker)<_Callable, _Types...>::_Call( \
_STD forward<_Callable>(_Obj), _STD forward<_Types>(_Args)...)); \
}
template
<
class
,
class
...
>
struct
;
template
<
class
,
class
...
>
inline
auto
(
&&
,
&&...
)
_NOEXCEPT_COND(_NOEXCEPT_OPER(_Invoker<_Callable, _Types...>::_Call(
_STD forward<_Callable>(_Obj), _STD forward<_Types>(_Args)...)))
noexcept
(
noexcept
(
<
,
...>::_Call( ::
std
::
<
>(
_Obj
), ::
std
::
<
>(
_Args
)...)))
->
decltype
(
<
,
...>::_Call(
_STD forward<_Callable>(_Obj), _STD forward<_Types>(_Args)...));
::
std
::
<
>(
_Obj
), ::
std
::
<
>(
_Args
)...));
struct
{
};
template
<
class
>
void
(
)
noexcept
;
template
<
class
,
class
,
bool
=
<
,
>>
struct
: bool_constant<_NOEXCEPT_OPER(_Implicitly_convert_to<_To>(_STD declval<_From>()))>
:
<
noexcept
(
<
>(::
std
::
<
>()))>
{
};
template
<
class
,
class
>
struct
<
,
,
false
>
:
{
};
template
<
class
,
class
...
>
struct
{
using
=
;
using
=
;
template
<
class
>
using
=
;
template
<
class
>
using
=
;
};
template
<
class
...
>
struct _Invoke_traits<void_t<decltype(_STD invoke(_STD declval<_Types>()...))>, _Types...>
struct
<
<
decltype
(::
std
::
(::
std
::
<
>()...))>,
...>
{
using type = decltype(_STD invoke(_STD declval<_Types>()...));
using
=
decltype
(::
std
::
(::
std
::
<
>()...));
using
=
;
using _Is_nothrow_invocable = bool_constant<_NOEXCEPT_OPER(_STD invoke(_STD declval<_Types>()...))>;
using
=
<
noexcept
(::
std
::
(::
std
::
<
>()...))>;
template
<
class
>
using
=
<
<
<
>,
<
,
>>>;
template
<
class
>
using
=
<
<
,
<
<
>,
<
,
>>>>;
};
template
<
class
>
struct _CXX17_DEPRECATE_RESULT_OF result_of
{
static_assert
(
<
>,
"result_of<CallableType> is invalid; use "
"result_of<CallableType(zero or more argument types)> instead."
);
};
#define _RESULT_OF(CALL_OPT, X1, X2, X3) \
template<class _Callable, \
class... _Args> \
struct _CXX17_DEPRECATE_RESULT_OF result_of<_Callable CALL_OPT (_Args...)> \
: _Invoke_traits<void, _Callable, _Args...> \
{ /* template to determine result of call operation */ \
};
_NON_MEMBER_CALL(_RESULT_OF, X1, X2, X3)
template
<
class
,
class
...
>
struct
<
__cdecl
(
...)> :
<
void
,
,
...> { };
template
<
class
,
class
...
>
struct
<
__fastcall
(
...)> :
<
void
,
,
...> { };
template
<
class
,
class
...
>
struct
<
__stdcall
(
...)> :
<
void
,
,
...> { };
template
<
class
,
class
...
>
struct
<
__vectorcall
(
...)> :
<
void
,
,
...> { };
#undef _RESULT_OF
#pragma warning(push)
#pragma warning(disable: 4996) // was declared deprecated
#pragma warning(disable:
4996
)
template
<
class
>
using result_of_t _CXX17_DEPRECATE_RESULT_OF = typename result_of<_Ty>::type;
using
=
typename
<
>::type;
#pragma warning(pop)
template
<
class
,
class
...
>
using
=
typename
<
void
,
,
...>::type;
template
<
class
,
class
,
class
...
>
using
=
typename
<
void
,
,
...>::
template
<
>;
template
<
class
,
class
,
class
...
>
struct
:
<
,
,
...>
{
};
#if _HAS_CXX17
// STRUCT TEMPLATE invoke_result
template<class _Callable,
class... _Args>
struct invoke_result
: _Invoke_traits<void, _Callable, _Args...>
{ // determine the result type of invoking _Callable with _Args
};
template<class _Callable,
class... _Args>
using invoke_result_t = typename _Invoke_traits<void, _Callable, _Args...>::type;
// STRUCT TEMPLATE is_invocable
template<class _Callable,
class... _Args>
struct is_invocable
: _Invoke_traits<void, _Callable, _Args...>::_Is_invocable
{ // determines whether _Callable is callable with _Args
};
template<class _Callable,
class... _Args>
_INLINE_VAR constexpr bool is_invocable_v = _Invoke_traits<void, _Callable, _Args...>::_Is_invocable::value;
// STRUCT TEMPLATE is_nothrow_invocable
template<class _Callable,
class... _Args>
struct is_nothrow_invocable
: _Invoke_traits<void, _Callable, _Args...>::_Is_nothrow_invocable
{ // determines whether _Callable is nothrow-callable with _Args
};
template<class _Callable,
class... _Args>
_INLINE_VAR constexpr bool is_nothrow_invocable_v =
_Invoke_traits<void, _Callable, _Args...>::_Is_nothrow_invocable::value;
// STRUCT TEMPLATE is_invocable_r
template<class _Rx,
class _Callable,
class... _Args>
struct is_invocable_r
: _Is_invocable_r_<_Rx, _Callable, _Args...>
{ // determines whether _Callable is callable with _Args and return type _Rx
};
template<class _Rx,
class _Callable,
class... _Args>
_INLINE_VAR constexpr bool is_invocable_r_v = _Is_invocable_r_<_Rx, _Callable, _Args...>::value;
// STRUCT TEMPLATE is_nothrow_invocable_r
template<class _Rx,
class _Callable,
class... _Args>
struct is_nothrow_invocable_r
: _Invoke_traits<void, _Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx>
{ // determines whether _Callable is nothrow-callable with _Args and return type _Rx
};
template<class _Rx,
class _Callable,
class... _Args>
_INLINE_VAR constexpr bool is_nothrow_invocable_r_v =
_Invoke_traits<void, _Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx>::value;
#endif /* _HAS_CXX17 */
template
<
class
,
class
=
void
>
struct
{
};
#pragma warning(push)
#pragma warning(disable: 4996) // was declared deprecated
#pragma warning(disable:
4996
)
template
<
class
>
struct
<
,
<
typename
::result_type>>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef typename _Ty::result_type result_type;
typedef
typename
::result_type
;
};
#pragma warning(pop)
template
<
class
,
class
=
void
>
struct
:
<
>
{
};
#pragma warning(push)
#pragma warning(disable: 4996) // was declared deprecated
#pragma warning(disable:
4996
)
template
<
class
>
struct
<
,
<
typename
::argument_type>>
:
<
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef typename _Ty::argument_type argument_type;
typedef
typename
::argument_type
;
};
#pragma warning(pop)
template
<
class
,
class
=
void
>
struct
:
<
>
{
};
#pragma warning(push)
#pragma warning(disable: 4996) // was declared deprecated
#pragma warning(disable:
4996
)
template
<
class
>
struct
<
,
<
typename
::first_argument_type,
typename
::second_argument_type>>
:
<
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef typename _Ty::first_argument_type first_argument_type;
typedef
typename
::first_argument_type
;
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef typename _Ty::second_argument_type second_argument_type;
typedef
typename
::second_argument_type
;
};
#pragma warning(pop)
template
<
class
>
struct
{
using
=
<
<
>>;
using
=
<
<
>>;
using
=
<
::
::
,
,
<
::
::
,
,
<
>>>;
};
template
<
class
>
void
(
<
&>)
noexcept
;
template
<
class
>
void
(
<
&&>) =
delete
;
struct
_Unique_tag_refwrap_has_ctor_from
{
};
template
<
class
,
class
,
class
=
void
>
struct
:
{
};
template
<
class
,
class
>
struct
<
,
,
<
_Unique_tag_refwrap_has_ctor_from
,
decltype(_Refwrap_ctor_fun<_Ty>(_STD declval<_Uty>()))>>
decltype
(
<
>(::
std
::
<
>()))>>
:
{
};
template
<
class
>
class
:
public
<
>::
{
public
:
static_assert
(
<
> ||
<
>,
"reference_wrapper<T> requires T to be an object type or a function type."
);
using
=
;
template
<
class
,
<
<
<
<
<
<
>>,
>>,
<
,
>>,
int
> =
0
>
(
&&
)
_NOEXCEPT_COND(_NOEXCEPT_OPER(_Refwrap_ctor_fun<_Ty>(_STD declval<_Uty>())))
noexcept
(
noexcept
(
<
>(::
std
::
<
>())))
{
_Ty& _Ref = _STD forward<_Uty>(_Val);
_Ptr = _STD addressof(_Ref);
}
&()
const
noexcept
{
return
(*
);
}
_NODISCARD _Ty& get() const noexcept
{
return
(*
);
}
template
<
class
...
>
auto
(
&&...
)
const
-> decltype(_STD invoke(get(), _STD forward<_Types>(_Args)...))
->
decltype
(::
std
::
(
(), ::
std
::
<
>(
)...))
{
return (_STD invoke(get(), _STD forward<_Types>(_Args)...));
return
(::
std
::
(
(), ::
std
::
<
>(
)...));
}
private
:
*
;
};
#if _HAS_CXX17
template<class _Ty>
reference_wrapper(_Ty&)
-> reference_wrapper<_Ty>;
#endif /* _HAS_CXX17 */
template
<
class
>
_NODISCARD inline reference_wrapper<_Ty> ref(_Ty& _Val) noexcept
{
return
(
<
>(
));
}
template
<
class
>
void
(
const
&&) =
delete
;
template
<
class
>
_NODISCARD inline reference_wrapper<_Ty> ref(reference_wrapper<_Ty> _Val) noexcept
{
return (_STD ref(_Val.get()));
}
template
<
class
>
_NODISCARD inline reference_wrapper<const _Ty> cref(const _Ty& _Val) noexcept
inline
<
const
>
(
const
&
)
noexcept
{
return
(
<
const
>(
));
}
template
<
class
>
void
(
const
&&) =
delete
;
template
<
class
>
_NODISCARD inline reference_wrapper<const _Ty> cref(reference_wrapper<_Ty> _Val) noexcept
inline
<
const
>
(
<
>
)
noexcept
{
return (_STD cref(_Val.get()));
}
template
<
class
>
struct
;
template
<
class
>
struct
;
#if _HAS_CXX17
template<class _Ty,
class = enable_if_t<is_move_constructible_v<_Ty>
&& is_move_assignable_v<_Ty>>> inline
#else /* _HAS_CXX17 */
template
<
class
,
class
=
void
>
inline
#endif /* _HAS_CXX17 */
void
(
&,
&)
_NOEXCEPT_COND(is_nothrow_move_constructible_v<_Ty>
&& is_nothrow_move_assignable_v<_Ty>);
noexcept
(
is_nothrow_move_constructible_v
<
> &&
is_nothrow_move_assignable_v
<
>);
template
<
class
,
,
class
=
<
<
>::value>>
inline
void
(
(&)[
],
(&)[
])
_NOEXCEPT_COND(_Is_nothrow_swappable<_Ty>::value);
template
<
class
,
class
,
class
=
void
>
struct
:
{
};
template
<
class
,
class
>
struct _Swappable_with_helper<_Ty1, _Ty2, void_t<decltype(swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))>>
struct
<
,
,
<
decltype
(
(::
std
::
<
>(), ::
std
::
<
>()))>>
:
{
};
template
<
class
,
class
>
struct
:
<
<
<
,
>,
<
,
>>>
{
};
template
<
class
>
struct
:
<
<
>,
<
>>::
{
};
template
<
class
,
class
>
struct
: bool_constant<_NOEXCEPT_OPER(swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))
:
<
noexcept
(
(::
std
::
<
>(), ::
std
::
<
>()))
&& _NOEXCEPT_OPER(swap(_STD declval<_Ty2>(), _STD declval<_Ty1>()))>
&&
noexcept
(
(::
std
::
<
>(), ::
std
::
<
>()))>
{
};
template
<
class
,
class
>
struct
_Is_nothrow_swappable_with
:
<
<
<
,
>,
<
,
>>>
{
};
template
<
class
>
struct
:
_Is_nothrow_swappable_with
<
<
>,
<
>>::
{
};
#if _HAS_CXX17
// STRUCT TEMPLATE is_swappable_with
template<class _Ty1,
class _Ty2>
struct is_swappable_with
: _Is_swappable_with<_Ty1, _Ty2>::type
{ // Determine if expressions with type and value category _Ty1 and _Ty2
// can be swapped (and vice versa)
};
template<class _Ty1,
class _Ty2>
_INLINE_VAR constexpr bool is_swappable_with_v = is_swappable_with<_Ty1, _Ty2>::value;
// STRUCT TEMPLATE is_swappable
template<class _Ty>
struct is_swappable
: _Is_swappable<_Ty>::type
{ // Determine if _Ty lvalues satisfy is_swappable_with
};
template<class _Ty>
_INLINE_VAR constexpr bool is_swappable_v = is_swappable<_Ty>::value;
// STRUCT TEMPLATE is_nothrow_swappable_with
template<class _Ty1,
class _Ty2>
struct is_nothrow_swappable_with
: _Is_nothrow_swappable_with<_Ty1, _Ty2>::type
{ // Determine if expressions with type and value category _Ty1 and _Ty2
// satisfy is_swappable_with, and can be swapped without emitting exceptions
};
template<class _Ty1,
class _Ty2>
_INLINE_VAR constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Ty1, _Ty2>::value;
// STRUCT TEMPLATE is_nothrow_swappable
template<class _Ty>
struct is_nothrow_swappable
: _Is_nothrow_swappable<_Ty>::type
{ // Determine if _Ty lvalues satisfy is_nothrow_swappable_with
};
template<class _Ty>
_INLINE_VAR constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Ty>::value;
#endif /* _HAS_CXX17 */
namespace
{
void
();
template
<
class
,
class
=
void
>
struct
:
{};
template
<
class
>
struct _Has_ADL_swap<_Ty, void_t<decltype(swap(_STD declval<_Ty&>(), _STD declval<_Ty&>()))>>
struct
<
,
<
decltype
(
(::
std
::
<
&>(), ::
std
::
<
&>()))>>
:
{};
}
using
_Has_ADL_swap_detail
::
;
template
<
class
>
struct
:
<
<
is_trivially_destructible
<
>,
is_trivially_move_constructible
<
>,
is_trivially_move_assignable
<
>,
<
<
>>>>
{
};
template
<
class
>
_INLINE_VAR constexpr bool _Is_trivially_swappable_v = _Is_trivially_swappable<_Ty>::value;
constexpr
bool
_Is_trivially_swappable_v
=
<
>::
;
#define _BITMASK_OPS(_BITMASK) \
_NODISCARD constexpr _BITMASK operator&(_BITMASK _Left, _BITMASK _Right) noexcept \
{ /* return _Left & _Right */ \
using _IntTy = _STD underlying_type_t<_BITMASK>; \
return (static_cast<_BITMASK>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right))); \
} \
\
_NODISCARD constexpr _BITMASK operator|(_BITMASK _Left, _BITMASK _Right) noexcept \
{ /* return _Left | _Right */ \
using _IntTy = _STD underlying_type_t<_BITMASK>; \
return (static_cast<_BITMASK>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right))); \
} \
\
_NODISCARD constexpr _BITMASK operator^(_BITMASK _Left, _BITMASK _Right) noexcept \
{ /* return _Left ^ _Right */ \
using _IntTy = _STD underlying_type_t<_BITMASK>; \
return (static_cast<_BITMASK>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right))); \
} \
\
constexpr _BITMASK& operator&=(_BITMASK& _Left, _BITMASK _Right) noexcept \
{ /* return _Left &= _Right */ \
return (_Left = _Left & _Right); \
} \
\
constexpr _BITMASK& operator|=(_BITMASK& _Left, _BITMASK _Right) noexcept \
{ /* return _Left |= _Right */ \
return (_Left = _Left | _Right); \
} \
\
constexpr _BITMASK& operator^=(_BITMASK& _Left, _BITMASK _Right) noexcept \
{ /* return _Left ^= _Right */ \
return (_Left = _Left ^ _Right); \
} \
\
_NODISCARD constexpr _BITMASK operator~(_BITMASK _Left) noexcept \
{ /* return ~_Left */ \
using _IntTy = _STD underlying_type_t<_BITMASK>; \
return (static_cast<_BITMASK>(~static_cast<_IntTy>(_Left))); \
} \
\
_NODISCARD constexpr bool _Bitmask_includes(_BITMASK _Left, _BITMASK _Elements) noexcept \
{ /* return (_Left & _Elements) != _BITMASK{} */ \
using _IntTy = _STD underlying_type_t<_BITMASK>; /* TRANSITION, VSO#574589 */ \
return (static_cast<_IntTy>(_Left & _Elements) != 0); \
} \
\
_NODISCARD constexpr bool _Bitmask_includes_all(_BITMASK _Left, _BITMASK _Elements) noexcept \
{ /* return (_Left & _Elements) == _Elements */ \
return ((_Left & _Elements) == _Elements); \
}
#if defined(_WIN64)
_INLINE_VAR constexpr size_t _FNV_offset_basis = 14695981039346656037ULL;
_INLINE_VAR constexpr size_t _FNV_prime = 1099511628211ULL;
#else /* defined(_WIN64) */
_INLINE_VAR constexpr size_t _FNV_offset_basis = 2166136261U;
_INLINE_VAR constexpr size_t _FNV_prime = 16777619U;
#endif /* defined(_WIN64) */
_NODISCARD inline size_t _Fnv1a_append_bytes(size_t _Val,
const
unsigned
char
*
const
,
const
)
noexcept
{
for
(
=
0
;
_Idx
; ++
_Idx
)
{
^=
static_cast
<
>(
[
_Idx
]);
*=
_FNV_prime
;
}
return
(
);
}
template
<
class
>
_NODISCARD inline size_t _Fnv1a_append_range(const size_t _Val,
const
*
const
,
const
*
const
)
noexcept
{
static_assert
(
<
>,
"Only trivial types can be directly hashed."
);
const
auto
=
reinterpret_cast
<
const
unsigned
char
*>(
);
const
auto
=
reinterpret_cast
<
const
unsigned
char
*>(
);
return
(
(
,
_Firstb
,
static_cast
<
>(
_Lastb
-
_Firstb
)));
}
template
<
class
>
_NODISCARD inline size_t _Fnv1a_append_value(const size_t _Val, const _Kty& _Keyval) noexcept
inline
(
const
,
const
&
)
noexcept
{
static_assert
(
<
>,
"Only trivial types can be directly hashed."
);
return
(
(
,
&
reinterpret_cast
<
const
unsigned
char
&>(
),
sizeof
(
)));
}
template
<
class
>
_NODISCARD inline size_t _Hash_representation(const _Kty& _Keyval) noexcept
inline
(
const
&
)
noexcept
{
return
(
(
_FNV_offset_basis
,
));
}
template
<
class
>
_NODISCARD inline size_t _Hash_array_representation(
inline
_Hash_array_representation
(
const
*
const
,
const
)
noexcept
{
static_assert
(
<
>,
"Only trivial types can be directly hashed."
);
return
(
(
_FNV_offset_basis
,
reinterpret_cast
<
const
unsigned
char
*>(
),
*
sizeof
(
)));
}
template
<
class
>
struct
;
template
<
class
,
bool
>
struct
_Conditionally_enabled_hash
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Kty argument_type;
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t result_type;
_NODISCARD size_t operator()(const _Kty& _Keyval) const
_NOEXCEPT_COND(_NOEXCEPT_OPER(hash<_Kty>::_Do_hash(_Keyval)))
noexcept
(
noexcept
(
<
>::_Do_hash(
)))
{
return
(
<
>::
(
));
}
};
template
<
class
>
struct
_Conditionally_enabled_hash
<
,
false
>
{
_Conditionally_enabled_hash
() =
delete
;
_Conditionally_enabled_hash
(
const
_Conditionally_enabled_hash
&) =
delete
;
_Conditionally_enabled_hash
(
_Conditionally_enabled_hash
&&) =
delete
;
_Conditionally_enabled_hash
&
(
const
_Conditionally_enabled_hash
&) =
delete
;
_Conditionally_enabled_hash
&
(
_Conditionally_enabled_hash
&&) =
delete
;
};
template
<
class
>
struct
:
_Conditionally_enabled_hash
<
, !
<
> && !
<
>
&& (
<
> ||
<
> ||
<
>)>
{
static
(
const
&
)
noexcept
{
return
(
(
));
}
};
template
<>
struct
<
float
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef float argument_type;
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t result_type;
_NODISCARD size_t operator()(const float _Keyval) const noexcept
(
const
float
)
const
noexcept
{
return
(
(
0.0F
?
0.0F
:
));
}
};
template
<>
struct
<
double
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef double argument_type;
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t result_type;
_NODISCARD size_t operator()(const double _Keyval) const noexcept
(
const
double
)
const
noexcept
{
return
(
(
0.0
?
0.0
:
));
}
};
template
<>
struct
<
long
double
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef long double argument_type;
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t result_type;
_NODISCARD size_t operator()(const long double _Keyval) const noexcept
(
const
long
double
)
const
noexcept
{
return
(
(
0.0L
?
0.0L
:
));
}
};
template
<>
struct
<
>
{
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef nullptr_t argument_type;
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t result_type;
_NODISCARD size_t operator()(nullptr_t) const noexcept
{
void
*
{};
return
(
(
_Null
));
}
};
template
<
class
,
class
=
void
>
struct
:
{
};
template
<
class
>
struct _Is_nothrow_hashable<_Kty, void_t<decltype(hash<_Kty>{}(_STD declval<const _Kty&>()))>>
struct
<
,
<
decltype
(
<
>{}(::
std
::
<
const
&>()))>>
: bool_constant<_NOEXCEPT_OPER(hash<_Kty>{}(_STD declval<const _Kty&>()))>
:
<
noexcept
(
<
>{}
::
std
::
<
const
&>()))>
{
};
#if _HAS_TR1_NAMESPACE
#pragma warning(push)
#pragma warning(disable: 4996) // was declared deprecated
#pragma warning(disable:
4996
)
namespace _DEPRECATE_TR1_NAMESPACE tr1 {
namespace
[[deprecated(
"warning STL4002: "
"The non-Standard std::tr1 namespace and TR1-only machinery are deprecated and will be REMOVED. You can "
"define _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING to acknowledge that you have received this warning."
)]]
{
using _STD aligned_storage;
using _STD has_virtual_destructor;
using _STD integral_constant;
using _STD is_arithmetic;
using _STD is_convertible;
using _STD is_floating_point;
using _STD is_fundamental;
using _STD is_member_function_pointer;
using
::
std
::
is_member_function_pointer
;
using _STD is_member_object_pointer;
using _STD is_member_pointer;
using _STD is_polymorphic;
using _STD make_unsigned;
using _STD remove_all_extents;
using _STD remove_extent;
using _STD remove_pointer;
using _STD remove_reference;
using _STD remove_volatile;
using _STD reference_wrapper;
}
#pragma warning(pop)
#endif /* _HAS_TR1_NAMESPACE */
#define _DEBUGGER_STEP_OVER 15732479 // 0xf00f00 - 1
#define _DEBUGGER_STEP_INTO 16707565 // 0xfeefee - 1
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_INTO
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
_IMPLEMENT_INVOKE(_EMPTY_ARGUMENT, inline)
struct
{
template
<
class
,
class
,
class
...
>
static
inline
auto
(
,
&&
,
&&...
)
noexcept
(
noexcept
((::
std
::
<
>(
).*
)(::
std
::
<
>(
)...))) ->
decltype
((::
std
::
<
>(
).*
)(::
std
::
<
>(
)...)) {
return
((::
std
::
<
>(
).*
)(::
std
::
<
>(
)...)); } };
struct
{
template
<
class
,
class
,
class
...
>
static
inline
auto
(
,
&&
,
&&...
)
noexcept
(
noexcept
((::
std
::
<
>(
).get().*
)(::
std
::
<
>(
)...))) ->
decltype
((::
std
::
<
>(
).get().*
)(::
std
::
<
>(
)...)) {
return
((::
std
::
<
>(
).get().*
)(::
std
::
<
>(
)...)); } };
struct
{
template
<
class
,
class
,
class
...
>
static
inline
auto
(
,
&&
,
&&...
)
noexcept
(
noexcept
(((*::
std
::
<
>(
)).*
)(::
std
::
<
>(
)...))) ->
decltype
(((*::
std
::
<
>(
)).*
)(::
std
::
<
>(
)...)) {
return
(((*::
std
::
<
>(
)).*
)(::
std
::
<
>(
)...)); } };
struct
{
template
<
class
,
class
>
static
inline
auto
(
,
&&
)
noexcept
(
noexcept
(::
std
::
<
>(
).*
)) ->
decltype
(::
std
::
<
>(
).*
) {
return
(::
std
::
<
>(
).*
); } };
struct
{
template
<
class
,
class
>
static
inline
auto
(
,
&&
)
noexcept
(
noexcept
(::
std
::
<
>(
).get().*
)) ->
decltype
(::
std
::
<
>(
).get().*
) {
return
(::
std
::
<
>(
).get().*
); } };
struct
{
template
<
class
,
class
>
static
inline
auto
(
,
&&
)
noexcept
(
noexcept
((*::
std
::
<
>(
)).*
)) ->
decltype
((*::
std
::
<
>(
)).*
) {
return
((*::
std
::
<
>(
)).*
); } };
struct
{
template
<
class
,
class
...
>
static
inline
auto
(
&&
,
&&...
)
noexcept
(
noexcept
(::
std
::
<
>(
)(::
std
::
<
>(
)...))) ->
decltype
(::
std
::
<
>(
)(::
std
::
<
>(
)...)) {
return
(::
std
::
<
>(
)(::
std
::
<
>(
)...)); } };
template
<
class
,
class
,
class
=
<
<
>>,
bool
=
is_member_function_pointer_v
<
>,
bool
=
is_member_object_pointer_v
<
>>
struct
;
template
<
class
,
class
,
class
>
struct
<
,
,
,
true
,
false
> :
<
<
typename
<
>::
,
<
>>,
,
<
<
<
<
>>,
>,
,
>> { };
template
<
class
,
class
,
class
>
struct
<
,
,
,
false
,
true
> :
<
<
typename
_Is_member_object_pointer
<
>::
,
<
>>,
,
<
<
<
<
>>,
>,
,
>> { };
template
<
class
,
class
,
class
>
struct
<
,
,
,
false
,
false
> :
{ };
template
<
class
,
class
...
>
struct
;
template
<
class
>
struct
<
> :
{ };
template
<
class
,
class
,
class
...
>
struct
<
,
,
...> :
<
,
> { };
template
<
class
,
class
...
>
inline
auto
(
&&
,
&&...
)
noexcept
(
noexcept
(
<
,
...>::
( ::
std
::
<
>(
), ::
std
::
<
>(
)...))) ->
decltype
(
<
,
...>::
( ::
std
::
<
>(
), ::
std
::
<
>(
)...)) {
return
(
<
,
...>::
( ::
std
::
<
>(
), ::
std
::
<
>(
)...)); }
#if _HAS_CXX17
// constexpr IMPLEMENTATION OF invoke
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_INTO
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
_IMPLEMENT_INVOKE(_C_, constexpr)
#endif /* _HAS_CXX17 */
#undef _IMPLEMENT_INVOKE
template
<
class
,
bool
=
<
>>
struct
{
};
template
<
class
>
struct
<
,
true
>
{
template
<
class
...
>
static
void
(
&&...
)
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_OVER
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
{
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_INTO
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
_STD invoke(_STD forward<_Valtys>(_Vals)...);
::
std
::
(::
std
::
<
>(
)...);
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_OVER
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
}
};
template
<
class
>
struct
<
,
false
>
{
template
<
class
...
>
static
(
&&...
)
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_OVER
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
{
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_INTO
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
return (_STD invoke(_STD forward<_Valtys>(_Vals)...));
return
(::
std
::
(::
std
::
<
>(
)...));
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_OVER
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
}
};
template
<>
struct
<
,
false
>
{
template
<
class
...
>
static
auto
(
&&...
)
-> decltype(_STD invoke(_STD forward<_Valtys>(_Vals)...))
->
decltype
(::
std
::
(::
std
::
<
>(
)...))
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_OVER
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
{
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_INTO
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
return (_STD invoke(_STD forward<_Valtys>(_Vals)...));
return
(::
std
::
(::
std
::
<
>(
)...));
#ifndef _DEBUG_FUNCTIONAL_MACHINERY
#line _DEBUGGER_STEP_OVER
#endif /* _DEBUG_FUNCTIONAL_MACHINERY */
}
};
#pragma pop_macro("new")
_STL_RESTORE_CLANG_WARNINGS
#pragma warning(pop)
#pragma warning(pop)
#pragma pack(pop)
#endif /* RC_INVOKED */
#endif /* _TYPE_TRAITS_ */
#pragma pack(pop)