Struct djb_hash::x33a_u32_php::X33aU32Php

pub struct X33aU32Php { /* fields omitted */ }

Implements 32 bit version of one of the original hash functions post by Daniel J. Bernstein but with final OR to set the high bit.

PHP uses a zero hash value to signal an empty hash that will need to be calculated. To insure no actual hash ends up being zero a final step of binary OR is used to always set the high bit.

Examples

use std::hash::Hasher;
use djb_hash::HasherU32;
use djb_hash::x33a_u32_php::*;
let input = "Ez";
let mut hasher = X33aU32Php::new();
hasher.write(&input.as_bytes());
assert_eq!(hasher.finish(), 2153345956u64);
assert_eq!(hasher.finish_u32(), 2153345956u32);

Methods

impl X33aU32Php

pub fn new() -> Self

Creates a new hash using the original 5381 prime number salt value used by DJB.

pub fn new_with_salt(s: u32) -> Self

Creates a new hash using user supplied salt value.

The supplied salt needs to be a prime number. It should have bits in more than just the lower 8 bits but setting any bits past half the size of the hash is of limited use as they are quickly lost during the multiplication stage for long values and tend to because static for very short values. Primes between 16 to 32 bits for 64 bit hashes seem to work best in most cases and between 16 to 24 bits for 32 bit hashes.

Trait Implementations

impl HasherU32 for X33aU32Php

fn finish_u32(&self) -> u32

Returns a 32 bit hash instead of the normal 64 bit one.

impl Hasher for X33aU32Php

fn finish(&self) -> u64

Returns the hash value for the values written so far.

fn write(&mut self, bytes: &[u8])

Writes byte slice to hash.

Does hash * 33 + byte but is implemented as hash << 5 (*32) + hash + byte as this is faster on most processors vs normal multiplication.

fn write_u8(&mut self, i: u8)

Writes a single u8 into this hasher.

fn write_u16(&mut self, i: u16)

Writes a single u16 into this hasher.

fn write_u32(&mut self, i: u32)

Writes a single u32 into this hasher.

fn write_u64(&mut self, i: u64)

Writes a single u64 into this hasher.

fn write_u128(&mut self, i: u128)

Writes a single u128 into this hasher.

fn write_usize(&mut self, i: usize)

Writes a single usize into this hasher.

fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.