Struct BlockRng 

pub struct BlockRng<G: Generator> {
    results: G::Output,
    pub core: G,
}

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

results: G::Output

core: G

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

Implementations

impl<W: Word + Default, const N: usize, G: Generator<Output = [W; N]>> BlockRng<G>

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

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: Word, const N: usize, G: Generator<Output = [W; N]>> BlockRng<G>

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.

fn set_index(&mut self, index: usize)

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: Generator<Output = [u32; N]>> BlockRng<G>

pub fn next_u64_from_u32(&mut self) -> u64

Generate a u64 from two u32 words

impl<W: Word, const N: usize, G: Generator<Output = [W; N]>> BlockRng<G>

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

Fill dest

Trait Implementations

impl<G: Clone + Generator> Clone for BlockRng<G>

where G::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

Formats the value using the given formatter.

impl<G: Generator> Drop for BlockRng<G>

fn drop(&mut self)

Executes the destructor for this type.