Trait RngCore 

pub trait RngCore {
    // Required methods
    fn next_u32(&mut self) -> u32;
    fn next_u64(&mut self) -> u64;
    fn fill_bytes(&mut self, dst: &mut [u8]);
}

Implementation-level interface for RNGs

This trait encapsulates the low-level functionality common to all generators, and is the “back end”, to be implemented by generators. End users should normally use the rand::Rng trait which is automatically implemented for every type implementing RngCore.

Three different methods for generating random data are provided since the optimal implementation of each is dependent on the type of generator. There is no required relationship between the output of each; e.g. many implementations of fill_bytes consume a whole number of u32 or u64 values and drop any remaining unused bytes. The same can happen with the next_u32 and next_u64 methods, implementations may discard some random bits for efficiency.

Properties of a generator

Implementers should produce bits uniformly. Pathological RNGs (e.g. constant or counting generators which rarely change some bits) may cause issues in consumers of random data, for example dead-locks in rejection samplers and obviously non-random output (e.g. a counting generator may result in apparently-constant output from a uniform-ranged distribution).

Algorithmic generators implementing SeedableRng should normally have portable, reproducible output, i.e. fix Endianness when converting values to avoid platform differences, and avoid making any changes which affect output (except by communicating that the release has breaking changes).

Implementing RngCore

Typically an RNG will implement only one of the methods available in this trait directly, then use the helper functions from the le module to implement the other methods.

Note that implementors of RngCore also automatically implement the TryRngCore trait with the Error associated type being equal to Infallible.

It is recommended that implementations also implement:

• Debug with a custom implementation which does not print any internal state (at least, CryptoRngs should not risk leaking state through Debug).
• Serialize and Deserialize (from Serde), preferably making Serde support optional at the crate level in PRNG libs.
• Clone, if possible.
• never implement Copy (accidental copies may cause repeated values).
• do not implement Default for pseudorandom generators, but instead implement SeedableRng, to guide users towards proper seeding. External / hardware RNGs can choose to implement Default.
• Eq and PartialEq could be implemented, but are probably not useful.

Required Methods

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

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

Fill dest with random data.

This method should guarantee that dest is entirely filled with new data, and may panic if this is impossible (e.g. reading past the end of a file that is being used as the source of randomness).

Implementors

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

impl<R: BlockRngCore<Item = u64>> RngCore for BlockRng64<R>

impl<R: TryRngCore + ?Sized> RngCore for UnwrapMut<'_, R>

impl<R: TryRngCore> RngCore for UnwrapErr<R>

impl<T: DerefMut> RngCore for T

where T::Target: RngCore,