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

/*!
# Digesting Atomic Types

This module provides a way to digest atomic types.

## Example

```rust
use digestible::{Digestible, Digester};
use sha2::{Digest, Sha256};
use std::sync::atomic::{AtomicU8, AtomicU32, AtomicU16, AtomicU64, AtomicBool, Ordering};
#[derive(Digestible, Default)]
pub struct MyStruct{
    #[digestible(digest_with = atomics::digest_seq_cst)]
    pub u8: AtomicU8,
    #[digestible(digest_with = atomics::digest_relaxed)]
    pub u16: AtomicU16,
    #[digestible(digest_with = atomics::digest_acquire)]
    pub bool: AtomicBool,
}

let mut hasher = sha2::Sha256::new();
let result = hasher.digest_native(&MyStruct::default());
assert_eq!(result.len(), 32);
```
*/
use crate::Digestible;
use core::sync::atomic::Ordering;

/// This is used internally to allow for a simple digest_with implementation
///
/// # Do not implement this trait. This is used internally to allow for a simple digest_with implementation
#[doc(hidden)]
pub trait AtomicType {
    /// The type that is returned when the atomic is loaded
    type TargetType: Digestible;
    /// Loads the atomic with the given ordering
    fn load(&self, order: Ordering) -> Self::TargetType;
}
impl<'a, T: AtomicType> AtomicType for &'a T {
    type TargetType = T::TargetType;

    fn load(&self, order: Ordering) -> Self::TargetType {
        (**self).load(order)
    }
}
#[cfg(feature = "alloc")]
mod has_alloc {
    use crate::digest_with::atomics::AtomicType;
    use alloc::boxed::Box;
    use alloc::rc::Rc;
    use alloc::sync::Arc;
    use core::sync::atomic::Ordering;

    impl<T: AtomicType> AtomicType for Arc<T> {
        type TargetType = T::TargetType;

        fn load(&self, order: Ordering) -> Self::TargetType {
            self.as_ref().load(order)
        }
    }
    impl<T: AtomicType> AtomicType for Rc<T> {
        type TargetType = T::TargetType;

        fn load(&self, order: Ordering) -> Self::TargetType {
            self.as_ref().load(order)
        }
    }
    impl<T: AtomicType> AtomicType for Box<T> {
        type TargetType = T::TargetType;

        fn load(&self, order: Ordering) -> Self::TargetType {
            self.as_ref().load(order)
        }
    }
}
macro_rules! digestible_atomic {

    ($(($atomic:ty, $target:ty)),*) =>{
        $(
            impl AtomicType for $atomic{
                type TargetType = $target;

                fn load(&self, ordering: Ordering) -> Self::TargetType {
                    self.load(ordering)
                }
        }
        )*
    };
}
digestible_atomic!(
    (core::sync::atomic::AtomicBool, bool),
    (core::sync::atomic::AtomicU8, u8),
    (core::sync::atomic::AtomicU16, u16),
    (core::sync::atomic::AtomicU32, u32),
    (core::sync::atomic::AtomicU64, u64),
    (core::sync::atomic::AtomicI8, i8),
    (core::sync::atomic::AtomicI16, i16),
    (core::sync::atomic::AtomicI32, i32),
    (core::sync::atomic::AtomicI64, i64),
    (core::sync::atomic::AtomicUsize, usize),
    (core::sync::atomic::AtomicIsize, isize)
);
macro_rules! digest_with {
    (
        $ordering:path,
        $name:ident
    ) => {
        #[doc = concat!("Loads the Digestible Data from the Atomic. Using Ordering [", stringify!($ordering), "](core::sync::atomic::",stringify!($ordering),")")]
        #[doc = "\n\n AtomicType is implemented for all Atomic Types except AtomicPtr"]
        #[inline(always)]
        pub fn $name<B: byteorder::ByteOrder, W: crate::DigestWriter>(atomic: &impl AtomicType, writer: &mut W) {
            atomic.load($ordering).digest::<B, W>(writer);
        }
    };
    ($(($ordering:path, $name:ident)),*) => {
        $(
            digest_with!($ordering, $name);
        )*
    };
}
digest_with!(
    (Ordering::Relaxed, digest_relaxed),
    (Ordering::Acquire, digest_acquire),
    (Ordering::SeqCst, digest_seq_cst)
);