Struct BlockRng 

pub struct BlockRng<G>
where
    G: Generator,
{
    pub core: G,
    /* private fields */
}

RNG functionality for a block Generator

This type encompasses a Generator core and a buffer. It provides optimized implementations of methods required by an Rng.

All values are consumed in-order of generation. No whole words (e.g. u32 or u64) are discarded, though where a word is partially used (e.g. for a byte-fill whose length is not a multiple of the word size) the rest of the word is discarded.

Fields

core: G

The core part of the RNG, implementing the generate function.

Implementations

impl<W, const N: usize, G> BlockRng<G>

where W: Word + Default, G: Generator<Output = [W; N]>,

pub fn new(core: G) -> BlockRng<G>

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

pub fn reconstruct(core: G, remaining_results: &[W]) -> Option<BlockRng<G>>

Reconstruct from a core and a remaining-results buffer.

This may be used to deserialize using a core and the output of Self::remaining_results.

Returns None if remaining_results is too long.

impl<W, const N: usize, G> BlockRng<G>

where W: Word, G: Generator<Output = [W; N]>,

pub fn reset_and_skip(&mut self, n: usize)

Re-generate buffer contents, skipping the first n words

Existing buffer contents are discarded. A new set of results is generated (either immediately or when next required). The first n words are skipped (this may be used to set a specific word position).

Panics

This method will panic if n >= N where N is the buffer size (in words).

pub fn word_offset(&self) -> usize

Get the number of words consumed since the start of the block

The result is in the range 0..N where N is the buffer size (in words).

pub fn remaining_results(&self) -> &[W]

Access the unused part of the results buffer

The length of the returned slice is guaranteed to be less than the length of <Self as Generator>::Output (i.e. less than N where Output = [W; N]).

This is a low-level interface intended for serialization. Results are not marked as consumed.

pub fn next_word(&mut self) -> W

Generate the next word (e.g. u32)

impl<const N: usize, G> BlockRng<G>

where G: Generator<Output = [u32; N]>,

pub fn next_u64_from_u32(&mut self) -> u64

Generate a u64 from two u32 words

impl<W, const N: usize, G> BlockRng<G>

where W: Word, G: Generator<Output = [W; N]>,

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

Fill dest

Trait Implementations

impl<G> Clone for BlockRng<G>

where G: Clone + Generator, <G as Generator>::Output: Clone,

fn clone(&self) -> BlockRng<G>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<G> Debug for BlockRng<G>

where G: Generator + Debug,

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

Formats the value using the given formatter.

impl<G> Drop for BlockRng<G>

where G: Generator,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.