|
|
---
|
|
|
source: tests/output.rs
|
|
|
expression: "get_stdout(&[item])"
|
|
|
---
|
|
|
rand_core Struct rand_core::block::BlockRng rusty-man
|
|
|
|
|
|
SYNOPSIS
|
|
|
pub struct BlockRng<R: BlockRngCore + ?Sized> {
|
|
|
pub core: R,
|
|
|
// some fields omitted
|
|
|
}
|
|
|
|
|
|
DESCRIPTION
|
|
|
A wrapper type implementing [`RngCore`] for some type implementing [`BlockRngCore`] with `u32`
|
|
|
array buffer; i.e. this can be used to implement a full RNG from just a `generate` function.
|
|
|
|
|
|
The `core` field may be accessed directly but the results buffer may not. PRNG implementations
|
|
|
can simply use a type alias (`pub type MyRng = BlockRng<MyRngCore>;`) but might prefer to use
|
|
|
a wrapper type (`pub struct MyRng(BlockRng<MyRngCore>);`); the latter must re-implement
|
|
|
`RngCore` but hides the implementation details and allows extra functionality to be defined on
|
|
|
the RNG (e.g. `impl MyRng { fn set_stream(...){...} }`).
|
|
|
|
|
|
`BlockRng` has heavily optimized implementations of the [`RngCore`] methods reading values
|
|
|
from the results buffer, as well as calling [`BlockRngCore::generate`] directly on the output
|
|
|
array when `fill_bytes` / `try_fill_bytes` is called on a large array. These methods also
|
|
|
handle the bookkeeping of when to generate a new batch of values.
|
|
|
|
|
|
No whole generated `u32` values are thown away and all values are consumed in-order.
|
|
|
`next_u32` simply takes the next available `u32` value. `next_u64` is implemented by combining
|
|
|
two `u32` values, least significant first. `fill_bytes` and `try_fill_bytes` consume a whole
|
|
|
number of `u32` values, converting each `u32` to a byte slice in little-endian order. If the
|
|
|
requested byte length is not a multiple of 4, some bytes will be discarded.
|
|
|
|
|
|
See also [`BlockRng64`] which uses `u64` array buffers. Currently there is no direct support
|
|
|
for other buffer types.
|
|
|
|
|
|
For easy initialization `BlockRng` also implements [`SeedableRng`].
|
|
|
|
|
|
FIELDS
|
|
|
core
|
|
|
core: R
|
|
|
|
|
|
The *core* part of the RNG, implementing the `generate` function.
|
|
|
|
|
|
METHODS
|
|
|
impl<R: BlockRngCore> BlockRng<R>
|
|
|
new
|
|
|
pub fn new(core: R) -> BlockRng<R>
|
|
|
|
|
|
Create a new `BlockRng` from an existing RNG implementing `BlockRngCore`. Results will
|
|
|
be generated on first use.
|
|
|
|
|
|
index
|
|
|
pub 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.
|
|
|
|
|
|
reset
|
|
|
pub fn reset(&mut self)
|
|
|
|
|
|
Reset the number of available results. This will force a new set of results to be
|
|
|
generated on next use.
|
|
|
|
|
|
generate_and_set
|
|
|
pub fn generate_and_set(&mut self, index: usize)
|
|
|
|
|
|
Generate a new set of results immediately, setting the index to the given value.
|
|
|
|
|
|
IMPLEMENTATIONS
|
|
|
Trait Implementations
|
|
|
BlockRngCore
|
|
|
impl<R: BlockRngCore + CryptoRng> CryptoRng for BlockRng<R>
|
|
|
|
|
|
BlockRngCore
|
|
|
impl<R: BlockRngCore + Debug> Debug for BlockRng<R>
|
|
|
|
|
|
BlockRngCore
|
|
|
impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng<R>
|
|
|
|
|
|
BlockRngCore
|
|
|
impl<R: BlockRngCore<Item = u32>> RngCore for BlockRng<R>
|
|
|
where
|
|
|
<R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>,
|
|
|
|
|
|
Clone
|
|
|
impl<R: Clone + BlockRngCore + ?Sized> Clone for BlockRng<R>
|
|
|
where
|
|
|
R::Results: Clone,
|
|
|
|
|
|
Auto Trait Implementations
|
|
|
Sized
|
|
|
impl<R: ?Sized> RefUnwindSafe for BlockRng<R>
|
|
|
where
|
|
|
R: RefUnwindSafe,
|
|
|
<R as BlockRngCore>::Results: RefUnwindSafe,
|
|
|
|
|
|
Sized
|
|
|
impl<R: ?Sized> Send for BlockRng<R>
|
|
|
where
|
|
|
R: Send,
|
|
|
<R as BlockRngCore>::Results: Send,
|
|
|
|
|
|
Sized
|
|
|
impl<R: ?Sized> Sync for BlockRng<R>
|
|
|
where
|
|
|
R: Sync,
|
|
|
<R as BlockRngCore>::Results: Sync,
|
|
|
|
|
|
Sized
|
|
|
impl<R: ?Sized> Unpin for BlockRng<R>
|
|
|
where
|
|
|
R: Unpin,
|
|
|
<R as BlockRngCore>::Results: Unpin,
|
|
|
|
|
|
Sized
|
|
|
impl<R: ?Sized> UnwindSafe for BlockRng<R>
|
|
|
where
|
|
|
R: UnwindSafe,
|
|
|
<R as BlockRngCore>::Results: UnwindSafe,
|
|
|
|
|
|
Blanket Implementations
|
|
|
Any
|
|
|
impl<T> Any for T
|
|
|
where
|
|
|
T: 'static + ?Sized,
|
|
|
|
|
|
Borrow
|
|
|
impl<T> Borrow<T> for T
|
|
|
where
|
|
|
T: ?Sized,
|
|
|
|
|
|
BorrowMut
|
|
|
impl<T> BorrowMut<T> for T
|
|
|
where
|
|
|
T: ?Sized,
|
|
|
|
|
|
From
|
|
|
impl<T> From<T> for T
|
|
|
|
|
|
Into
|
|
|
impl<T, U> Into<U> for T
|
|
|
where
|
|
|
U: From<T>,
|
|
|
|
|
|
ToOwned
|
|
|
impl<T> ToOwned for T
|
|
|
where
|
|
|
T: Clone,
|
|
|
|
|
|
TryFrom
|
|
|
impl<T, U> TryFrom<U> for T
|
|
|
where
|
|
|
U: Into<T>,
|
|
|
|
|
|
TryInto
|
|
|
impl<T, U> TryInto<U> for T
|
|
|
where
|
|
|
U: TryFrom<T>,
|
|
|
|
|
|
|