xstddef File Reference

#include <stdlib.h>
#include <cstddef>
#include <initializer_list>
#include <xtr1common>

Classes
struct	_If< bool, _Ty1, _Ty2 >
struct	_If< true, _Ty1, _Ty2 >
struct	_Always_false< _Ty >
struct	unary_function< _Arg, _Result >
struct	binary_function< _Arg1, _Arg2, _Result >
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< 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 * >

Namespaces
	tr1

Macros
#define	_XSTDDEF_
#define	_X_STD_BEGIN   _STD_BEGIN
#define	_X_STD_END   _STD_END
#define	_XSTD   _STD /* LEAVE SPACE */
#define	_THROWS(x)
#define	_TRY_BEGIN   {{
#define	_CATCH(x)   } if (0) {
#define	_CATCH_ALL   } if (0) {
#define	_CATCH_END   }}
#define	_RAISE(x)   _invoke_watson(0, 0, 0, 0, 0)
#define	_RERAISE
#define	_THROW0()
#define	_THROW1(x)
#define	_THROW(x, y)   x(y)._Raise()
#define	_THROW_NCEE(x, y)   x(y)._Raise()
#define	_EMPTY_ARGUMENT   /* for empty macro argument */
#define	_BITMASK(Enum, Ty)   typedef int Ty
#define	_BITMASK_OPS(Ty)
#define	_HASH_SEQ_DEFINED
#define	_NON_MEMBER_CALL(FUNC, CONST_OPT)   FUNC(__cdecl, CONST_OPT)
#define	_MEMBER_CALL(FUNC, CONST_OPT, CV_OPT)   FUNC(__cdecl, CONST_OPT, CV_OPT)
#define	_NON_MEMBER_CALL_CONST(FUNC)
#define	_MEMBER_CALL_CV(FUNC, CONST_OPT)
#define	_MEMBER_CALL_CONST_CV(FUNC)
#define	_CLASS_DEFINE_CV(CLASS)
#define	_COMMA   , /* for immediate commas in macro parameters */
#define	_Comma   ,
#define	_EX(...)   __VA_ARGS__

Functions
template<class _Ty >
_Ty *	addressof (_Ty &_Val) _NOEXCEPT
_STD_BEGIN size_t	_Hash_seq (const unsigned char *_First, size_t _Count)

Macro Definition Documentation

#define _BITMASK	(		Enum,
			Ty
	)		typedef int Ty

#define _BITMASK_OPS

(

Ty

)

#define _CATCH

(

x

)

} if (0) {

#define _CATCH_ALL   } if (0) {

#define _CATCH_END   }}

#define _CLASS_DEFINE_CV

(

CLASS

)

Value:

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

#define _COMMA   , /* for immediate commas in macro parameters */

#define _Comma   ,

#define _EMPTY_ARGUMENT   /* for empty macro argument */

#define _EX

(

...

)

__VA_ARGS__

#define _HASH_SEQ_DEFINED

#define _MEMBER_CALL	(		FUNC,
			CONST_OPT,
			CV_OPT
	)		FUNC(__cdecl, CONST_OPT, CV_OPT)

#define _MEMBER_CALL_CONST_CV

(

FUNC

)

Value:

_MEMBER_CALL_CV(FUNC, ) \
	_MEMBER_CALL_CV(FUNC, const)

#define _MEMBER_CALL_CV	(		FUNC,
			CONST_OPT
	)

Value:

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

#define _NON_MEMBER_CALL	(		FUNC,
			CONST_OPT
	)		FUNC(__cdecl, CONST_OPT)

#define _NON_MEMBER_CALL_CONST

(

FUNC

)

Value:

_NON_MEMBER_CALL(FUNC, ) \
	_NON_MEMBER_CALL(FUNC, const)

#define _RAISE

(

x

)

_invoke_watson(0, 0, 0, 0, 0)

#define _RERAISE

#define _THROW	(		x,
			y
	)		x(y)._Raise()

_Ret_maybenull_ const _STD nothrow_t & _THROW0

(

)

#define _THROW1

(

x

)

#define _THROW_NCEE	(		x,
			y
	)		x(y)._Raise()

#define _THROWS

(

x

)

#define _TRY_BEGIN   {{

#define _X_STD_BEGIN   _STD_BEGIN

#define _X_STD_END   _STD_END

#define _XSTD   _STD /* LEAVE SPACE */

#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(_M_X64) || defined(_LP64) || defined(__x86_64) || 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(_M_X64), etc. */
    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(_M_X64), etc. */

    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;
        }

 #if defined(_M_X64) || defined(_LP64) || defined(__x86_64) || defined(_WIN64)
    static_assert(sizeof(size_t) == 8, "This code is for 64-bit size_t.");
    _Val ^= _Val >> 32;

 #else /* defined(_M_X64), etc. */
    static_assert(sizeof(size_t) == 4, "This code is for 32-bit size_t.");
 #endif /* defined(_M_X64), etc. */

    return (_Val);
    }

template<class _Ty >

_Ty* addressof ( _Ty &  _Val )

inline

    {   // return address of _Val
    return (reinterpret_cast<_Ty *>(
        (&const_cast<char&>(
        reinterpret_cast<const volatile char&>(_Val)))));
    }