```
pub struct BlockRng<R>where
R: BlockRngCore + ?Sized,{
pub core: R,
/* private fields */
}
```

## Expand description

A wrapper type implementing `RngCore`

for some type implementing
`BlockRngCore`

with `u32`

array buffer; i.e. this can be used to implement
a full RNG from just a `generate`

function.

The `core`

field may be accessed directly but the results buffer may not.
PRNG implementations can simply use a type alias
(`pub type MyRng = BlockRng<MyRngCore>;`

) but might prefer to use a
wrapper type (`pub struct MyRng(BlockRng<MyRngCore>);`

); the latter must
re-implement `RngCore`

but hides the implementation details and allows
extra functionality to be defined on the RNG
(e.g. `impl MyRng { fn set_stream(...){...} }`

).

`BlockRng`

has heavily optimized implementations of the `RngCore`

methods
reading values from the results buffer, as well as
calling `BlockRngCore::generate`

directly on the output array when
`fill_bytes`

/ `try_fill_bytes`

is called on a large array. These methods
also handle the bookkeeping of when to generate a new batch of values.

No whole generated `u32`

values are thrown away and all values are consumed
in-order. `next_u32`

simply takes the next available `u32`

value.
`next_u64`

is implemented by combining two `u32`

values, least
significant first. `fill_bytes`

and `try_fill_bytes`

consume a whole
number of `u32`

values, converting each `u32`

to a byte slice in
little-endian order. If the requested byte length is not a multiple of 4,
some bytes will be discarded.

See also `BlockRng64`

which uses `u64`

array buffers. Currently there is
no direct support for other buffer types.

For easy initialization `BlockRng`

also implements `SeedableRng`

.

## Fields§

§`core: R`

The *core* part of the RNG, implementing the `generate`

function.

## Implementations§

source§### impl<R> BlockRng<R>where
R: BlockRngCore,

### impl<R> BlockRng<R>where
R: BlockRngCore,

source#### pub fn new(core: R) -> BlockRng<R>

#### pub fn new(core: R) -> BlockRng<R>

Create a new `BlockRng`

from an existing RNG implementing
`BlockRngCore`

. Results will be generated on first use.

source#### pub fn index(&self) -> usize

#### pub fn index(&self) -> usize

Get the index into the result buffer.

If this is equal to or larger than the size of the result buffer then
the buffer is “empty” and `generate()`

must be called to produce new
results.

source#### pub fn reset(&mut self)

#### pub fn reset(&mut self)

Reset the number of available results. This will force a new set of results to be generated on next use.

source#### pub fn generate_and_set(&mut self, index: usize)

#### pub fn generate_and_set(&mut self, index: usize)

Generate a new set of results immediately, setting the index to the given value.

## Trait Implementations§

source§### impl<R> RngCore for BlockRng<R>

### impl<R> RngCore for BlockRng<R>

source§#### fn fill_bytes(&mut self, dest: &mut [u8])

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

`dest`

with random data. Read moresource§### impl<R> SeedableRng for BlockRng<R>where
R: BlockRngCore + SeedableRng,

### impl<R> SeedableRng for BlockRng<R>where
R: BlockRngCore + SeedableRng,

§#### type Seed = <R as SeedableRng>::Seed

#### type Seed = <R as SeedableRng>::Seed

`u8`

arrays (we recommend `[u8; N]`

for some `N`

). Read moresource§#### fn from_seed(seed: <BlockRng<R> as SeedableRng>::Seed) -> BlockRng<R>

#### fn from_seed(seed: <BlockRng<R> as SeedableRng>::Seed) -> BlockRng<R>

source§#### fn from_rng<S>(rng: S) -> Result<BlockRng<R>, Error>where
S: RngCore,

#### fn from_rng<S>(rng: S) -> Result<BlockRng<R>, Error>where
S: RngCore,

`Rng`

. Read moresource§#### fn from_entropy() -> Self

#### fn from_entropy() -> Self

### impl<R> CryptoRng for BlockRng<R>where
R: BlockRngCore + CryptoRng,

## Auto Trait Implementations§

### impl<R: ?Sized> RefUnwindSafe for BlockRng<R>

### impl<R: ?Sized> Send for BlockRng<R>

### impl<R: ?Sized> Sync for BlockRng<R>

### impl<R: ?Sized> Unpin for BlockRng<R>

### impl<R: ?Sized> UnwindSafe for BlockRng<R>

## Blanket Implementations§

§### impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,

### impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,

§### impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,

### impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

source§### impl<T> CryptoRngCore for T

### impl<T> CryptoRngCore for T

§### impl<T> Instrument for T

### impl<T> Instrument for T

§#### fn instrument(self, span: Span) -> Instrumented<Self>

#### fn instrument(self, span: Span) -> Instrumented<Self>

§#### fn in_current_span(self) -> Instrumented<Self>

#### fn in_current_span(self) -> Instrumented<Self>

source§### impl<R> Rng for R

### impl<R> Rng for R

source§#### fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,

#### fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,

source§#### fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,

#### fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,

source§#### fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,

#### fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,

source§#### fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,

#### fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,

source§#### fn gen_bool(&mut self, p: f64) -> bool

#### fn gen_bool(&mut self, p: f64) -> bool

`p`

of being true. Read moresource§#### fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool

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

`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