# [−] [src] Struct rand::rngs::adapter::ReseedingRng

    pub struct ReseedingRng<R, Rsdr>(_)
     where
        R: BlockRngCore + SeedableRng,
        Rsdr: RngCore;

A wrapper around any PRNG that implements `BlockRngCore`, that adds the ability to reseed it.

`ReseedingRng` reseeds the underlying PRNG in the following cases:

- On a manual call to `reseed()`.
- After `clone()`, the clone will be reseeded on first use.
- After a process is forked, the RNG in the child process is reseeded within the next few generated values, depending on the block size of the underlying PRNG. For ChaCha and Hc128 this is a maximum of 15 `u32` values before reseeding.
- After the PRNG has generated a configurable number of random bytes.

# When should reseeding after a fixed number of generated bytes be used?

Reseeding after a fixed number of generated bytes is never strictly necessary. Cryptographic PRNGs don't have a limited number of bytes they can output, or at least not a limit reachable in any practical way. There is no such thing as 'running out of entropy'.

Occasionally reseeding can be seen as some form of 'security in depth'. Even if in the future a cryptographic weakness is found in the CSPRNG being used, or a flaw in the implementation, occasionally reseeding should make exploiting it much more difficult or even impossible.

Use `ReseedingRng::new` with a `threshold` of `0` to disable reseeding after a fixed number of generated bytes.

# Error handling

Although unlikely, reseeding the wrapped PRNG can fail. `ReseedingRng` will never panic but try to handle the error intelligently through some combination of retrying and delaying reseeding until later. If handling the source error fails `ReseedingRng` will continue generating data from the wrapped PRNG without reseeding.

Manually calling `reseed()` will not have this retry or delay logic, but reports the error.

# Example

    use rand::prelude::*;
    use rand_chacha::ChaCha20Core; // Internal part of ChaChaRng that
                                 // implements BlockRngCore
    use rand::rngs::OsRng;
    use rand::rngs::adapter::ReseedingRng;

    let prng = ChaCha20Core::from_entropy();
    let mut reseeding_rng = ReseedingRng::new(prng, 0, OsRng);

    println!("{}", reseeding_rng.gen::<u64>());

    let mut cloned_rng = reseeding_rng.clone();
    assert!(reseeding_rng.gen::<u64>() != cloned_rng.gen::<u64>());

## Methods

### `impl<R, Rsdr> ReseedingRng<R, Rsdr> where
R: BlockRngCore + SeedableRng,
Rsdr: RngCore,` [src]

#### `pub fn new(rng: R, threshold: u64, reseeder: Rsdr) -> Self` [src]

Create a new `ReseedingRng` from an existing PRNG, combined with a RNG to use as reseeder.

`threshold` sets the number of generated bytes after which to reseed the PRNG. Set it to zero to never reseed based on the number of generated values.

#### `pub fn reseed(&mut self) -> Result<(), Error>` [src]

Reseed the internal PRNG.

## Trait Implementations

### `impl<R, Rsdr> Clone for ReseedingRng<R, Rsdr> where
R: BlockRngCore + SeedableRng + Clone,
Rsdr: RngCore + Clone,` [src]

#### `fn clone(&self) -> ReseedingRng<R, Rsdr>` [src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl<R: Debug, Rsdr: Debug> Debug for ReseedingRng<R, Rsdr> where
R: BlockRngCore + SeedableRng,
Rsdr: RngCore,` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr> where
R: BlockRngCore<Item = u32> + SeedableRng,
<R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>,` [src]

#### `fn next_u32(&mut self) -> u32` [src]

Return the next random `u32`. Read more

#### `fn next_u64(&mut self) -> u64` [src]

Return the next random `u64`. Read more

#### `fn fill_bytes(&mut self, dest: &mut [u8])` [src]

Fill `dest` with random data. Read more

#### `fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>` [src]

Fill `dest` entirely with random data. Read more

### `impl<R, Rsdr> CryptoRng for ReseedingRng<R, Rsdr> where
R: BlockRngCore + SeedableRng + CryptoRng,
Rsdr: RngCore + CryptoRng,` [src]

## Auto Trait Implementations

### `impl<R, Rsdr> Send for ReseedingRng<R, Rsdr> where
R: Send,
Rsdr: Send,
<R as BlockRngCore>::Results: Send,`

### `impl<R, Rsdr> Sync for ReseedingRng<R, Rsdr> where
R: Sync,
Rsdr: Sync,
<R as BlockRngCore>::Results: Sync,`

## Blanket Implementations

### `impl<R> Rng for R where
R: RngCore + ?Sized,` [src]

#### `fn gen<T>(&mut self) -> T where
Standard: Distribution<T>,` [src]

Return a random value supporting the [`Standard`] distribution. Read more

#### `fn gen_range<T: SampleUniform, B1, B2>(&mut self, low: B1, high: B2) -> T where
B1: SampleBorrow<T> + Sized,
B2: SampleBorrow<T> + Sized,` [src]

Generate a random value in the range [`low`, `high`), i.e. inclusive of `low` and exclusive of `high`. Read more

#### `fn sample<T, D: Distribution<T>>(&mut self, distr: D) -> T` [src]

Sample a new value, using the given distribution. Read more

####
ⓘImportant traits for DistIter<D, R, T>

### Important traits for DistIter<D, R, T>

`impl<D, R, T> Iterator for DistIter<D, R, T> where
D: Distribution<T>,
R: Rng, type Item = T;`
`fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T> where
D: Distribution<T>,
Self: Sized,` [src]

Create an iterator that generates values using the given distribution. Read more

#### `fn fill<T: AsByteSliceMut + ?Sized>(&mut self, dest: &mut T)` [src]

Fill `dest` entirely with random bytes (uniform value distribution), where `dest` is any type supporting [`AsByteSliceMut`], namely slices and arrays over primitive integer types (`i8`, `i16`, `u32`, etc.). Read more

#### `fn try_fill<T: AsByteSliceMut + ?Sized>(
&mut self,
dest: &mut T
) -> Result<(), Error>` [src]

Fill `dest` entirely with random bytes (uniform value distribution), where `dest` is any type supporting [`AsByteSliceMut`], namely slices and arrays over primitive integer types (`i8`, `i16`, `u32`, etc.). Read more

#### `fn gen_bool(&mut self, p: f64) -> bool` [src]

Return a bool with a probability `p` of being true. Read more

#### `fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool` [src]

Return a bool with a probability of `numerator/denominator` of being true. I.e. `gen_ratio(2, 3)` has chance of 2 in 3, or about 67%, of returning true. If `numerator == denominator`, then the returned value is guaranteed to be `true`. If `numerator == 0`, then the returned value is guaranteed to be `false`. Read more

### `impl<T> From<T> for T` [src]

#### `fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<V, T> VZip<V> for T where
V: MultiLane<T>,` [src]

#### `fn vzip(self) -> V` [src]

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)