[#BloombergLP-bslh-hashAppend-0c]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslh.adoc[bslh]::hashAppend
:relfileprefix: ../../
:mrdocs:

`hashAppend` overloads

== Synopses

Declared in `&lt;bslh&lowbar;hash&period;h&gt;`

Append a filesystem path to a hash algorithm&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class HASHALG&gt;
void
xref:BloombergLP/bslh/hashAppend-08c.adoc[hashAppend](
    HASHALG& hashAlg,
    std::filesystem::path const& path);
----

[.small]#xref:BloombergLP/bslh/hashAppend-08c.adoc[_» more&period;&period;&period;_]#

Pass a sentinel value for `std&colon;&colon;monostate` into the hashing algorithm&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class HASH&lowbar;ALGORITHM&gt;
void
xref:BloombergLP/bslh/hashAppend-04c.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& algorithm,
    std::monostate const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-04c.adoc[_» more&period;&period;&period;_]#

Incorporate the specified `tid` into the specified `algorithm`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class t&lowbar;HASH&lowbar;ALG&gt;
void
xref:BloombergLP/bslh/hashAppend-03c.adoc[hashAppend](
    t&lowbar;HASH&lowbar;ALG& algorithm,
    std::thread::id const& tid);
----

[.small]#xref:BloombergLP/bslh/hashAppend-03c.adoc[_» more&period;&period;&period;_]#

Combine an optional value into the state of a hash algorithm&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE&gt;
void
xref:BloombergLP/bslh/hashAppend-043.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& algorithm,
    std::optional&lt;TYPE&gt; const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-043.adoc[_» more&period;&period;&period;_]#

Invoke `hashAppend`, with the specified `algorithm`, on each element of the specified `input` in order of increasing index as defined by `std&colon;&colon;get`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class&period;&period;&period; TYPE&gt;
void
xref:BloombergLP/bslh/hashAppend-07.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& algorithm,
    std::tuple&lt;TYPE&period;&period;&period;&gt; const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-07.adoc[_» more&period;&period;&period;_]#

Append the active alternative of a `std&colon;&colon;variant` to a hash algorithm&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class&period;&period;&period; TYPE&gt;
void
xref:BloombergLP/bslh/hashAppend-058.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& algorithm,
    std::variant&lt;TYPE&period;&period;&period;&gt; const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-058.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE&gt;
void
xref:BloombergLP/bslh/hashAppend-032.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    TYPE input)
requires (bsl&colon;&colon;is&lowbar;integral&lt;TYPE&gt;&colon;&colon;value &verbar;&verbar;
     bsl&colon;&colon;is&lowbar;pointer&lt;TYPE&gt;&colon;&colon;value  &verbar;&verbar;
     bsl&colon;&colon;is&lowbar;enum&lt;TYPE&gt;&colon;&colon;value)    &amp;&amp;
    !bsl&colon;&colon;is&lowbar;same&lt;TYPE, bool&gt;&colon;&colon;value;
----

[.small]#xref:BloombergLP/bslh/hashAppend-032.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE&gt;
void
xref:BloombergLP/bslh/hashAppend-082.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    TYPE input)
requires bsl&colon;&colon;is&lowbar;floating&lowbar;point&lt;TYPE&gt;&colon;&colon;value &amp;&amp;
   !bsl&colon;&colon;is&lowbar;same&lt;TYPE, long double&gt;&colon;&colon;value;
----

[.small]#xref:BloombergLP/bslh/hashAppend-082.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE&gt;
void
xref:BloombergLP/bslh/hashAppend-086.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    TYPE input)
requires bsl&colon;&colon;is&lowbar;same&lt;TYPE, bool&gt;&colon;&colon;value;
----

[.small]#xref:BloombergLP/bslh/hashAppend-086.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE&gt;
void
xref:BloombergLP/bslh/hashAppend-056.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    TYPE input)
requires bsl&colon;&colon;is&lowbar;same&lt;TYPE, long double&gt;&colon;&colon;value;
----

[.small]#xref:BloombergLP/bslh/hashAppend-056.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    size&lowbar;t N&gt;
void
xref:BloombergLP/bslh/hashAppend-0f6.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    char(& input)[]);
----

[.small]#xref:BloombergLP/bslh/hashAppend-0f6.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    size&lowbar;t N&gt;
void
xref:BloombergLP/bslh/hashAppend-0f1.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    char const(& input)[]);
----

[.small]#xref:BloombergLP/bslh/hashAppend-0f1.adoc[_» more&period;&period;&period;_]#

Pass the specified `input` to the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASHALG,
    class CHAR&lowbar;TYPE,
    class CHAR&lowbar;TRAITS&gt;
void
xref:BloombergLP/bslh/hashAppend-037.adoc[hashAppend](
    HASHALG& hashAlg,
    std::basic&lowbar;string&lowbar;view&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS&gt; const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-037.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE1,
    class TYPE2&gt;
void
xref:BloombergLP/bslh/hashAppend-0f38.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& algorithm,
    std::pair&lt;TYPE1, TYPE2&gt; const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-0f38.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE,
    size&lowbar;t N&gt;
void
xref:BloombergLP/bslh/hashAppend-0b.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    TYPE(& input)[]);
----

[.small]#xref:BloombergLP/bslh/hashAppend-0b.adoc[_» more&period;&period;&period;_]#

Combine the specified `input` into the state of the specified `hashAlg`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE,
    size&lowbar;t N&gt;
void
xref:BloombergLP/bslh/hashAppend-0f39.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlg,
    TYPE const(& input)[]);
----

[.small]#xref:BloombergLP/bslh/hashAppend-0f39.adoc[_» more&period;&period;&period;_]#

Append a `std&colon;&colon;array` to a hashing algorithm&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASH&lowbar;ALGORITHM,
    class TYPE,
    size&lowbar;t SIZE&gt;
void
xref:BloombergLP/bslh/hashAppend-0a.adoc[hashAppend](
    HASH&lowbar;ALGORITHM& hashAlgorithm,
    std::array&lt;TYPE, SIZE&gt; const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-0a.adoc[_» more&period;&period;&period;_]#

Append a `std&colon;&colon;basic&lowbar;string` to a hashing algorithm&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class HASHALG,
    class CHAR&lowbar;TYPE,
    class CHAR&lowbar;TRAITS,
    class ALLOCATOR&gt;
void
xref:BloombergLP/bslh/hashAppend-034.adoc[hashAppend](
    HASHALG& hashAlg,
    std::basic&lowbar;string&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS, ALLOCATOR&gt; const& input);
----

[.small]#xref:BloombergLP/bslh/hashAppend-034.adoc[_» more&period;&period;&period;_]#

== Parameters

[cols="1,4"]
|===
| Name| Description
| *hashAlg*
| hashing algorithm that receives the path hash input
| *path*
| filesystem path whose hash value is appended
| *algorithm*
| hashing algorithm that combines the monostate sentinel
| *input*
| unused `std&colon;&colon;monostate` value being hashed
| *tid*
| thread identifier to convert and append
| *hashAlgorithm*
| hashing algorithm object
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#
