#![stable(feature = "rust1", since = "1.0.0")]
-use fmt;
-use marker;
-use mem;
+use crate::fmt;
+use crate::marker;
#[stable(feature = "rust1", since = "1.0.0")]
#[allow(deprecated)]
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_u16(&mut self, i: u16) {
- self.write(&unsafe { mem::transmute::<_, [u8; 2]>(i) })
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `u32` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_u32(&mut self, i: u32) {
- self.write(&unsafe { mem::transmute::<_, [u8; 4]>(i) })
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `u64` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_u64(&mut self, i: u64) {
- self.write(&unsafe { mem::transmute::<_, [u8; 8]>(i) })
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `u128` into this hasher.
#[inline]
#[stable(feature = "i128", since = "1.26.0")]
fn write_u128(&mut self, i: u128) {
- self.write(&unsafe { mem::transmute::<_, [u8; 16]>(i) })
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `usize` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_usize(&mut self, i: usize) {
- let bytes = unsafe {
- ::slice::from_raw_parts(&i as *const usize as *const u8, mem::size_of::<usize>())
- };
- self.write(bytes);
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `i8` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_i16(&mut self, i: i16) {
- self.write_u16(i as u16)
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `i32` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_i32(&mut self, i: i32) {
- self.write_u32(i as u32)
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `i64` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_i64(&mut self, i: i64) {
- self.write_u64(i as u64)
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `i128` into this hasher.
#[inline]
#[stable(feature = "i128", since = "1.26.0")]
fn write_i128(&mut self, i: i128) {
- self.write_u128(i as u128)
+ self.write(&i.to_ne_bytes())
}
/// Writes a single `isize` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_isize(&mut self, i: isize) {
- self.write_usize(i as usize)
+ self.write(&i.to_ne_bytes())
}
}
#[stable(since = "1.9.0", feature = "core_impl_debug")]
impl<H> fmt::Debug for BuildHasherDefault<H> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.pad("BuildHasherDefault")
}
}
//////////////////////////////////////////////////////////////////////////////
mod impls {
- use mem;
- use slice;
+ use crate::mem;
+ use crate::slice;
+
use super::*;
macro_rules! impl_write {
( $($name:ident)+) => (
#[stable(feature = "rust1", since = "1.0.0")]
- impl<$($name: Hash),*> Hash for ($($name,)*) where last_type!($($name,)+): ?Sized {
+ 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);)*
+ let ($(ref $name,)+) = *self;
+ $($name.hash(state);)+
}
}
);