bslh Namespace Reference [Component bslh_defaulthashalgorithm, Component bslh_defaultseededhashalgorithm, Component bslh_fibonaccibadhashwrapper, Component bslh_hash, Component bslh_hashoptional, Component bslh_hashpair, Component bslh_hashvariant, Component bslh_seededhash, Component bslh_seedgenerator, Component bslh_siphashalgorithm, Component bslh_spookyhashalgorithm, Component bslh_spookyhashalgorithmimp, Component bslh_wyhashincrementalalgorithm]

Classes
class	DefaultHashAlgorithm
class	DefaultSeededHashAlgorithm
class	FibonacciBadHashWrapper
class	Hash_AdlWrapper
struct	Hash
struct	SeededHash
class	SeedGenerator
class	SipHashAlgorithm
class	SpookyHashAlgorithm
class	SpookyHashAlgorithmImp
class	WyHashIncrementalAlgorithm
Functions
template<class HASH_ALGORITHM , class TYPE >
bsl::enable_if < (bsl::is_integral< TYPE > ::value||bsl::is_pointer< TYPE > ::value||bsl::is_enum< TYPE > ::value)&&!bsl::is_same< TYPE, bool >::value >::type	hashAppend (HASH_ALGORITHM &hashAlg, TYPE input)
template<class HASH_ALGORITHM , size_t N>
void	hashAppend (HASH_ALGORITHM &hashAlg, char(&input)[N])
template<class HASH_ALGORITHM , size_t N>
void	hashAppend (HASH_ALGORITHM &hashAlg, const char(&input)[N])
template<class HASH_ALGORITHM , class TYPE , size_t N>
void	hashAppend (HASH_ALGORITHM &hashAlg, TYPE(&input)[N])
template<class HASH_ALGORITHM , class TYPE , size_t N>
void	hashAppend (HASH_ALGORITHM &hashAlg, const TYPE(&input)[N])
template<class HASH_ALGORITHM , class TYPE >
void	hashAppend (HASH_ALGORITHM &algorithm, const std::optional< TYPE > &input)
template<class HASH_ALGORITHM , class TYPE1 , class TYPE2 >
void	hashAppend (HASH_ALGORITHM &algorithm, const std::pair< TYPE1, TYPE2 > &input)
template<class HASH_ALGORITHM >
void	hashAppend (HASH_ALGORITHM &algorithm, const std::monostate &)
template<class HASH_ALGORITHM , class... TYPE>
void	hashAppend (HASH_ALGORITHM &algorithm, const std::variant< TYPE...> &input)
template<class HASH_ALGORITHM , class TYPE , size_t SIZE>
void	hashAppend (HASH_ALGORITHM &hashAlgorithm, const std::array< TYPE, SIZE > &input)
template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
BSLS_PLATFORM_AGGRESSIVE_INLINE void	hashAppend (HASHALG &hashAlg, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &input)
template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS >
BSLS_PLATFORM_AGGRESSIVE_INLINE void	hashAppend (HASHALG &hashAlg, const std::basic_string_view< CHAR_TYPE, CHAR_TRAITS > &input)

---

Function Documentation

template<class HASH_ALGORITHM , class TYPE >

bsl::enable_if< bsl::is_same< TYPE, long double >::value >::type bslh::hashAppend	(	HASH_ALGORITHM &	hashAlg,
		TYPE	input
	)			[inline]

Passes the specified input into the specified hashAlg to be combined into the internal state of the algorithm which is used to produce the resulting hash value. Note that the enable_if meta-function is used to enable this hashAppend function for only bool, because bools can have multiple true representations and need to be normalized before they can be hashed as a continuous sequence of bytes.

Passes the specified input into the specified hashAlg to be combined into the internal state of the algorithm which is used to produce the resulting hash value. Note that the enable_if meta-function is used to enable this hashAppend function for only long double, because on some compilers long doubles contain garbage and can not be hashed as a continuous sequence of bytes.

Parameters:

input

Passes the specified input into the specified hashAlg to be combined into the internal state of the algorithm which is used to produce the resulting hash value. Note that the enable_if meta-function is used to enable this hashAppend function for only integral (excluding bool), pointer, and enum types, because these types can all be hashed as a continuous sequence of bytes. Also note that this function is defined inline because MS Visual Studio compilers before 2013 require (some) functions declared using enable_if be in-place inline.

Referenced by hashAppend().

template<class HASH_ALGORITHM , size_t N>

void bslh::hashAppend	(	HASH_ALGORITHM &	hashAlg,
		char(&)	input[N]
	)

Passes the specified input into the specified hashAlg to be combined into the internal state of the algorithm which is used to produce the resulting hash value. Note that the entire char array will be hashed in only one call to hashAlg. Also note that this hashAppend exists because some platforms don't recognize that adding a const qualifier is a better match for arrays than decaying to a pointer and using the hashAppend function for pointers.

template<class HASH_ALGORITHM , size_t N>

void bslh::hashAppend	(	HASH_ALGORITHM &	hashAlg,
		const char(&)	input[N]
	)

Passes the specified input into the specified hashAlg to be combined into the internal state of the algorithm which is used to produce the resulting hash value. Note that the entire char array will be hashed in only one call to hashAlg.

template<class HASH_ALGORITHM , class TYPE , size_t N>

void bslh::hashAppend	(	HASH_ALGORITHM &	hashAlg,
		TYPE(&)	input[N]
	)

Passes the specified input into the specified hashAlg to be combined into the internal state of the algorithm which is used to produce the resulting hash value. Note that the elements in input will be hashed one at a time by calling hashAppend because the (template parameter) TYPE might not be hashable as a contiguous sequence of bytes. Also note that this hashAppend exists because some platforms don't recognize that adding a const qualifier is a better match for arrays than decaying to a pointer and using the hashAppend function for pointers.

template<class HASH_ALGORITHM , class TYPE , size_t N>

void bslh::hashAppend	(	HASH_ALGORITHM &	hashAlg,
		const TYPE(&)	input[N]
	)

Passes the specified input into the specified hashAlg to be combined into the internal state of the algorithm which is used to produce the resulting hash value. Note that the elements in input will be hashed one at a time by calling hashAppend because the (template parameter) TYPE might not be hashable as a contiguous sequence of bytes.

template<class HASH_ALGORITHM , class TYPE >

void bslh::hashAppend	(	HASH_ALGORITHM &	algorithm,
		const std::optional< TYPE > &	input
	)			[inline]

Parameters:

input

If the specified input is engaged, pass its contained value into the specified algorithm to be combined into the internal state of the algorithm that is used to produce the resulting hash value. Otherwise, pass an arbitrary size_t value instead. Note that this behavior (for engaged values) is required by the C++ Standard.

References hashAppend().

template<class HASH_ALGORITHM , class TYPE1 , class TYPE2 >

void bslh::hashAppend	(	HASH_ALGORITHM &	algorithm,
		const std::pair< TYPE1, TYPE2 > &	input
	)

Invoke the (appropriate) hashAppend function, with the specified algorithm on the first and second members, in that order, of the specified input pair.

template<class HASH_ALGORITHM >

void bslh::hashAppend	(	HASH_ALGORITHM &	algorithm,
		const std::monostate &
	)			[inline]

References hashAppend().

template<class HASH_ALGORITHM , class... TYPE>

void bslh::hashAppend	(	HASH_ALGORITHM &	algorithm,
		const std::variant< TYPE...> &	input
	)			[inline]

Parameters:

input

Pass the index of the active variant of the specified input to the specified algorithm, followed by the active value itself, to be combined into the internal state of the algorithm that is used to produce the resulting hash value.

References hashAppend().

template<class HASH_ALGORITHM , class TYPE , size_t SIZE>

void bslh::hashAppend	(	HASH_ALGORITHM &	hashAlgorithm,
		const std::array< TYPE, SIZE > &	input
	)

Pass the specified input to the specified hashAlgorithm hashing algorithm of the (template parameter) type HASH_ALGORITHM. Note that this function violates the BDE coding standard, adding a function for a namespace for a different package, and none of the function parameters are from this package either. This is necessary in order to provide an implementation of bslh::hashAppend for the (native) standard library array type as we are not allowed to add overloads directly into namespace std, and this component essentially provides the interface between bsl and std array types.

template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

BSLS_PLATFORM_AGGRESSIVE_INLINE void bslh::hashAppend	(	HASHALG &	hashAlg,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	input
	)

Pass the specified input string to the specified hashAlg hashing algorithm of the (template parameter) type HASHALG. Note that this function violates the BDE coding standard, adding a function for a namespace for a different package, and none of the function parameters are from this package either. This is necessary in order to provide an implementation of bslh::hashAppend for the (native) standard library string type as we are not allowed to add overloads directly into namespace std, and this component essentially provides the interface between bsl and std string types.

References hashAppend().

template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS >

BSLS_PLATFORM_AGGRESSIVE_INLINE void bslh::hashAppend	(	HASHALG &	hashAlg,
		const std::basic_string_view< CHAR_TYPE, CHAR_TRAITS > &	input
	)

Pass the specified input string to the specified hashAlg hashing algorithm of the (template parameter) type HASHALG. Note that this function violates the BDE coding standard, adding a function for a namespace for a different package, and none of the function parameters are from this package either. This is necessary in order to provide an implementation of bslh::hashAppend for the (native) standard library string_view type as we are not allowed to add overloads directly into namespace std, and this component essentially provides the interface between bsl and std string types.