[#BloombergLP-bslh-hashAppend-0c] = xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslh.adoc[bslh]::hashAppend :relfileprefix: ../../ :mrdocs: `hashAppend` overloads == Synopses Declared in `<bslh_hash.h>` Pass the specified `input` path 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 `std::filesystem::path` type as we are not allowed to add overloads directly into namespace `std`. Also note that this will NOT be found by the compiler if HASHALG is not in `BloombergLP::bslh`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class HASHALG> void xref:BloombergLP/bslh/hashAppend-08c.adoc[hashAppend]( HASHALG& hashAlg, std::filesystem::path const& path); ---- [.small]#xref:BloombergLP/bslh/hashAppend-08c.adoc[_» more..._]# Pass the special value corresponding to the `std::monostate` object to the specified `algorithm`. This function integrates with the `bslh` modular hashing system and effectively provides a `bsl::hash` specialization for `std::monostate`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class HASH_ALGORITHM> void xref:BloombergLP/bslh/hashAppend-04c.adoc[hashAppend]( HASH_ALGORITHM& algorithm, std::monostate const&); ---- [.small]#xref:BloombergLP/bslh/hashAppend-04c.adoc[_» more..._]# Invoke `hashAppend` with the specified `algorithm` as the first argument and the result of applying an unspecified function to the specified `tid` as the second argument. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class t_HASH_ALG> void xref:BloombergLP/bslh/hashAppend-03c.adoc[hashAppend]( t_HASH_ALG& algorithm, std::thread::id const& tid); ---- [.small]#xref:BloombergLP/bslh/hashAppend-03c.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE> void xref:BloombergLP/bslh/hashAppend-043.adoc[hashAppend]( HASH_ALGORITHM& algorithm, std::optional<TYPE> const& input); ---- [.small]#xref:BloombergLP/bslh/hashAppend-043.adoc[_» more..._]# Invoke `hashAppend`, with the specified `algorithm`, on each element of the specified `input` in order of increasing index as defined by `std::get`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class... TYPE> void xref:BloombergLP/bslh/hashAppend-07.adoc[hashAppend]( HASH_ALGORITHM& algorithm, std::tuple<TYPE...> const& input); ---- [.small]#xref:BloombergLP/bslh/hashAppend-07.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class... TYPE> void xref:BloombergLP/bslh/hashAppend-058.adoc[hashAppend]( HASH_ALGORITHM& algorithm, std::variant<TYPE...> const& input); ---- [.small]#xref:BloombergLP/bslh/hashAppend-058.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE> void xref:BloombergLP/bslh/hashAppend-032.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, TYPE input) requires (bsl::is_integral<TYPE>::value || bsl::is_pointer<TYPE>::value || bsl::is_enum<TYPE>::value) && !bsl::is_same<TYPE, bool>::value; ---- [.small]#xref:BloombergLP/bslh/hashAppend-032.adoc[_» more..._]# 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 floating point (excluding `long double`) types, because these types need to have +/‐0.0 normalized to 0.0 before they can 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE> void xref:BloombergLP/bslh/hashAppend-082.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, TYPE input) requires bsl::is_floating_point<TYPE>::value && !bsl::is_same<TYPE, long double>::value; ---- [.small]#xref:BloombergLP/bslh/hashAppend-082.adoc[_» more..._]# 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 `bool`s can have multiple `true` representations and need to be normalized before they can be hashed as a continuous sequence of bytes. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE> void xref:BloombergLP/bslh/hashAppend-086.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, TYPE input) requires bsl::is_same<TYPE, bool>::value; ---- [.small]#xref:BloombergLP/bslh/hashAppend-086.adoc[_» more..._]# 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 double`s contain garbage and can not be hashed as a continuous sequence of bytes. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE> void xref:BloombergLP/bslh/hashAppend-056.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, TYPE input) requires bsl::is_same<TYPE, long double>::value; ---- [.small]#xref:BloombergLP/bslh/hashAppend-056.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, size_t N> void xref:BloombergLP/bslh/hashAppend-0f6.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, char(& input)[]); ---- [.small]#xref:BloombergLP/bslh/hashAppend-0f6.adoc[_» more..._]# 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`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, size_t N> void xref:BloombergLP/bslh/hashAppend-0f1.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, char const(& input)[]); ---- [.small]#xref:BloombergLP/bslh/hashAppend-0f1.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASHALG, class CHAR_TYPE, class CHAR_TRAITS> void xref:BloombergLP/bslh/hashAppend-037.adoc[hashAppend]( HASHALG& hashAlg, std::basic_string_view<CHAR_TYPE, CHAR_TRAITS> const& input); ---- [.small]#xref:BloombergLP/bslh/hashAppend-037.adoc[_» more..._]# Invoke the (appropriate) `hashAppend` function, with the specified `algorithm` on the `first` and `second` members, in that order, of the specified `input` pair. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE1, class TYPE2> void xref:BloombergLP/bslh/hashAppend-0f38.adoc[hashAppend]( HASH_ALGORITHM& algorithm, std::pair<TYPE1, TYPE2> const& input); ---- [.small]#xref:BloombergLP/bslh/hashAppend-0f38.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE, size_t N> void xref:BloombergLP/bslh/hashAppend-0b.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, TYPE(& input)[]); ---- [.small]#xref:BloombergLP/bslh/hashAppend-0b.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE, size_t N> void xref:BloombergLP/bslh/hashAppend-0f39.adoc[hashAppend]( HASH_ALGORITHM& hashAlg, TYPE const(& input)[]); ---- [.small]#xref:BloombergLP/bslh/hashAppend-0f39.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASH_ALGORITHM, class TYPE, size_t SIZE> void xref:BloombergLP/bslh/hashAppend-0a.adoc[hashAppend]( HASH_ALGORITHM& hashAlgorithm, std::array<TYPE, SIZE> const& input); ---- [.small]#xref:BloombergLP/bslh/hashAppend-0a.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class HASHALG, class CHAR_TYPE, class CHAR_TRAITS, class ALLOCATOR> void xref:BloombergLP/bslh/hashAppend-034.adoc[hashAppend]( HASHALG& hashAlg, std::basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOCATOR> const& input); ---- [.small]#xref:BloombergLP/bslh/hashAppend-034.adoc[_» more..._]# [.small]#Created with https://www.mrdocs.com[MrDocs]#