crates/vendor/hash32-0.2.1/src/lib.rs - third_party/rust_crates - Git at Google

 //! 32-bit hashing machinery
 //!
 //! # Why?
 //!
 //! Because 32-bit architectures are a thing (e.g. ARM Cortex-M) and you don't want your hashing
 //! function to pull in a bunch of slow 64-bit compiler intrinsics (software implementations of
 //! 64-bit operations).
 //!
 //! # Relationship to `core::hash`
 //!
 //! This crate exposes the same interfaces you'll find in [`core::hash`]: `Hash`, `Hasher`,
 //! `BuildHasher` and `BuildHasherDefault`. The main difference is that `hash32::Hasher::finish`
 //! returns a `u32` instead of `u64`, and the contract of `hash32::Hasher` forbids the implementer
 //! from performing 64-bit (or 128-bit) operations while computing the hash.
 //!
 //! [`core::hash`]: https://doc.rust-lang.org/std/hash/index.html
 //!
 //! # `#[derive(Hash32)]`
 //!
 //! The easiest way to implement `hash32::Hash` for a `struct` is to use the `#[derive(Hash32)]`.
 //!
 //! Note that you need to *explicitly* depend on both `hash32` *and* `hash32_derive`; both crates
 //! must appear in your `Cargo.toml`.
 //!
 //! ``` ignore
 //! use hash32_derive::Hash32;
 //!
 //! #[derive(Hash32)]
 //! struct Ipv4Addr([u8; 4]);
 //!
 //! # fn main() {}
 //!
 //! ```
 //! # Hashers
 //!
 //! This crate provides implementations of the following 32-bit hashing algorithms:
 //!
 //! - [Fowler-Noll-Vo](struct.FnvHasher.html)
 //! - [MurmurHash3](struct.Murmur3Hasher.html)
 //!
 //! # MSRV
 //!
 //! This crate is guaranteed to compile on latest stable Rust. It *might* compile on older
 //! versions but that may change in any new patch release.
 //!
 //! # Future
 //!
 //! In the future we'd like to deprecate this crate in favor of making `core::hash::Hasher` generic
 //! over the size of the computed hash. Below is shown the planned change (but it doesn't work due
 //! to limitations in the `associated_type_defaults` feature):
 //!
 //! ``` ignore
 //! #![feature(associated_type_defaults)]
 //!
 //! trait Hasher {
 //!     type Hash = u64; // default type for backwards compatibility
 //!
 //!     fn finish(&self) -> Self::Hash; // changed
 //!     fn write(&mut self, bytes: &[u8]);
 //! }
 //! ```
 //!
 //! With this change a single `#[derive(Hash)]` would enough to make a type hashable with 32-bit and
 //! 64-bit hashers.

 #![deny(missing_docs)]
 #![deny(warnings)]
 #![no_std]

 extern crate byteorder;

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

 pub use fnv::Hasher as FnvHasher;
 pub use murmur3::Hasher as Murmur3Hasher;

 mod fnv;
 mod murmur3;

 /// See [`core::hash::BuildHasherDefault`][0] for details
 ///
 /// [0]: https://doc.rust-lang.org/core/hash/struct.BuildHasherDefault.html
 pub struct BuildHasherDefault<H>
 {
     _marker: PhantomData<H>,
 }

 impl<H> Default for BuildHasherDefault<H>
 where
     H: Default + Hasher,
 {
     fn default() -> Self {
         BuildHasherDefault {
             _marker: PhantomData,
         }
     }
 }

 impl<H> Clone for BuildHasherDefault<H>
 where
     H: Default + Hasher,
 {
     fn clone(&self) -> Self {
         BuildHasherDefault::default()
     }
 }

 impl<H> PartialEq for BuildHasherDefault<H>
 where
     H: Default + Hasher,
 {
     fn eq(&self, _other: &BuildHasherDefault<H>) -> bool {
         true
     }
 }

 impl<H: Default + Hasher> Eq for BuildHasherDefault<H> {}

 impl<H: Default + Hasher> fmt::Debug for BuildHasherDefault<H> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("BuildHasherDefault")
     }
 }

 impl<H> BuildHasherDefault<H>
 {
     /// `const` constructor
     pub const fn new() -> Self {
         BuildHasherDefault {
             _marker: PhantomData,
         }
     }
 }

 impl<H> BuildHasher for BuildHasherDefault<H>
 where
     H: Default + Hasher,
 {
     type Hasher = H;

     fn build_hasher(&self) -> Self::Hasher {
         H::default()
     }
 }

 /// See [`core::hash::BuildHasher`][0] for details
 ///
 /// [0]: https://doc.rust-lang.org/core/hash/trait.BuildHasher.html
 pub trait BuildHasher {
     /// See [`core::hash::BuildHasher::Hasher`][0]
     ///
     /// [0]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html#associatedtype.Hasher
     type Hasher: Hasher;

     /// See [`core::hash::BuildHasher.build_hasher`][0]
     ///
     /// [0]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html#tymethod.build_hasher
     fn build_hasher(&self) -> Self::Hasher;
 }

 /// See [`core::hash::Hasher`][0] for details
 ///
 /// [0]: https://doc.rust-lang.org/core/hash/trait.Hasher.html
 ///
 /// # Contract
 ///
 /// Implementers of this trait must *not* perform any 64-bit (or 128-bit) operation while computing
 /// the hash.
 pub trait Hasher {
     /// See [`core::hash::Hasher.finish`][0]
     ///
     /// [0]: https://doc.rust-lang.org/std/hash/trait.Hasher.html#tymethod.finish
     fn finish(&self) -> u32;

     /// See [`core::hash::Hasher.write`][0]
     ///
     /// [0]: https://doc.rust-lang.org/std/hash/trait.Hasher.html#tymethod.write
     fn write(&mut self, bytes: &[u8]);
 }

 /// See [`core::hash::Hash`][0] for details
 ///
 /// [0]: https://doc.rust-lang.org/core/hash/trait.Hash.html
 pub trait Hash {
     /// Feeds this value into the given `Hasher`.
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher;

     /// Feeds a slice of this type into the given `Hasher`.
     fn hash_slice<H>(data: &[Self], state: &mut H)
     where
         H: Hasher,
         Self: Sized,
     {
         for piece in data {
             piece.hash(state);
         }
     }
 }

 macro_rules! int {
     ($ty:ident) => {
         impl Hash for $ty {
             fn hash<H>(&self, state: &mut H)
             where
                 H: Hasher,
             {
                 unsafe { state.write(&mem::transmute::<$ty, [u8; mem::size_of::<$ty>()]>(*self)) }
             }

             fn hash_slice<H>(data: &[Self], state: &mut H)
             where
                 H: Hasher,
             {
                 let newlen = data.len() * mem::size_of::<$ty>();
                 let ptr = data.as_ptr() as *const u8;
                 unsafe { state.write(slice::from_raw_parts(ptr, newlen)) }
             }
         }
     };
 }

 int!(i16);
 int!(i32);
 int!(i64);
 int!(i8);
 int!(isize);
 int!(u16);
 int!(u32);
 int!(u64);
 int!(u8);
 int!(usize);

 impl Hash for bool {
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher,
     {
         (*self as u8).hash(state)
     }
 }

 impl Hash for char {
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher,
     {
         (*self as u32).hash(state)
     }
 }

 impl Hash for str {
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher,
     {
         state.write(self.as_bytes());
         state.write(&[0xff]);
     }
 }

 impl<T> Hash for [T]
 where
     T: Hash,
 {
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher,
     {
         self.len().hash(state);
         T::hash_slice(self, state);
     }
 }

 macro_rules! array {
     ($($n:expr),+) => {
         $(
             impl<T> Hash for [T; $n]
                 where
                 T: Hash,
             {
                 fn hash<H>(&self, state: &mut H)
                     where
                     H: Hasher,
                 {
                     Hash::hash(&self[..], state)
                 }
             }
         )+
     };
 }

 array!(
     0, 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
 );

 impl<'a, T: ?Sized + Hash> Hash for &'a T {
     fn hash<H: Hasher>(&self, state: &mut H) {
         (**self).hash(state);
     }
 }

 impl<'a, T: ?Sized + Hash> Hash for &'a mut T {
     fn hash<H: Hasher>(&self, state: &mut H) {
         (**self).hash(state);
     }
 }

 impl Hash for () {
     fn hash<H: Hasher>(&self, _state: &mut H) {}
 }

 macro_rules! tuple {
     ( $($name:ident)+) => (
         impl<$($name: Hash),*> Hash for ($($name,)*)
             where
             last_type!($($name,)+): ?Sized
         {
             #[allow(non_snake_case)]
             fn hash<S: Hasher>(&self, state: &mut S) {
                 let ($(ref $name,)*) = *self;
                 $($name.hash(state);)*
             }
         }
     );
 }

 macro_rules! last_type {
     ($a:ident,) => { $a };
     ($a:ident, $($rest_a:ident,)+) => { last_type!($($rest_a,)+) };
 }

 tuple! { A }
 tuple! { A B }
 tuple! { A B C }
 tuple! { A B C D }
 tuple! { A B C D E }
 tuple! { A B C D E F }
 tuple! { A B C D E F G }
 tuple! { A B C D E F G H }
 tuple! { A B C D E F G H I }
 tuple! { A B C D E F G H I J }
 tuple! { A B C D E F G H I J K }
 tuple! { A B C D E F G H I J K L }

 #[cfg(test)]
 mod test {
     use super::{FnvHasher, Hash, Hasher};
     #[test]
     fn hashes_tuples() {
         let mut h = FnvHasher::default();
         ().hash(&mut h);
         (1_usize,).hash(&mut h);
         (1_u8, 2_i8).hash(&mut h);
         (1_u16, 2_i16, 3_u32).hash(&mut h);
         (1_i32, 2_u64, 3_i64, true).hash(&mut h);
         (1_isize, 'a', "abc", [1u32, 2, 3, 4], false).hash(&mut h);
         h.finish();
     }
 }
	//! 32-bit hashing machinery
	//!
	//! # Why?
	//!
	//! Because 32-bit architectures are a thing (e.g. ARM Cortex-M) and you don't want your hashing
	//! function to pull in a bunch of slow 64-bit compiler intrinsics (software implementations of
	//! 64-bit operations).
	//!
	//! # Relationship to `core::hash`
	//!
	//! This crate exposes the same interfaces you'll find in [`core::hash`]: `Hash`, `Hasher`,
	//! `BuildHasher` and `BuildHasherDefault`. The main difference is that `hash32::Hasher::finish`
	//! returns a `u32` instead of `u64`, and the contract of `hash32::Hasher` forbids the implementer
	//! from performing 64-bit (or 128-bit) operations while computing the hash.
	//!
	//! [`core::hash`]: https://doc.rust-lang.org/std/hash/index.html
	//!
	//! # `#[derive(Hash32)]`
	//!
	//! The easiest way to implement `hash32::Hash` for a `struct` is to use the `#[derive(Hash32)]`.
	//!
	//! Note that you need to explicitly depend on both `hash32` and `hash32_derive`; both crates
	//! must appear in your `Cargo.toml`.
	//!
	//! ``` ignore
	//! use hash32_derive::Hash32;
	//!
	//! #[derive(Hash32)]
	//! struct Ipv4Addr([u8; 4]);
	//!
	//! # fn main() {}
	//!
	//! ```
	//! # Hashers
	//!
	//! This crate provides implementations of the following 32-bit hashing algorithms:
	//!
	//! - [Fowler-Noll-Vo](struct.FnvHasher.html)
	//! - [MurmurHash3](struct.Murmur3Hasher.html)
	//!
	//! # MSRV
	//!
	//! This crate is guaranteed to compile on latest stable Rust. It might compile on older
	//! versions but that may change in any new patch release.
	//!
	//! # Future
	//!
	//! In the future we'd like to deprecate this crate in favor of making `core::hash::Hasher` generic
	//! over the size of the computed hash. Below is shown the planned change (but it doesn't work due
	//! to limitations in the `associated_type_defaults` feature):
	//!
	//! ``` ignore
	//! #![feature(associated_type_defaults)]
	//!
	//! trait Hasher {
	//! type Hash = u64; // default type for backwards compatibility
	//!
	//! fn finish(&self) -> Self::Hash; // changed
	//! fn write(&mut self, bytes: &[u8]);
	//! }
	//! ```
	//!
	//! With this change a single `#[derive(Hash)]` would enough to make a type hashable with 32-bit and
	//! 64-bit hashers.

	#![deny(missing_docs)]
	#![deny(warnings)]
	#![no_std]

	extern crate byteorder;

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

	pub use fnv::Hasher as FnvHasher;
	pub use murmur3::Hasher as Murmur3Hasher;

	mod fnv;
	mod murmur3;

	/// See [`core::hash::BuildHasherDefault`][0] for details
	///
	/// [0]: https://doc.rust-lang.org/core/hash/struct.BuildHasherDefault.html
	pub struct BuildHasherDefault<H>
	{
	_marker: PhantomData<H>,
	}

	impl<H> Default for BuildHasherDefault<H>
	where
	H: Default + Hasher,
	{
	fn default() -> Self {
	BuildHasherDefault {
	_marker: PhantomData,
	}
	}
	}

	impl<H> Clone for BuildHasherDefault<H>
	where
	H: Default + Hasher,
	{
	fn clone(&self) -> Self {
	BuildHasherDefault::default()
	}
	}

	impl<H> PartialEq for BuildHasherDefault<H>
	where
	H: Default + Hasher,
	{
	fn eq(&self, _other: &BuildHasherDefault<H>) -> bool {
	true
	}
	}

	impl<H: Default + Hasher> Eq for BuildHasherDefault<H> {}

	impl<H: Default + Hasher> fmt::Debug for BuildHasherDefault<H> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.pad("BuildHasherDefault")
	}
	}

	impl<H> BuildHasherDefault<H>
	{
	/// `const` constructor
	pub const fn new() -> Self {
	BuildHasherDefault {
	_marker: PhantomData,
	}
	}
	}

	impl<H> BuildHasher for BuildHasherDefault<H>
	where
	H: Default + Hasher,
	{
	type Hasher = H;

	fn build_hasher(&self) -> Self::Hasher {
	H::default()
	}
	}

	/// See [`core::hash::BuildHasher`][0] for details
	///
	/// [0]: https://doc.rust-lang.org/core/hash/trait.BuildHasher.html
	pub trait BuildHasher {
	/// See [`core::hash::BuildHasher::Hasher`][0]
	///
	/// [0]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html#associatedtype.Hasher
	type Hasher: Hasher;

	/// See [`core::hash::BuildHasher.build_hasher`][0]
	///
	/// [0]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html#tymethod.build_hasher
	fn build_hasher(&self) -> Self::Hasher;
	}

	/// See [`core::hash::Hasher`][0] for details
	///
	/// [0]: https://doc.rust-lang.org/core/hash/trait.Hasher.html
	///
	/// # Contract
	///
	/// Implementers of this trait must not perform any 64-bit (or 128-bit) operation while computing
	/// the hash.
	pub trait Hasher {
	/// See [`core::hash::Hasher.finish`][0]
	///
	/// [0]: https://doc.rust-lang.org/std/hash/trait.Hasher.html#tymethod.finish
	fn finish(&self) -> u32;

	/// See [`core::hash::Hasher.write`][0]
	///
	/// [0]: https://doc.rust-lang.org/std/hash/trait.Hasher.html#tymethod.write
	fn write(&mut self, bytes: &[u8]);
	}

	/// See [`core::hash::Hash`][0] for details
	///
	/// [0]: https://doc.rust-lang.org/core/hash/trait.Hash.html
	pub trait Hash {
	/// Feeds this value into the given `Hasher`.
	fn hash<H>(&self, state: &mut H)
	where
	H: Hasher;

	/// Feeds a slice of this type into the given `Hasher`.
	fn hash_slice<H>(data: &[Self], state: &mut H)
	where
	H: Hasher,
	Self: Sized,
	{
	for piece in data {
	piece.hash(state);
	}
	}
	}

	macro_rules! int {
	($ty:ident) => {
	impl Hash for $ty {
	fn hash<H>(&self, state: &mut H)
	where
	H: Hasher,
	{
	unsafe { state.write(&mem::transmute::<$ty, [u8; mem::size_of::<$ty>()]>(*self)) }
	}

	fn hash_slice<H>(data: &[Self], state: &mut H)
	where
	H: Hasher,
	{
	let newlen = data.len() * mem::size_of::<$ty>();
	let ptr = data.as_ptr() as *const u8;
	unsafe { state.write(slice::from_raw_parts(ptr, newlen)) }
	}
	}
	};
	}

	int!(i16);
	int!(i32);
	int!(i64);
	int!(i8);
	int!(isize);
	int!(u16);
	int!(u32);
	int!(u64);
	int!(u8);
	int!(usize);

	impl Hash for bool {
	fn hash<H>(&self, state: &mut H)
	where
	H: Hasher,
	{
	(*self as u8).hash(state)
	}
	}

	impl Hash for char {
	fn hash<H>(&self, state: &mut H)
	where
	H: Hasher,
	{
	(*self as u32).hash(state)
	}
	}

	impl Hash for str {
	fn hash<H>(&self, state: &mut H)
	where
	H: Hasher,
	{
	state.write(self.as_bytes());
	state.write(&[0xff]);
	}
	}

	impl<T> Hash for [T]
	where
	T: Hash,
	{
	fn hash<H>(&self, state: &mut H)
	where
	H: Hasher,
	{
	self.len().hash(state);
	T::hash_slice(self, state);
	}
	}

	macro_rules! array {
	($($n:expr),+) => {
	$(
	impl<T> Hash for [T; $n]
	where
	T: Hash,
	{
	fn hash<H>(&self, state: &mut H)
	where
	H: Hasher,
	{
	Hash::hash(&self[..], state)
	}
	}
	)+
	};
	}

	array!(
	0, 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
	);

	impl<'a, T: ?Sized + Hash> Hash for &'a T {
	fn hash<H: Hasher>(&self, state: &mut H) {
	(**self).hash(state);
	}
	}

	impl<'a, T: ?Sized + Hash> Hash for &'a mut T {
	fn hash<H: Hasher>(&self, state: &mut H) {
	(**self).hash(state);
	}
	}

	impl Hash for () {
	fn hash<H: Hasher>(&self, _state: &mut H) {}
	}

	macro_rules! tuple {
	( $($name:ident)+) => (
	impl<$($name: Hash),> Hash for ($($name,))
	where
	last_type!($($name,)+): ?Sized
	{
	#[allow(non_snake_case)]
	fn hash<S: Hasher>(&self, state: &mut S) {
	let ($(ref $name,)) = self;
	$($name.hash(state);)*
	}
	}
	);
	}

	macro_rules! last_type {
	($a:ident,) => { $a };
	($a:ident, $($rest_a:ident,)+) => { last_type!($($rest_a,)+) };
	}

	tuple! { A }
	tuple! { A B }
	tuple! { A B C }
	tuple! { A B C D }
	tuple! { A B C D E }
	tuple! { A B C D E F }
	tuple! { A B C D E F G }
	tuple! { A B C D E F G H }
	tuple! { A B C D E F G H I }
	tuple! { A B C D E F G H I J }
	tuple! { A B C D E F G H I J K }
	tuple! { A B C D E F G H I J K L }

	#[cfg(test)]
	mod test {
	use super::{FnvHasher, Hash, Hasher};
	#[test]
	fn hashes_tuples() {
	let mut h = FnvHasher::default();
	().hash(&mut h);
	(1_usize,).hash(&mut h);
	(1_u8, 2_i8).hash(&mut h);
	(1_u16, 2_i16, 3_u32).hash(&mut h);
	(1_i32, 2_u64, 3_i64, true).hash(&mut h);
	(1_isize, 'a', "abc", [1u32, 2, 3, 4], false).hash(&mut h);
	h.finish();
	}
	}