Skip to content

Commit ee815de

Browse files
committed
Remove Reseeder trait
1 parent 2278d44 commit ee815de

File tree

2 files changed

+22
-46
lines changed

2 files changed

+22
-46
lines changed

src/lib.rs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -279,7 +279,7 @@ use prng::Isaac64Rng as IsaacWordRng;
279279

280280
use distributions::{Range, IndependentSample};
281281
use distributions::range::SampleRange;
282-
#[cfg(feature="std")] use reseeding::{ReseedingRng, ReseedWithNew};
282+
#[cfg(feature="std")] use reseeding::ReseedingRng;
283283

284284
// public modules
285285
pub mod distributions;
@@ -933,20 +933,20 @@ pub fn weak_rng() -> XorShiftRng {
933933
#[cfg(feature="std")]
934934
#[derive(Clone, Debug)]
935935
pub struct ThreadRng {
936-
rng: Rc<RefCell<ReseedingRng<StdRng, ReseedWithNew>>>,
936+
rng: Rc<RefCell<ReseedingRng<StdRng, EntropySource>>>,
937937
}
938938

939939
#[cfg(feature="std")]
940940
thread_local!(
941-
static THREAD_RNG_KEY: Rc<RefCell<ReseedingRng<StdRng, ReseedWithNew>>> = {
941+
static THREAD_RNG_KEY: Rc<RefCell<ReseedingRng<StdRng, EntropySource>>> = {
942942
const THREAD_RNG_RESEED_THRESHOLD: u64 = 32_768;
943-
let r = match StdRng::new() {
944-
Ok(r) => r,
945-
Err(e) => panic!("could not initialize thread_rng: {:?}", e)
946-
};
943+
let mut entropy_source = EntropySource::new()
944+
.expect("could not initialize thread_rng");
945+
let r = StdRng::from_rng(&mut entropy_source)
946+
.expect("could not initialize thread_rng");
947947
let rng = ReseedingRng::new(r,
948948
THREAD_RNG_RESEED_THRESHOLD,
949-
ReseedWithNew);
949+
entropy_source);
950950
Rc::new(RefCell::new(rng))
951951
}
952952
);

src/reseeding.rs

Lines changed: 14 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,7 @@
1111
//! A wrapper around another RNG that reseeds it after it
1212
//! generates a certain number of random bytes.
1313
14-
use {Rng, Error};
15-
#[cfg(feature="std")]
16-
use NewRng;
14+
use {Rng, SeedableRng, Error};
1715

1816
/// A wrapper around any RNG which reseeds the underlying RNG after it
1917
/// has generated a certain number of random bytes.
@@ -23,10 +21,10 @@ pub struct ReseedingRng<R, Rsdr> {
2321
generation_threshold: u64,
2422
bytes_generated: u64,
2523
/// Controls the behaviour when reseeding the RNG.
26-
pub reseeder: Rsdr,
24+
reseeder: Rsdr,
2725
}
2826

29-
impl<R: Rng, Rsdr: Reseeder<R>> ReseedingRng<R, Rsdr> {
27+
impl<R: Rng+SeedableRng, Rsdr: Rng> ReseedingRng<R, Rsdr> {
3028
/// Create a new `ReseedingRng` with the given parameters.
3129
///
3230
/// # Arguments
@@ -47,14 +45,14 @@ impl<R: Rng, Rsdr: Reseeder<R>> ReseedingRng<R, Rsdr> {
4745
/// generated exceed the threshold.
4846
pub fn reseed_if_necessary(&mut self) {
4947
if self.bytes_generated >= self.generation_threshold {
50-
self.reseeder.reseed(&mut self.rng).unwrap();
48+
R::from_rng(&mut self.reseeder).map(|result| self.rng = result).unwrap();
5149
self.bytes_generated = 0;
5250
}
5351
}
5452
}
5553

5654

57-
impl<R: Rng, Rsdr: Reseeder<R>> Rng for ReseedingRng<R, Rsdr> {
55+
impl<R: Rng+SeedableRng, Rsdr: Rng> Rng for ReseedingRng<R, Rsdr> {
5856
fn next_u32(&mut self) -> u32 {
5957
self.reseed_if_necessary();
6058
self.bytes_generated += 4;
@@ -80,35 +78,10 @@ impl<R: Rng, Rsdr: Reseeder<R>> Rng for ReseedingRng<R, Rsdr> {
8078
}
8179
}
8280

83-
/// Something that can be used to reseed an RNG via `ReseedingRng`.
84-
///
85-
/// Note that implementations should support `Clone` only if reseeding is
86-
/// deterministic (no external entropy source). This is so that a `ReseedingRng`
87-
/// only supports `Clone` if fully deterministic.
88-
pub trait Reseeder<R: ?Sized> {
89-
/// Reseed the given RNG.
90-
///
91-
/// On error, this should just forward the source error; errors are handled
92-
/// by the caller.
93-
fn reseed(&mut self, rng: &mut R) -> Result<(), Error>;
94-
}
95-
96-
/// Reseed an RNG using `NewRng` to replace the current instance.
97-
#[cfg(feature="std")]
98-
#[derive(Debug)]
99-
pub struct ReseedWithNew;
100-
101-
#[cfg(feature="std")]
102-
impl<R: Rng + NewRng> Reseeder<R> for ReseedWithNew {
103-
fn reseed(&mut self, rng: &mut R) -> Result<(), Error> {
104-
R::new().map(|result| *rng = result)
105-
}
106-
}
107-
10881
#[cfg(test)]
10982
mod test {
11083
use {impls, le};
111-
use super::{ReseedingRng, Reseeder};
84+
use super::{ReseedingRng};
11285
use {SeedableRng, Rng, Error};
11386

11487
struct Counter {
@@ -139,17 +112,20 @@ mod test {
139112
}
140113

141114
#[derive(Debug, Clone)]
142-
struct ReseedCounter;
143-
impl Reseeder<Counter> for ReseedCounter {
144-
fn reseed(&mut self, rng: &mut Counter) -> Result<(), Error> {
145-
*rng = Counter { i: 0 };
115+
struct ResetCounter;
116+
impl Rng for ResetCounter {
117+
fn next_u32(&mut self) -> u32 { unimplemented!() }
118+
fn next_u64(&mut self) -> u64 { unimplemented!() }
119+
fn fill_bytes(&mut self, _dest: &mut [u8]) { unimplemented!() }
120+
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
121+
for i in dest.iter_mut() { *i = 0; }
146122
Ok(())
147123
}
148124
}
149125

150126
#[test]
151127
fn test_reseeding() {
152-
let mut rs = ReseedingRng::new(Counter {i:0}, 400, ReseedCounter);
128+
let mut rs = ReseedingRng::new(Counter {i:0}, 400, ResetCounter);
153129

154130
let mut i = 0;
155131
for _ in 0..1000 {

0 commit comments

Comments
 (0)