1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! A Rust implementation of the [XXHash] algorithm.
//!
//! [XXHash]: https://github.com/Cyan4973/xxHash
//!
//! ### With a fixed seed
//!
//! ```rust
//! use std::hash::BuildHasherDefault;
//! use std::collections::HashMap;
//! use twox_hash::XxHash64;
//!
//! let mut hash: HashMap<_, _, BuildHasherDefault<XxHash64>> = Default::default();
//! hash.insert(42, "the answer");
//! assert_eq!(hash.get(&42), Some(&"the answer"));
//! ```
//!
//! ### With a random seed
//!
//! ```rust
//! use std::collections::HashMap;
//! use twox_hash::RandomXxHashBuilder64;
//!
//! let mut hash: HashMap<_, _, RandomXxHashBuilder64> = Default::default();
//! hash.insert(42, "the answer");
//! assert_eq!(hash.get(&42), Some(&"the answer"));
//! ```

#![no_std]

extern crate alloc;

#[cfg(test)]
extern crate std;

use core::{marker::PhantomData, mem};

mod sixty_four;
mod thirty_two;
pub mod xxh3;

#[cfg(feature = "std")]
mod std_support;
#[cfg(feature = "std")]
pub use std_support::sixty_four::RandomXxHashBuilder64;
#[cfg(feature = "std")]
pub use std_support::thirty_two::RandomXxHashBuilder32;
#[cfg(feature = "std")]
pub use std_support::xxh3::{
    RandomHashBuilder128 as RandomXxh3HashBuilder128,
    RandomHashBuilder64 as RandomXxh3HashBuilder64,
};

#[cfg(feature = "digest")]
mod digest_support;

#[cfg(feature = "digest_0_9")]
mod digest_0_9_support;

pub use crate::sixty_four::XxHash64;
pub use crate::thirty_two::XxHash32;
pub use crate::xxh3::{Hash128 as Xxh3Hash128, Hash64 as Xxh3Hash64};

/// A backwards compatibility type alias. Consider directly using
/// `XxHash64` instead.
pub type XxHash = XxHash64;

#[cfg(feature = "std")]
/// A backwards compatibility type alias. Consider directly using
/// `RandomXxHashBuilder64` instead.
pub type RandomXxHashBuilder = RandomXxHashBuilder64;

/// An unaligned buffer with iteration support for `UnalignedItem`.
struct UnalignedBuffer<'a, T> {
    buf: &'a [u8],
    phantom: PhantomData<T>,
}

/// Types implementing this trait must be transmutable from a `*const
/// u8` to `*const Self` at any possible alignment.
///
/// The intent is to use this with only primitive integer types (and
/// tightly-packed arrays of those integers).
unsafe trait UnalignedItem {}

unsafe impl UnalignedItem for [u64; 4] {}
unsafe impl UnalignedItem for [u32; 4] {}
unsafe impl UnalignedItem for u64 {}
unsafe impl UnalignedItem for u32 {}

impl<'a, T: UnalignedItem> UnalignedBuffer<'a, T> {
    #[inline]
    fn new(buf: &'a [u8]) -> Self {
        Self {
            buf,
            phantom: PhantomData,
        }
    }

    #[inline]
    fn remaining(&self) -> &[u8] {
        self.buf
    }
}

impl<'a, T: UnalignedItem> Iterator for UnalignedBuffer<'a, T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        let size = mem::size_of::<T>();
        self.buf.get(size..).map(|remaining| {
            // `self.buf` has at least `size` bytes that can be read as `T`.
            let result = unsafe { (self.buf.as_ptr() as *const T).read_unaligned() };
            self.buf = remaining;
            result
        })
    }
}