// This class wraps an implementation of the "SipHash" algorithm in an

// interface that is usable in the modular hashing system in 'bslh'.

private:

// PRIVATE TYPES

typedef bsls::Types::Uint64 Uint64;

// Typedef for a 64-bit integer type used in the hashing algorithm.

// DATA

Uint64 d_v0;

Uint64 d_v1;

Uint64 d_v2;

Uint64 d_v3;

// Stores the intermediate state of the algorithm as values are

// accumulated

union {

Uint64 d_alignment;

// Provides alignment

unsigned char d_buf [8];

// Used to buffer data until we have enough to do a full round of

// computation as specified by the algorithm.

};

size_t d_bufSize;

// The length of the data currently stored in the buffer.

size_t d_totalLength;

// The total length of all data that has been passed into the

// algorithm.

// NOT IMPLEMENTED

SipHashAlgorithm(const SipHashAlgorithm& original); // = delete;

// Do not allow copy construction.

SipHashAlgorithm& operator=(const SipHashAlgorithm& rhs); // = delete;

// Do not allow assignment.

public:

// TYPES

typedef Uint64 result_type;

// Typedef indicating the value type returned by this algorithm.

// CONSTANTS

enum { k_SEED_LENGTH = 16 }; // Seed length in bytes.

// CREATORS

explicit SipHashAlgorithm(const char *seed);

// Create a 'bslh::SipHashAlgorithm', seeded with a 128-bit

// ('k_SEED_LENGTH' bytes) seed pointed to by the specified 'seed'.

// Each bit of the supplied seed will contribute to the final hash

// produced by 'computeHash()'. The behaviour is undefined unless

// 'seed' points to at least 16 bytes of initialized memory. Note that

// if data in 'seed' is not random, all guarantees of security and

// Denial of Service (DoS) protection are void.

//! ~SipHashAlgorithm() = default;

// Destroy this object.

// MANIPULATORS

void operator()(const void *data, size_t numBytes);

// Incorporate the specified 'data', of at least the specified

// 'numBytes', into the internal state of the hashing algorithm. Every

// bit of data incorporated into the internal state of the algorithm

// will contribute to the final hash produced by 'computeHash()'. The

// same hash will be produced regardless of whether a sequence of bytes

// is passed in all at once or through multiple calls to this member

// function. Input where 'numBytes' is 0 will have no effect on the

// internal state of the algorithm. The behaviour is undefined unless

// 'data' points to a valid memory location with at least 'numBytes'

// bytes of initialized memory.

result_type computeHash();

// Return the finalized version of the hash that has been accumulated.

// Note that this changes the internal state of the object, so calling

// 'computeHash()' multiple times in a row will return different

// results, and only the first result returned will match the expected

// result of the algorithm. Also note that a value will be returned,

// even if data has not been passed into 'operator()'