Struct RapidSecrets 

pub struct RapidSecrets {
    pub seed: u64,
    pub secrets: [u64; 3],
}

Hold the seed and secrets to be used by rapidhash.

RapidSecrets premix the seed and generate a set of other secrets based on the seed that are all used in the hashing process. There are some quality checks on the random values to ensure a reasonable distribution of entropy in the generated secrets.

Constructing this struct is fairly cheap, but unnecessary in the critical path. We therefore recommend instantiating it once and re-using the same instance for any persistent hashing. The seed method is marked const to also do so at compile time.

Minimal HashDoS Protection

We recommend changing the default seed and secrets must be changed to avoid trivial collision attacks. For persistent hashing, you can hard code your own randomized seed at compile time.

use rapidhash::v1::RapidSecrets;
const DEFAULT_SECRETS: RapidSecrets = RapidSecrets::seed(0x123456);  // <-- change this value!

/// Export your chosen rapidhash version and secrets for use throughout your project.
pub fn rapidhash(data: &[u8]) -> u64 {
    rapidhash::v1::rapidhash_v1_seeded(data, &DEFAULT_SECRETS)
}

TODO: serde or serialization support.

Fields

seed: u64

The core rapidhash seed.

secrets: [u64; 3]

The secrets, effectively other seeds used in the hashing process.

Implementations

impl RapidSecrets

pub const fn seed(seed: u64) -> Self

Generate secrets from a given randomized seed.

Note the chosen seed will be pre-mixed to further randomized it, and the secrets will be computed based on the seed.

If compatibility with the C++ implementation is required, use the seed_cpp method instead.

pub const fn reseed(&self) -> Self

Creates a new RapidSecrets instance with a different seed and the same secrets.

This is useful for in-memory hashing, so we can quickly use a different seed for other HashMaps.

pub const fn seed_cpp(seed: u64) -> Self

Creates a new RapidSecrets instance using a seed and secrets that are compatible with the C++ implementation.

Note that these use the default secrets and therefore are liable to some trivial collision attacks, as randomising both the seed and secrets is necessary to provide minimal HashDoS resistance.

Trait Implementations

impl Clone for RapidSecrets

fn clone(&self) -> RapidSecrets

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RapidSecrets

impl Debug for RapidSecrets

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for RapidSecrets

impl Hash for RapidSecrets

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RapidSecrets

fn eq(&self, other: &RapidSecrets) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RapidSecrets