digestible 0.2.3

A more dynamic Hash and Hasher trait for Rust
Documentation 
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
118
119
120
121
122
123
124
125
126
127
128
129

use crate::{DigestWriter, Digester, Digestible};
use byteorder::ByteOrder;
use core::hash::Hasher;
macro_rules! map_to_hasher {
    ( $(($call:ident($call_param:ident: $call_type:ty) => $to:ident)),*) => {
        $(
            #[inline(always)]
            fn $call<B: ByteOrder>(&mut self, $call_param: $call_type) {
                self.0.$to($call_param)
            }
        )*
    };

}
/// Allows you to pass a Hasher into a type that excepts a Digester
///
/// ## Example
///
/// ```rust
/// use digestible::hash_digester::DigesterUsingHasher;
/// use digestible::{Digester, Digestible};
/// use std::hash::Hasher;
/// use std::io::Write;
/// #[derive(Digestible)]
/// pub struct MyStruct{
///     pub id: u32,
///     pub name: String,
/// }
///
///     let mut hasher = std::collections::hash_map::DefaultHasher::new();
///     let test = MyStruct{
///         id: 0,
///         name: "Test".to_string(),
///     };
///     let mut my_digest = DigesterUsingHasher(&mut hasher);
///     let result = my_digest.digest::<byteorder::NativeEndian>(&test);
///     println!("{:?}", result);
pub struct DigesterUsingHasher<'h, H: Hasher>(pub &'h mut H);
impl<H: Hasher> DigestWriter for DigesterUsingHasher<'_, H> {
    #[inline(always)]
    fn write(&mut self, bytes: &[u8]) {
        self.0.write(bytes)
    }
    #[inline(always)]
    fn write_u8(&mut self, data: u8) {
        self.0.write_u8(data)
    }
    #[inline(always)]
    fn write_i8(&mut self, data: i8) {
        self.0.write_i8(data)
    }
    map_to_hasher!(
        (write_u16(value: u16) => write_u16), (write_u32(value: u32) => write_u32),
        (write_u64(value: u64) => write_u64), (write_u128(value: u128) => write_u128),
        (write_usize(value: usize) => write_usize),
        (write_i16(value: i16) => write_i16), (write_i32(value: i32) => write_i32),
        (write_i64(value: i64) => write_i64), (write_i128(value: i128) => write_i128),
        (write_isize(value: isize) => write_isize)
    );
}
impl<H: Hasher> Digester for DigesterUsingHasher<'_, H> {
    type Target = u64;
    fn digest<B: ByteOrder>(mut self, data: &impl Digestible) -> Self::Target {
        Digestible::digest::<B, _>(data, &mut self);
        self.0.finish()
    }
}

/// Foreign Types that do not implement Digestible and do not have a way to access the inner data
/// ## Example
/// ```rust
/// use byteorder::ByteOrder;
/// use digestible::hash_digester::HashableHack;
/// use digestible::Digester;
/// use digestible::{DigestWriter, Digestible};
/// use sha2::Digest;
/// use std::hash::Hash;
/// use std::io::Write;
/// #[derive(Hash)]
/// pub struct MyHashableType(u32);
/// impl Digestible for MyHashableType {
///     fn digest<B: ByteOrder, W: DigestWriter>(&self, writer: &mut W) {
///         let mut hashable_hack = HashableHack(writer);
///         <Self as Hash>::hash(self, &mut hashable_hack);
///     }
/// }
///
/// use byteorder::NativeEndian;
/// let test = MyHashableType(0);
/// let mut hasher = sha2::Sha256::new();
/// let result = hasher.digest::<NativeEndian>(&test).to_vec();
/// println!("{:?}", result);
/// ```
pub struct HashableHack<'w, W: crate::DigestWriter>(pub &'w mut W);

macro_rules! map_to_digester {
    ( $(($call:ident($call_param:ident: $call_type:ty) => $to:ident)),*) => {
        $(
            #[inline(always)]
            fn $call(&mut self, $call_param: $call_type) {
                self.0.$to::<byteorder::NativeEndian>($call_param)
            }
        )*
    };

}
impl<W: crate::DigestWriter> Hasher for HashableHack<'_, W> {
    /// Does nothing.
    fn finish(&self) -> u64 {
        0
    }
    fn write(&mut self, bytes: &[u8]) {
        self.0.write(bytes)
    }
    fn write_u8(&mut self, i: u8) {
        self.0.write(&[i])
    }
    fn write_i8(&mut self, i: i8) {
        self.0.write(&[i as u8])
    }
    map_to_digester!(
        (write_u16(value: u16) => write_u16), (write_u32(value: u32) => write_u32),
        (write_u64(value: u64) => write_u64), (write_u128(value: u128) => write_u128),
        (write_usize(value: usize) => write_usize),
        (write_i16(value: i16) => write_i16), (write_i32(value: i32) => write_i32),
        (write_i64(value: i64) => write_i64), (write_i128(value: i128) => write_i128),
        (write_isize(value: isize) => write_isize)
    );
}