rand06-compat 0.2.0

Compatibility wrapper between `rand_core` 0.6 and 0.10
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

#![doc = include_str!("../README.md")]
#![cfg_attr(not(feature = "std"), no_std)]

/// Compatibility extension trait for RNGs implementing `rand_core` `0.10`
/// `TryRng` trait.
pub trait Rand0_6CompatExt {
    /// Wraps `self` in a compatibility wrapper that implements `0.6` traits.
    fn compat(self) -> Rand0_6CompatWrapper<Self>
    where
        Self: Sized,
    {
        Rand0_6CompatWrapper(self)
    }

    /// Wraps `self` in a compatibility wrapper that implements `0.6` traits.
    ///
    /// Same as [`Rand0_6CompatExt::compat`] but instead of taking ownership it
    /// borrows.
    fn compat_by_ref(&mut self) -> Rand0_6CompatWrapper<&mut Self>
    where
        Self: Sized,
    {
        Rand0_6CompatWrapper(self)
    }
}

impl<T> Rand0_6CompatExt for T where T: rand_core::TryRng + ?Sized {}

/// Rand 0.6 compatibility wrapper.
pub struct Rand0_6CompatWrapper<R: ?Sized>(R);

impl<R> Rand0_6CompatWrapper<R> {
    /// Creates a new compatibility wrapper.
    pub fn new(inner: R) -> Self {
        Self(inner)
    }

    /// Returns the inner value.
    pub fn into_inner(self) -> R {
        self.0
    }
}

#[cfg(not(feature = "std"))]
impl<R> rand_core_06::RngCore for Rand0_6CompatWrapper<R>
where
    R: rand_core::TryRng + ?Sized,
{
    fn next_u32(&mut self) -> u32 {
        self.0.try_next_u32().unwrap()
    }

    fn next_u64(&mut self) -> u64 {
        self.0.try_next_u64().unwrap()
    }

    fn fill_bytes(&mut self, dest: &mut [u8]) {
        self.0.try_fill_bytes(dest).unwrap()
    }

    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core_06::Error> {
        self.0
            .try_fill_bytes(dest)
            .map_err(|_| rand_core_06::Error::from(core::num::NonZeroU32::new(1).unwrap()))
    }
}

#[cfg(feature = "std")]
impl<R> rand_core_06::RngCore for Rand0_6CompatWrapper<R>
where
    R: rand_core::TryRng + ?Sized,
    R::Error: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
{
    fn next_u32(&mut self) -> u32 {
        self.0.try_next_u32().unwrap()
    }

    fn next_u64(&mut self) -> u64 {
        self.0.try_next_u64().unwrap()
    }

    fn fill_bytes(&mut self, dest: &mut [u8]) {
        self.0.try_fill_bytes(dest).unwrap()
    }

    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core_06::Error> {
        self.0
            .try_fill_bytes(dest)
            .map_err(rand_core_06::Error::new)
    }
}

impl<R> rand_core_06::CryptoRng for Rand0_6CompatWrapper<R> where R: rand_core::TryCryptoRng + ?Sized
{}

#[cfg(test)]
mod tests {
    use super::*;

    use rand::rngs::SysRng;
    use rand_core_06::RngCore as RngCore06;

    fn foo<R>(rng: &mut R)
    where
        R: RngCore06,
    {
        let _: u32 = rng.next_u32();
    }

    #[test]
    fn test_compat_os_rng() {
        foo(&mut SysRng.compat());
    }

    #[test]
    fn test_compat_thread_rng() {
        let mut rng = rand::rng();
        foo(&mut (rng.compat_by_ref()));
        foo(&mut rng.compat());
    }
}