#include <cstddef>
#include <cstdlib>
#include <initializer_list>
#include <xtr1common>

Classes
struct	_If< bool, _Ty1, _Ty2 >

struct	_If< true, _Ty1, _Ty2 >

struct	_Always_false< _Ty >

struct	plus< _Ty >

struct	minus< _Ty >

struct	multiplies< _Ty >

struct	equal_to< _Ty >

struct	less< _Ty >

struct	plus< void >

struct	minus< void >

struct	multiplies< void >

struct	equal_to< void >

struct	less< void >

struct	_Bitwise_hash< _Kty >

struct	hash< _Kty >

struct	hash< bool >

struct	hash< char >

struct	hash< signed char >

struct	hash< unsigned char >

struct	hash< char16_t >

struct	hash< char32_t >

struct	hash< short >

struct	hash< unsigned short >

struct	hash< int >

struct	hash< unsigned int >

struct	hash< long >

struct	hash< unsigned long >

struct	hash< long long >

struct	hash< unsigned long long >

struct	hash< float >

struct	hash< double >

struct	hash< long double >

struct	hash< _Ty * >

Macros
#define	_XSTDDEF_

#define	_THROWS(x)

#define	_TRY_BEGIN try {

#define	_CATCH(x) } catch (x) {

#define	_CATCH_ALL } catch (...) {

#define	_CATCH_END }

#define	_RAISE(x) throw x

#define	_RERAISE throw

#define	_THROW0() noexcept

#define	_THROW(x, y) throw x(y)

#define	_THROW_NCEE(x, y) throw x(y)

#define	_EMPTY_ARGUMENT /* for empty macro argument */

#define	_BITMASK(Enum, Ty) typedef Enum Ty

#define	_BITMASK_OPS(Ty)

#define	_IOS_BITMASK(Enum, Ty) typedef int Ty

#define	_IOS_BITMASK_OPS(Ty)

#define	_HASH_SEQ_DEFINED

#define	_EMIT_CDECL(FUNC, OPT1, OPT2) FUNC(__cdecl, OPT1, OPT2)

#define	_EMIT_CLRCALL(FUNC, OPT1, OPT2)

#define	_EMIT_FASTCALL(FUNC, OPT1, OPT2)

#define	_EMIT_STDCALL(FUNC, OPT1, OPT2)

#define	_EMIT_THISCALL(FUNC, OPT1, OPT2)

#define	_EMIT_VECTORCALL(FUNC, OPT1, OPT2)

#define	_NON_MEMBER_CALL(FUNC, CV_REF_OPT)

#define	_NON_MEMBER_CALL_CV(FUNC, REF_OPT)

#define	_NON_MEMBER_CALL_CV_REF(FUNC)

#define	_MEMBER_CALL(FUNC, CV_OPT, REF_OPT)

#define	_MEMBER_CALL_CV(FUNC, REF_OPT)

#define	_MEMBER_CALL_CV_REF(FUNC)

#define	_CLASS_DEFINE_CONST(CLASS)

#define	_CLASS_DEFINE_CV(CLASS)

#define	_CLASS_DEFINE_CV_REF(CLASS)

Functions
_STD_BEGIN size_t	_Hash_seq (const unsigned char *_First, size_t _Count)

template<class _Ty >
_STD_BEGIN constexpr _Ty *	addressof (_Ty &_Val) _NOEXCEPT

template<class _Ptrty >
auto	_Unfancy (_Ptrty _Ptr)

template<class _Ty >
_Ty *	_Unfancy (_Ty *_Ptr)

Macro Definition Documentation

#define _BITMASK	(	Enum,
		Ty
	)	typedef Enum Ty

#define _BITMASK_OPS ( Ty )

#define _CATCH ( x ) } catch (x) {

#define _CATCH_ALL } catch (...) {

#define _CATCH_END }

#define _CLASS_DEFINE_CONST ( CLASS )

Value:

CLASS(_EMPTY_ARGUMENT) \

CLASS(const)

_EMPTY_ARGUMENT

#define _EMPTY_ARGUMENT

Definition: xstddef:77

#define _CLASS_DEFINE_CV ( CLASS )

Value:

CLASS(_EMPTY_ARGUMENT) \
    CLASS(const) \
    CLASS(volatile) \
    CLASS(const volatile)

#define _CLASS_DEFINE_CV_REF ( CLASS )

Value:

CLASS(_EMPTY_ARGUMENT) \
    CLASS(const) \
    CLASS(volatile) \
    CLASS(const volatile) \
    CLASS(&) \
    CLASS(const &) \
    CLASS(volatile &) \
    CLASS(const volatile &) \
    CLASS(&&) \
    CLASS(const &&) \
    CLASS(volatile &&) \
    CLASS(const volatile &&)

#define _EMIT_CDECL	(	FUNC,
		OPT1,
		OPT2
	)	FUNC(__cdecl, OPT1, OPT2)

#define _EMIT_CLRCALL	(	FUNC,
		OPT1,
		OPT2
	)

#define _EMIT_FASTCALL	(	FUNC,
		OPT1,
		OPT2
	)

#define _EMIT_STDCALL	(	FUNC,
		OPT1,
		OPT2
	)

#define _EMIT_THISCALL	(	FUNC,
		OPT1,
		OPT2
	)

#define _EMIT_VECTORCALL	(	FUNC,
		OPT1,
		OPT2
	)

#define _EMPTY_ARGUMENT /* for empty macro argument */

#define _HASH_SEQ_DEFINED

#define _IOS_BITMASK	(	Enum,
		Ty
	)	typedef int Ty

#define _IOS_BITMASK_OPS ( Ty )

#define _MEMBER_CALL	(	FUNC,
		CV_OPT,
		REF_OPT
	)

Value:

_EMIT_CDECL(FUNC, CV_OPT, REF_OPT) \
	_EMIT_CLRCALL(FUNC, CV_OPT, REF_OPT) \
	_EMIT_FASTCALL(FUNC, CV_OPT, REF_OPT) \
	_EMIT_STDCALL(FUNC, CV_OPT, REF_OPT) \
	_EMIT_THISCALL(FUNC, CV_OPT, REF_OPT) \
	_EMIT_VECTORCALL(FUNC, CV_OPT, REF_OPT)

#define _MEMBER_CALL_CV	(	FUNC,
		REF_OPT
	)

Value:

_MEMBER_CALL(FUNC, , REF_OPT) \
	_MEMBER_CALL(FUNC, const, REF_OPT) \
	_MEMBER_CALL(FUNC, volatile, REF_OPT) \
	_MEMBER_CALL(FUNC, const volatile, REF_OPT)

#define _MEMBER_CALL_CV_REF ( FUNC )

Value:

_MEMBER_CALL_CV(FUNC, ) \
	_MEMBER_CALL_CV(FUNC, &) \
	_MEMBER_CALL_CV(FUNC, &&)

#define _NON_MEMBER_CALL	(	FUNC,
		CV_REF_OPT
	)

Value:

_EMIT_CDECL(FUNC, CV_REF_OPT, ) \
	_EMIT_CLRCALL(FUNC, CV_REF_OPT, ) \
	_EMIT_FASTCALL(FUNC, CV_REF_OPT, ) \
	_EMIT_STDCALL(FUNC, CV_REF_OPT, ) \
	_EMIT_VECTORCALL(FUNC, CV_REF_OPT, )

#define _NON_MEMBER_CALL_CV	(	FUNC,
		REF_OPT
	)

Value:

_NON_MEMBER_CALL(FUNC, REF_OPT) \
	_NON_MEMBER_CALL(FUNC, const REF_OPT) \
	_NON_MEMBER_CALL(FUNC, volatile REF_OPT) \
	_NON_MEMBER_CALL(FUNC, const volatile REF_OPT)

#define _NON_MEMBER_CALL_CV_REF ( FUNC )

Value:

_NON_MEMBER_CALL_CV(FUNC, ) \
	_NON_MEMBER_CALL_CV(FUNC, &) \
	_NON_MEMBER_CALL_CV(FUNC, &&)

#define _RAISE ( x ) throw x

#define _RERAISE throw

#define _THROW	(	x,
		y
	)	throw x(y)

#define _THROW0 ( ) noexcept

#define _THROW_NCEE	(	x,
		y
	)	throw x(y)

#define _THROWS ( x )

#define _TRY_BEGIN try {

#define _XSTDDEF_

Function Documentation

_STD_BEGIN size_t _Hash_seq	(	const unsigned char *	_First,
		size_t	_Count
	)

inline

     {   // FNV-1a hash function for bytes in [_First, _First + _Count)
  #if defined(_WIN64)
     static_assert(sizeof(size_t) == 8, "This code is for 64-bit size_t.");
     const size_t _FNV_offset_basis = 14695981039346656037ULL;
     const size_t _FNV_prime = 1099511628211ULL;
 
  #else /* defined(_WIN64) */
     static_assert(sizeof(size_t) == 4, "This code is for 32-bit size_t.");
     const size_t _FNV_offset_basis = 2166136261U;
     const size_t _FNV_prime = 16777619U;
  #endif /* defined(_WIN64) */
 
     size_t _Val = _FNV_offset_basis;
     for (size_t _Next = 0; _Next < _Count; ++_Next)
         {   // fold in another byte
         _Val ^= (size_t)_First[_Next];
         _Val *= _FNV_prime;
         }
     return (_Val);
     }

template<class _Ptrty >

auto _Unfancy ( _Ptrty _Ptr )

inline

     {   // converts from a fancy pointer to a plain pointer
     return (_STD addressof(*_Ptr));
     }

template<class _Ty >

_Ty* _Unfancy ( _Ty * _Ptr )

inline

     {   // do nothing for plain pointers
     return (_Ptr);
     }

template<class _Ty >

_STD_BEGIN constexpr _Ty* addressof ( _Ty & _Val )

inline

     {   // return address of _Val
     return (__builtin_addressof(_Val));
     }

Classes

Macros

Functions

Macro Definition Documentation

Function Documentation