use crate::stable_hasher;
-use rustc_serialize::{
- opaque::{self, EncodeResult, FileEncodeResult},
- Decodable, Encodable,
-};
+use rustc_serialize::{Decodable, Encodable};
+use std::convert::TryInto;
use std::hash::{Hash, Hasher};
-use std::mem::{self, MaybeUninit};
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Copy)]
#[repr(C)]
format!("{:x}{:x}", self.0, self.1)
}
- pub fn decode_opaque(decoder: &mut opaque::Decoder<'_>) -> Result<Fingerprint, String> {
- let mut bytes: [MaybeUninit<u8>; 16] = MaybeUninit::uninit_array();
+ #[inline]
+ pub fn to_le_bytes(&self) -> [u8; 16] {
+ // This seems to optimize to the same machine code as
+ // `unsafe { mem::transmute(*k) }`. Well done, LLVM! :)
+ let mut result = [0u8; 16];
+
+ let first_half: &mut [u8; 8] = (&mut result[0..8]).try_into().unwrap();
+ *first_half = self.0.to_le_bytes();
- decoder.read_raw_bytes(&mut bytes)?;
+ let second_half: &mut [u8; 8] = (&mut result[8..16]).try_into().unwrap();
+ *second_half = self.1.to_le_bytes();
- let [l, r]: [u64; 2] = unsafe { mem::transmute(bytes) };
+ result
+ }
- Ok(Fingerprint(u64::from_le(l), u64::from_le(r)))
+ #[inline]
+ pub fn from_le_bytes(bytes: [u8; 16]) -> Fingerprint {
+ Fingerprint(
+ u64::from_le_bytes(bytes[0..8].try_into().unwrap()),
+ u64::from_le_bytes(bytes[8..16].try_into().unwrap()),
+ )
}
}
impl_stable_hash_via_hash!(Fingerprint);
impl<E: rustc_serialize::Encoder> Encodable<E> for Fingerprint {
+ #[inline]
fn encode(&self, s: &mut E) -> Result<(), E::Error> {
- s.encode_fingerprint(self)
+ s.emit_raw_bytes(&self.to_le_bytes()[..])?;
+ Ok(())
}
}
impl<D: rustc_serialize::Decoder> Decodable<D> for Fingerprint {
+ #[inline]
fn decode(d: &mut D) -> Result<Self, D::Error> {
- d.decode_fingerprint()
- }
-}
-
-pub trait FingerprintEncoder: rustc_serialize::Encoder {
- fn encode_fingerprint(&mut self, f: &Fingerprint) -> Result<(), Self::Error>;
-}
-
-pub trait FingerprintDecoder: rustc_serialize::Decoder {
- fn decode_fingerprint(&mut self) -> Result<Fingerprint, Self::Error>;
-}
-
-impl<E: rustc_serialize::Encoder> FingerprintEncoder for E {
- default fn encode_fingerprint(&mut self, _: &Fingerprint) -> Result<(), E::Error> {
- panic!("Cannot encode `Fingerprint` with `{}`", std::any::type_name::<E>());
- }
-}
-
-impl FingerprintEncoder for opaque::Encoder {
- fn encode_fingerprint(&mut self, f: &Fingerprint) -> EncodeResult {
- let bytes: [u8; 16] = unsafe { mem::transmute([f.0.to_le(), f.1.to_le()]) };
- self.emit_raw_bytes(&bytes);
- Ok(())
- }
-}
-
-impl FingerprintEncoder for opaque::FileEncoder {
- fn encode_fingerprint(&mut self, f: &Fingerprint) -> FileEncodeResult {
- let bytes: [u8; 16] = unsafe { mem::transmute([f.0.to_le(), f.1.to_le()]) };
- self.emit_raw_bytes(&bytes)
- }
-}
-
-impl<D: rustc_serialize::Decoder> FingerprintDecoder for D {
- default fn decode_fingerprint(&mut self) -> Result<Fingerprint, D::Error> {
- panic!("Cannot decode `Fingerprint` with `{}`", std::any::type_name::<D>());
- }
-}
-
-impl FingerprintDecoder for opaque::Decoder<'_> {
- fn decode_fingerprint(&mut self) -> Result<Fingerprint, String> {
- Fingerprint::decode_opaque(self)
+ let mut bytes = [0u8; 16];
+ d.read_raw_bytes_into(&mut bytes[..])?;
+ Ok(Fingerprint::from_le_bytes(bytes))
}
}