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

use base64::engine::general_purpose::STANDARD;
use base64::Engine;
use byteorder::{ByteOrder, NativeEndian};
use digestible::digester::Digester;
use digestible::to_base64::IntoBase64;
use digestible::DigestWriter;
use digestible_macros::Digestible;
use sha2::Digest;
use std::collections::hash_map::DefaultHasher;
use std::hash::Hash;
use std::time::Duration;

fn duration_digest_with<B: ByteOrder, W: DigestWriter>(digest: &Duration, writer: &mut W) {
    writer.write_u64::<B>(digest.as_secs());
}

#[derive(Digestible)]
pub struct MyStruct {
    pub id: u32,
    pub name: String,
    #[digestible(skip)]
    pub password: String,
    #[digestible(digest_with = digest_with_hash)]
    pub duration: Duration,
    #[digestible(with = duration_digest_with)]
    pub duration_two: Duration,
}
#[test]
pub fn test() {
    let test = MyStruct {
        id: 0,
        name: "Test".to_string(),
        password: "Test".to_string(),
        duration: Duration::from_secs(10),
        duration_two: Duration::from_secs(10),
    };
    let hasher = sha2::Sha256::new();
    let result = hasher.digest::<NativeEndian>(&test);
    let vec = STANDARD.encode(result.as_slice());

    println!("{:?}", vec);
}
#[test]
pub fn test_base64() {
    let test = MyStruct {
        id: 0,
        name: "Test".to_string(),
        password: "Test".to_string(),
        duration: Duration::from_secs(10),
        duration_two: Duration::from_secs(10),
    };
    let hasher = sha2::Sha256::new().into_base64();
    let result = hasher.digest::<NativeEndian>(&test);
    println!("{:?}", result);
}
#[derive(Digestible)]
pub struct TupleStruct(String);
#[derive(Digestible)]
#[digestible(hash = LittleEndian, type_header = None)]
pub struct NoHeader {
    pub name: String,
    pub id: u32,
    #[digestible(as_ref = u32)]
    pub as_ref_test: Data<u32>,
}
#[derive(Digestible)]
#[digestible(hash = LittleEndian)]
pub enum EnumExample {
    One { username: String },
    Two { name: String },
    None,
    Unit(String),
}
pub struct Data<T>(T);
impl<T> AsRef<T> for Data<T> {
    fn as_ref(&self) -> &T {
        &self.0
    }
}
#[test]
pub fn hash_test() {
    let test = EnumExample::One {
        username: "Test".to_string(),
    };
    let mut default_hasher = DefaultHasher::new();
    test.hash(&mut default_hasher);
}