rnd 0.1.1

Random
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

extern crate std;

use core::cell::RefCell;
use crate::{unix, Random, RandomSource};

thread_local! {
    static GLOBAL_RAND: RefCell<Box<dyn RandomSource>> =
        RefCell::new(Box::new(unix::RandomDevice::new().unwrap()));
}

/// Gets a random `T` element using the global [RandomSource]
///
/// # Example
/// ```
/// let n = rnd::random::<u32>();
/// println!("{n}");
/// ```
pub fn random<T: Random>() -> T {
    GLOBAL_RAND.with(|r| {
        let mut bor = r.borrow_mut();
        let source = bor.as_mut();
        T::random(source)
    })
}

/// Sets the global [RandomSource] for this thread
///
/// # Example
/// ```no_run
/// pub struct MyRandomSource {
///     // ...
/// }
///
/// impl rnd::RandomSource for MyRandomSource {
///     fn fill_bytes(&mut self, bytes: &mut [u8]) {
///         // ... do some stuff
///     }
/// }
///
/// rnd::set_global_random(MyRandomSource {});
/// for _ in 0..10 {
///     println!("{}", rnd::random::<u32>());
/// }
/// ```
pub fn set_global_random(dev: impl RandomSource + 'static) {
    GLOBAL_RAND.with(|r| {
        *r.borrow_mut() = Box::new(dev)
    })
}

pub struct GlobalRandomSource;

impl RandomSource for GlobalRandomSource {
    fn fill_bytes(&mut self, bytes: &mut [u8]) {
        GLOBAL_RAND.with(|rs| {
            rs.borrow_mut().fill_bytes(bytes);
        })
    }
}