Trait rand::RngCore
[−]
[src]
pub trait RngCore { fn next_u32(&mut self) -> u32; fn next_u64(&mut self) -> u64; fn fill_bytes(&mut self, dest: &mut [u8]); fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>; }
The core of a random number generator.
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 Rng
from the rand crate, 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 try_fill_bytes
method is a variant of fill_bytes
allowing error
handling; it is not deemed sufficiently useful to add equivalents for
next_u32
or next_u64
since the latter methods are almost always used
with algorithmic generators (PRNGs), which are normally infallible.
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).
Typically implementators will implement only one of the methods available
in this trait directly, then use the helper functions from the impls
module to implement the other methods.
It is recommended that implementations also implement:
Debug
with a custom implementation which does not print any internal state (at least,CryptoRng
s should not risk leaking state through Debug)Serialize
andDeserialize
(from Serde), preferably making Serde support optional at the crate level in PRNG libsClone
if, and only if, the clone will have identical output to the original (i.e. all deterministic PRNGs but not external generators)- never implement
Copy
(accidental copies may cause repeated values) - also do not implement
Default
, but instead implementSeedableRng
thus allowing use ofrand::NewRng
(which is automatically implemented) Eq
andPartialEq
could be implemented, but are probably not useful
Example
A simple example, obviously not generating very random output:
use rand_core::{RngCore, Error, impls}; struct CountingRng(u64); impl RngCore for CountingRng { fn next_u32(&mut self) -> u32 { self.next_u64() as u32 } fn next_u64(&mut self) -> u64 { self.0 += 1; self.0 } fn fill_bytes(&mut self, dest: &mut [u8]) { impls::fill_bytes_via_u64(self, dest) } fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> { Ok(self.fill_bytes(dest)) } }
Required Methods
fn next_u32(&mut self) -> u32
Return the next random u32
.
RNGs must implement at least one method from this trait directly. In
the case this method is not implemented directly, it can be implemented
using self.next_u64() as u32
or
via fill_bytes
.
fn next_u64(&mut self) -> u64
Return the next random u64
.
RNGs must implement at least one method from this trait directly. In
the case this method is not implemented directly, it can be implemented
via next_u32
or
via fill_bytes
.
fn fill_bytes(&mut self, dest: &mut [u8])
Fill dest
with random data.
RNGs must implement at least one method from this trait directly. In
the case this method is not implemented directly, it can be implemented
via next_u32
or
via next_u64
or
via try_fill_bytes
; if this generator can fail the implementation
must choose how best to handle errors here (e.g. panic with a
descriptive message or log a warning and retry a few times).
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).
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
Fill dest
entirely with random data.
This is the only method which allows an RNG to report errors while
generating random data thus making this the primary method implemented
by external (true) RNGs (e.g. OsRng
) which can fail. It may be used
directly to generate keys and to seed (infallible) PRNGs.
Other than error handling, this method is identical to fill_bytes
;
thus this may be implemented using Ok(self.fill_bytes(dest))
or
fill_bytes
may be implemented with
self.try_fill_bytes(dest).unwrap()
or more specific error handling.
Implementations on Foreign Types
impl<R> RngCore for Box<R> where
R: RngCore + ?Sized,
[src]
R: RngCore + ?Sized,
impl<R> RngCore for BlockRng<R> where
R: BlockRngCore<Item = u32>,
<R as BlockRngCore>::Results: AsRef<[u32]>,
[src]
R: BlockRngCore<Item = u32>,
<R as BlockRngCore>::Results: AsRef<[u32]>,
impl<'a, R> RngCore for &'a mut R where
R: RngCore + ?Sized,
[src]
R: RngCore + ?Sized,
Implementors
impl RngCore for ChaChaRng
impl RngCore for Hc128Rng
impl RngCore for IsaacRng
impl RngCore for Isaac64Rng
impl RngCore for XorShiftRng
impl RngCore for JitterRng
impl RngCore for StepRng
impl RngCore for OsRng
impl<R: Read> RngCore for ReadRng<R>
impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr> where
R: BlockRngCore<Item = u32> + SeedableRng,
<R as BlockRngCore>::Results: AsRef<[u32]>,impl RngCore for EntropyRng
impl RngCore for ThreadRng
impl RngCore for StdRng
impl RngCore for SmallRng