#include <type_traits>

Classes
class	exception

class	bad_exception

class	bad_alloc

class	exception_ptr

class	nested_exception

struct	_With_nested< _Ty, _Uty >

Macros
#define	_EXCEPTION_

#define	_USE_EXCEPTION using _STDEXT exception;

#define	_USE_BAD_EXCEPTION

#define	_USE_EX

Typedefs
typedef void(__cdecl *	unexpected_handler) ()

Functions
_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL	uncaught_exception () _NOEXCEPT

_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL	uncaught_exceptions () _NOEXCEPT

_STDEXT_END _STD_BEGIN _USE_EXCEPTION typedef	void (__cdecl *_Prhand)(const exception &)

terminate_handler __CRTDECL	set_terminate (terminate_handler) _THROW0()

unexpected_handler __CRTDECL	set_unexpected (unexpected_handler) _THROW0()

void __CRTDECL	terminate () _NOEXCEPT

void __CRTDECL	unexpected ()

terminate_handler __CRTDECL	get_terminate () _NOEXCEPT

unexpected_handler __CRTDECL	get_unexpected () _NOEXCEPT

_STD_END _STD_BEGIN _USE_BAD_EXCEPTION _STD_END _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrCreate (_Out_ void *)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrDestroy (_Inout_ void *)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrCopy (_Out_ void , _In_ const void )

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrAssign (_Inout_ void , _In_ const void )

_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL	__ExceptionPtrCompare (_In_ const void , _In_ const void )

_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL	__ExceptionPtrToBool (_In_ const void *)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrSwap (_Inout_ void , _Inout_ void )

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrCurrentException (_Out_ void *)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrRethrow (_In_ const void *)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	__ExceptionPtrCopyException (_Inout_ void , _In_ const void , _In_ const void *)

void	swap (exception_ptr &_Lhs, exception_ptr &_Rhs) throw ()

bool	operator== (const exception_ptr &_Lhs, const exception_ptr &_Rhs) throw ()

bool	operator== (nullptr_t, const exception_ptr &_Rhs) throw ()

bool	operator== (const exception_ptr &_Lhs, nullptr_t) throw ()

bool	operator!= (const exception_ptr &_Lhs, const exception_ptr &_Rhs) throw ()

bool	operator!= (nullptr_t _Lhs, const exception_ptr &_Rhs) throw ()

bool	operator!= (const exception_ptr &_Lhs, nullptr_t _Rhs) throw ()

exception_ptr	current_exception () _NOEXCEPT

void	rethrow_exception (_In_ exception_ptr _Ptr)

template<class _Ex >
void *	__GetExceptionInfo (_Ex)

template<class _Ex >
exception_ptr	make_exception_ptr (_Ex _Except) _NOEXCEPT

template<class _Ty >
void	_Throw_with_nested (_Ty &&_Arg, true_type)

template<class _Ty >
void	_Throw_with_nested (_Ty &&_Arg, false_type)

template<class _Ty >
void	throw_with_nested (_Ty &&_Arg)

template<class _Ty >
void	_Rethrow_if_nested (const _Ty *_Ptr, true_type)

template<class _Ty >
void	_Rethrow_if_nested (const _Ty *, false_type)

template<class _Ty >
void	rethrow_if_nested (const _Ty &_Arg)

Variables
_CRTIMP2_NCEEPURE _Prhand	_Raise_handler

Macro Definition Documentation

#define _EXCEPTION_

#define _USE_BAD_EXCEPTION

Value:

using _STDEXT bad_alloc; \

using _STDEXT bad_exception;

bad_alloc

Definition: exception:160

bad_exception

Definition: exception:139

#define _USE_EX

Value:

using ::set_terminate; using ::terminate_handler; using ::terminate; \

using ::set_unexpected; using ::unexpected_handler; using ::unexpected;

unexpected

void __CRTDECL unexpected()

Definition: exception:212

terminate

void __CRTDECL terminate() _NOEXCEPT

Definition: exception:208

unexpected_handler

void(__cdecl * unexpected_handler)()

Definition: exception:193

set_unexpected

unexpected_handler __CRTDECL set_unexpected(unexpected_handler) _THROW0()

Definition: exception:202

set_terminate

terminate_handler __CRTDECL set_terminate(terminate_handler) _THROW0()

Definition: exception:196

#define _USE_EXCEPTION using _STDEXT exception;

Typedef Documentation

typedef void(__cdecl * unexpected_handler) ()

Function Documentation

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrAssign	(	_Inout_ void *	,
		_In_ const void *
	)

_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrCompare	(	_In_ const void *	,
		_In_ const void *
	)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy	(	_Out_ void *	,
		_In_ const void *
	)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopyException	(	_Inout_ void *	,
		_In_ const void *	,
		_In_ const void *
	)

_STD_END _STD_BEGIN _USE_BAD_EXCEPTION _STD_END _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate ( _Out_ void * )

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCurrentException ( _Out_ void * )

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy ( _Inout_ void * )

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrRethrow ( _In_ const void * )

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap	(	_Inout_ void *	,
		_Inout_ void *
	)

_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrToBool ( _In_ const void * )

template<class _Ex >

void* __GetExceptionInfo ( _Ex )

template<class _Ty >

void _Rethrow_if_nested	(	const _Ty *	_Ptr,
		true_type
	)

inline

     {   // use dynamic_cast
     const auto _Nested = dynamic_cast<const nested_exception *>(_Ptr);
 
     if (_Nested)
         _Nested->rethrow_nested();
     }

template<class _Ty >

void _Rethrow_if_nested	(	const _Ty *	,
		false_type
	)

inline

460 { // can't use dynamic_cast

461 }

template<class _Ty >

void _Throw_with_nested	(	_Ty &&	_Arg,
		true_type
	)

inline

     {   // throw user exception glued to nested_exception
     typedef typename remove_reference<_Ty>::type _Uty;
     typedef _With_nested<_Ty, _Uty> _Glued;
 
     _THROW_NCEE(_Glued, _STD forward<_Ty>(_Arg));
     }

template<class _Ty >

void _Throw_with_nested	(	_Ty &&	_Arg,
		false_type
	)

inline

     {   // throw user exception by itself
     typedef typename decay<_Ty>::type _Decayed;
 
     _THROW_NCEE(_Decayed, _STD forward<_Ty>(_Arg));
     }

exception_ptr current_exception ( )

inline

     {
     return exception_ptr::_Current_exception();
     }

terminate_handler __CRTDECL get_terminate ( )

inline

     {   // get current terminate handler
     return (0);
     }

unexpected_handler __CRTDECL get_unexpected ( )

inline

     {   // get current unexpected handler
     return (0);
     }

template<class _Ex >

exception_ptr make_exception_ptr ( _Ex _Except )

     {
     return exception_ptr::_Copy_exception(_STD addressof(_Except), __GetExceptionInfo(_Except));
     }

bool operator!=	(	const exception_ptr &	_Lhs,
		const exception_ptr &	_Rhs
	)
throw	(
	)

inline

     {
     return !(_Lhs == _Rhs);
     }

bool operator!=	(	nullptr_t	_Lhs,
		const exception_ptr &	_Rhs
	)
throw	(
	)

inline

     {
     return !(_Lhs == _Rhs);
     }

bool operator!=	(	const exception_ptr &	_Lhs,
		nullptr_t	_Rhs
	)
throw	(
	)

inline

     {
     return !(_Lhs == _Rhs);
     }

bool operator==	(	const exception_ptr &	_Lhs,
		const exception_ptr &	_Rhs
	)
throw	(
	)

inline

     {
     return __ExceptionPtrCompare(&_Lhs, &_Rhs);
     }

bool operator==	(	nullptr_t	,
		const exception_ptr &	_Rhs
	)
throw	(
	)

inline

     {
     return !_Rhs;
     }

bool operator==	(	const exception_ptr &	_Lhs,
		nullptr_t
	)
throw	(
	)

inline

     {
     return !_Lhs;
     }

void rethrow_exception ( _In_ exception_ptr _Ptr )

inline

     {
     _Ptr._RethrowException();
     }

template<class _Ty >

void rethrow_if_nested ( const _Ty & _Arg )

inline

     {   // detect nested_exception inheritance
     integral_constant<bool,
         is_polymorphic<_Ty>::value
         && (!is_base_of<nested_exception, _Ty>::value
             || is_convertible<_Ty *, nested_exception *>::value)> _Tag;
 
     _Rethrow_if_nested(_STD addressof(_Arg), _Tag);
     }

terminate_handler __CRTDECL set_terminate ( terminate_handler )

inline

     {   // register a terminate handler
     return 0;
     }

unexpected_handler __CRTDECL set_unexpected ( unexpected_handler )

inline

     {   // register an unexpected handler
     return 0;
     }

void swap	(	exception_ptr &	_Lhs,
		exception_ptr &	_Rhs
	)
throw	(
	)

inline

     {
     __ExceptionPtrSwap(&_Lhs, &_Rhs);
     }

void __CRTDECL terminate ( )

inline

209 { // handle exception termination

210 }

template<class _Ty >

void throw_with_nested ( _Ty && _Arg )

inline

     {   // throw user exception, glued to nested_exception if possible
     typedef typename remove_reference<_Ty>::type _Uty;
 
     integral_constant<bool,
         is_class<_Uty>::value
         && !is_base_of<nested_exception, _Uty>::value
         && !is_final<_Uty>::value> _Tag;
 
     _Throw_with_nested(_STD forward<_Ty>(_Arg), _Tag);
     }

_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL uncaught_exception ( )

_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL uncaught_exceptions ( )

void __CRTDECL unexpected ( )

inline

213 { // handle unexpected exception

214 }

_STDEXT_END _STD_BEGIN typedef void ( __cdecl * _Prhand ) const

Variable Documentation

_CRTIMP2_NCEEPURE _Prhand _Raise_handler

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation