rlibdht 0.1.0

Rust DHT library
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

use std::time::{SystemTime, UNIX_EPOCH};
use std::mem;

pub fn gen<T>() -> T
where
    T: Default + Copy,
{
    let mut rng = Lcg::new(get_seed());
    rng.gen_num::<T>()
}

pub fn gen_array<T, const N: usize>() -> [T; N]
where
    T: Default + Copy,
{
    let mut rng = Lcg::new(get_seed());
    let mut array = [T::default(); N];
    for i in 0..N {
        array[i] = rng.gen_num::<T>();
    }
    array
}

fn get_seed() -> u64 {
    let now = SystemTime::now();
    let since_the_epoch = now.duration_since(UNIX_EPOCH).expect("Time went backwards");
    since_the_epoch.as_nanos() as u64
}

struct Lcg {
    seed: u64,
}

impl Lcg {
    fn new(seed: u64) -> Self {
        Lcg { seed }
    }

    fn gen_num<T>(&mut self) -> T
    where
        T: Default + Copy,
    {
        const A: u64 = 6364136223846793005;
        const C: u64 = 1;
        self.seed = self.seed.wrapping_mul(A).wrapping_add(C);

        let bytes = self.seed.to_le_bytes();
        let mut result = T::default();

        // Cast the bytes to the target type
        let result_ptr = &mut result as *mut T as *mut u8;
        let size = mem::size_of::<T>();

        // Copy the appropriate number of bytes into result
        unsafe {
            result_ptr.copy_from_nonoverlapping(bytes.as_ptr(), size);
        }

        result
    }
}