osom_lib_prng/
defaults.rs

1use core::ops::RangeBounds;
2
3use osom_lib_reprc::macros::reprc;
4
5use crate::{
6    prngs::{ChaCha, LinearCongruentialGenerator128},
7    traits::{
8        CryptographicallySecure, PRNConcreteBoundedGenerator, PRNConcreteGenerator, PRNGenerator, Seedable, Splittable,
9    },
10};
11
12/// The recommended [`PRNGenerator`] for fast PRNG.
13///
14/// At the moment it uses [`LinearCongruentialGenerator128`] as an underlying PRNG.
15#[derive(Debug, PartialEq, Eq, Clone, Copy)]
16#[reprc]
17#[repr(transparent)]
18#[must_use]
19pub struct DefaultFastPRNG {
20    prng: LinearCongruentialGenerator128,
21}
22
23impl PRNGenerator for DefaultFastPRNG {
24    unsafe fn fill_raw(&mut self, dst_ptr: *mut u8, dst_len: usize) {
25        unsafe { self.prng.fill_raw(dst_ptr, dst_len) };
26    }
27}
28
29impl<const N: usize> PRNConcreteGenerator<DefaultFastPRNG> for [u8; N] {
30    #[inline(always)]
31    fn generate(generator: &mut DefaultFastPRNG) -> Self {
32        generator.prng.generate::<Self>()
33    }
34}
35
36impl PRNConcreteGenerator<DefaultFastPRNG> for bool {
37    fn generate(generator: &mut DefaultFastPRNG) -> Self {
38        generator.prng.generate::<bool>()
39    }
40}
41
42impl PRNConcreteGenerator<DefaultFastPRNG> for u8 {
43    fn generate(generator: &mut DefaultFastPRNG) -> Self {
44        generator.prng.generate::<u8>()
45    }
46}
47
48impl PRNConcreteGenerator<DefaultFastPRNG> for i8 {
49    fn generate(generator: &mut DefaultFastPRNG) -> Self {
50        generator.prng.generate::<i8>()
51    }
52}
53
54impl PRNConcreteGenerator<DefaultFastPRNG> for u32 {
55    fn generate(generator: &mut DefaultFastPRNG) -> Self {
56        generator.prng.generate::<u32>()
57    }
58}
59
60impl PRNConcreteGenerator<DefaultFastPRNG> for i32 {
61    fn generate(generator: &mut DefaultFastPRNG) -> Self {
62        generator.prng.generate::<i32>()
63    }
64}
65
66impl PRNConcreteGenerator<DefaultFastPRNG> for u64 {
67    fn generate(generator: &mut DefaultFastPRNG) -> Self {
68        generator.prng.generate::<u64>()
69    }
70}
71
72impl PRNConcreteGenerator<DefaultFastPRNG> for i64 {
73    fn generate(generator: &mut DefaultFastPRNG) -> Self {
74        generator.prng.generate::<i64>()
75    }
76}
77
78impl PRNConcreteGenerator<DefaultFastPRNG> for u128 {
79    fn generate(generator: &mut DefaultFastPRNG) -> Self {
80        generator.prng.generate::<u128>()
81    }
82}
83
84impl PRNConcreteGenerator<DefaultFastPRNG> for i128 {
85    fn generate(generator: &mut DefaultFastPRNG) -> Self {
86        generator.prng.generate::<i128>()
87    }
88}
89
90impl PRNConcreteBoundedGenerator<DefaultFastPRNG> for u32 {
91    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultFastPRNG, range: TBounds) -> Self {
92        generator.prng.generate_in_range(range)
93    }
94}
95
96impl PRNConcreteBoundedGenerator<DefaultFastPRNG> for u64 {
97    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultFastPRNG, range: TBounds) -> Self {
98        generator.prng.generate_in_range(range)
99    }
100}
101
102impl PRNConcreteBoundedGenerator<DefaultFastPRNG> for i32 {
103    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultFastPRNG, range: TBounds) -> Self {
104        generator.prng.generate_in_range(range)
105    }
106}
107
108impl PRNConcreteBoundedGenerator<DefaultFastPRNG> for i64 {
109    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultFastPRNG, range: TBounds) -> Self {
110        generator.prng.generate_in_range(range)
111    }
112}
113
114impl PRNConcreteBoundedGenerator<DefaultFastPRNG> for f32 {
115    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultFastPRNG, range: TBounds) -> Self {
116        generator.prng.generate_in_range(range)
117    }
118}
119
120impl PRNConcreteBoundedGenerator<DefaultFastPRNG> for f64 {
121    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultFastPRNG, range: TBounds) -> Self {
122        generator.prng.generate_in_range(range)
123    }
124}
125
126impl Seedable<u128> for DefaultFastPRNG {
127    fn with_seed(seed: u128) -> Self {
128        Self {
129            prng: LinearCongruentialGenerator128::with_seed(seed),
130        }
131    }
132}
133
134impl Seedable<u64> for DefaultFastPRNG {
135    fn with_seed(seed: u64) -> Self {
136        Self {
137            prng: LinearCongruentialGenerator128::with_seed(seed),
138        }
139    }
140}
141
142impl Splittable for DefaultFastPRNG {
143    fn split(&mut self) -> Self {
144        Self {
145            prng: self.prng.split(),
146        }
147    }
148}
149
150/// The recommended [`PRNGenerator`] PRNG for cryptographically secure purposes.
151///
152/// At the moment it uses [`ChaCha<20>`] as an underlying PRNG.
153#[derive(Debug, PartialEq, Eq, Clone)]
154#[reprc]
155#[repr(transparent)]
156#[must_use]
157pub struct DefaultSecurePRNG {
158    prng: ChaCha<20>,
159}
160
161unsafe impl CryptographicallySecure for DefaultSecurePRNG {}
162
163impl PRNGenerator for DefaultSecurePRNG {
164    unsafe fn fill_raw(&mut self, dst_ptr: *mut u8, dst_len: usize) {
165        unsafe { self.prng.fill_raw(dst_ptr, dst_len) };
166    }
167}
168
169impl<const N: usize> PRNConcreteGenerator<DefaultSecurePRNG> for [u8; N] {
170    #[inline(always)]
171    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
172        generator.prng.generate::<Self>()
173    }
174}
175
176impl PRNConcreteGenerator<DefaultSecurePRNG> for bool {
177    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
178        generator.prng.generate::<bool>()
179    }
180}
181
182impl PRNConcreteGenerator<DefaultSecurePRNG> for u8 {
183    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
184        generator.prng.generate::<u8>()
185    }
186}
187
188impl PRNConcreteGenerator<DefaultSecurePRNG> for i8 {
189    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
190        generator.prng.generate::<i8>()
191    }
192}
193
194impl PRNConcreteGenerator<DefaultSecurePRNG> for u32 {
195    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
196        generator.prng.generate::<u32>()
197    }
198}
199
200impl PRNConcreteGenerator<DefaultSecurePRNG> for i32 {
201    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
202        generator.prng.generate::<i32>()
203    }
204}
205
206impl PRNConcreteGenerator<DefaultSecurePRNG> for u64 {
207    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
208        generator.prng.generate::<u64>()
209    }
210}
211
212impl PRNConcreteGenerator<DefaultSecurePRNG> for i64 {
213    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
214        generator.prng.generate::<i64>()
215    }
216}
217
218impl PRNConcreteGenerator<DefaultSecurePRNG> for u128 {
219    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
220        generator.prng.generate::<u128>()
221    }
222}
223
224impl PRNConcreteGenerator<DefaultSecurePRNG> for i128 {
225    fn generate(generator: &mut DefaultSecurePRNG) -> Self {
226        generator.prng.generate::<i128>()
227    }
228}
229
230impl PRNConcreteBoundedGenerator<DefaultSecurePRNG> for u32 {
231    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultSecurePRNG, range: TBounds) -> Self {
232        generator.prng.generate_in_range(range)
233    }
234}
235
236impl PRNConcreteBoundedGenerator<DefaultSecurePRNG> for u64 {
237    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultSecurePRNG, range: TBounds) -> Self {
238        generator.prng.generate_in_range(range)
239    }
240}
241
242impl PRNConcreteBoundedGenerator<DefaultSecurePRNG> for i32 {
243    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultSecurePRNG, range: TBounds) -> Self {
244        generator.prng.generate_in_range(range)
245    }
246}
247
248impl PRNConcreteBoundedGenerator<DefaultSecurePRNG> for i64 {
249    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultSecurePRNG, range: TBounds) -> Self {
250        generator.prng.generate_in_range(range)
251    }
252}
253
254impl PRNConcreteBoundedGenerator<DefaultSecurePRNG> for f32 {
255    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultSecurePRNG, range: TBounds) -> Self {
256        generator.prng.generate_in_range(range)
257    }
258}
259
260impl PRNConcreteBoundedGenerator<DefaultSecurePRNG> for f64 {
261    fn generate<TBounds: RangeBounds<Self>>(generator: &mut DefaultSecurePRNG, range: TBounds) -> Self {
262        generator.prng.generate_in_range(range)
263    }
264}
265
266impl Seedable<u128> for DefaultSecurePRNG {
267    fn with_seed(seed: u128) -> Self {
268        Self {
269            prng: ChaCha::with_seed(seed),
270        }
271    }
272}
273
274impl Seedable<u64> for DefaultSecurePRNG {
275    fn with_seed(seed: u64) -> Self {
276        Self {
277            prng: ChaCha::with_seed(seed),
278        }
279    }
280}
281
282impl Splittable for DefaultSecurePRNG {
283    fn split(&mut self) -> Self {
284        Self {
285            prng: self.prng.split(),
286        }
287    }
288}
osom_lib_prng/defaults.rs

osom_lib_prng/
defaults.rs
