Struct nanorand::buffer::BufferedRng

pub struct BufferedRng<InternalGenerator: Rng<OUTPUT>, const OUTPUT: usize> { /* private fields */ }

A buffered wrapper for any Rng implementation. It will keep unused bytes from the last call to Rng::rand, and use them for subsequent randomness if needed, rather than throwing them away.

use nanorand::{Rng, BufferedRng, WyRand};

let mut thingy = [0u8; 5];
let mut rng = BufferedRng::new(WyRand::new());
rng.fill(&mut thingy);
// As WyRand generates 8 bytes of output, and our target is only 5 bytes,
// 3 bytes will remain in the buffer.
assert_eq!(rng.buffered(), 3);

Implementations

impl<InternalGenerator: Rng<OUTPUT>, const OUTPUT: usize> BufferedRng<InternalGenerator, OUTPUT>

pub fn new(rng: InternalGenerator) -> Self

Wraps a Rng InternalGenerator in a BufferedRng instance.

pub fn into_inner(self) -> InternalGenerator

Returns the internal RNG, dropping the buffer.

pub fn buffered(&self) -> usize

Returns how many unused bytes are currently buffered.

Trait Implementations

impl<InternalGenerator: Clone + Rng<OUTPUT>, const OUTPUT: usize> Clone for BufferedRng<InternalGenerator, OUTPUT>

fn clone(&self) -> BufferedRng<InternalGenerator, OUTPUT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<InternalGenerator: Rng<OUTPUT> + Default, const OUTPUT: usize> Default for BufferedRng<InternalGenerator, OUTPUT>

fn default() -> Self

Returns the “default value” for a type.

impl<InternalGenerator: Rng<OUTPUT>, const OUTPUT: usize> Read for BufferedRng<InternalGenerator, OUTPUT>

fn read(&mut self, output: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, _buf: &mut String) -> Result<usize>

Read all bytes until EOF in this source, appending them to buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it.

impl<InternalGenerator: Rng<OUTPUT>, const OUTPUT: usize> Rng<OUTPUT> for BufferedRng<InternalGenerator, OUTPUT>

fn rand(&mut self) -> [u8; OUTPUT]

Generates a random sequence of bytes, seeding from the internal state.

fn fill_bytes<Bytes>(&mut self, output: Bytes) where
    Bytes: AsMut<[u8]>, 

Fill an array of bytes with randomness.

fn generate<Generated>(&mut self) -> Generated where
    Generated: RandomGen<Self, OUTPUT>, 

Generates a random of the specified type, seeding from the internal state.

fn fill<Contents, Array>(&mut self, target: Array) where
    Contents: RandomGen<Self, OUTPUT>,
    Array: AsMut<[Contents]>, 

Fill an array with the specified type.

fn generate_range<Number, Bounds>(&mut self, range: Bounds) -> Number where
    Number: RandomRange<Self, OUTPUT>,
    Bounds: RangeBounds<Number>, 

Generates a random of the specified type, seeding from the internal state.

fn shuffle<Contents, Array>(&mut self, target: Array) where
    Array: AsMut<[Contents]>, 

Shuffle a slice, using the RNG.

impl<InternalGenerator: SeedableRng<SEED_SIZE, OUTPUT>, const OUTPUT: usize, const SEED_SIZE: usize> SeedableRng<SEED_SIZE, OUTPUT> for BufferedRng<InternalGenerator, OUTPUT>

fn reseed(&mut self, seed: [u8; SEED_SIZE])

Re-seed the RNG with the specified bytes.