Struct `BlockRng`

struct BlockRng<R: BlockRngCore> { ... }

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 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 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

`impl<R: BlockRngCore> BlockRng<R>`

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

Create a new BlockRng from an existing RNG implementing BlockRngCore. Results will be generated on first use.

fn index(self: &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.

fn reset(self: &mut Self)

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

fn generate_and_set(self: &mut Self, index: usize)

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

`impl<'de, R> Deserialize for BlockRng<R>`

fn deserialize<__D>(__deserializer: __D) -> Result<Self, <__D as >::Error> where __D: Deserializer<'de>

`impl<R> Freeze for BlockRng<R>`

`impl<R> RefUnwindSafe for BlockRng<R>`

`impl<R> Send for BlockRng<R>`

`impl<R> Serialize for BlockRng<R>`

fn serialize<__S>(self: &Self, __serializer: __S) -> Result<<__S as >::Ok, <__S as >::Error> where __S: Serializer

`impl<R> Sync for BlockRng<R>`

`impl<R> TryCryptoRng for BlockRng<R>`

`impl<R> TryRngCore for BlockRng<R>`

fn try_next_u32(self: &mut Self) -> Result<u32, <R as TryRngCore>::Error>
fn try_next_u64(self: &mut Self) -> Result<u64, <R as TryRngCore>::Error>
fn try_fill_bytes(self: &mut Self, dst: &mut [u8]) -> Result<(), <R as TryRngCore>::Error>

`impl<R> Unpin for BlockRng<R>`

`impl<R> UnsafeUnpin for BlockRng<R>`

`impl<R> UnwindSafe for BlockRng<R>`

`impl<R: $crate::clone::Clone + BlockRngCore> Clone for BlockRng<R>`

fn clone(self: &Self) -> BlockRng<R>

`impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng<R>`

fn from_seed(seed: <Self as >::Seed) -> Self
fn seed_from_u64(seed: u64) -> Self
fn from_rng<impl RngCore: RngCore>(rng: &mut impl RngCore) -> Self
fn try_from_rng<S: TryRngCore>(rng: &mut S) -> Result<Self, <S as >::Error>

`impl<R: BlockRngCore + fmt::Debug> Debug for BlockRng<R>`

fn fmt(self: &Self, fmt: &mut Formatter<'_>) -> Result

`impl<R: BlockRngCore<Item = u32>> RngCore for BlockRng<R>`

fn next_u32(self: &mut Self) -> u32
fn next_u64(self: &mut Self) -> u64
fn fill_bytes(self: &mut Self, dest: &mut [u8])

`impl<R: CryptoBlockRng + BlockRngCore<Item = u32>> CryptoRng for BlockRng<R>`

`impl<T> Any for BlockRng<R>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BlockRng<R>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for BlockRng<R>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for BlockRng<R>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> DeserializeOwned for BlockRng<R>`

`impl<T> From for BlockRng<R>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for BlockRng<R>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for BlockRng<R>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for BlockRng<R>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for BlockRng<R>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>