Struct coins_bip32::ecdsa::signature::rand_core::block::BlockRng [−][src]
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: R
The core part of the RNG, implementing the generate
function.
Implementations
impl<R> BlockRng<R> where
R: BlockRngCore,
[src]
R: BlockRngCore,
pub fn new(core: R) -> BlockRng<R>
[src]
Create a new BlockRng
from an existing RNG implementing
BlockRngCore
. Results will be generated on first use.
pub fn index(&self) -> usize
[src]
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.
pub fn reset(&mut self)
[src]
Reset the number of available results. This will force a new set of results to be generated on next use.
pub fn generate_and_set(&mut self, index: usize)
[src]
Generate a new set of results immediately, setting the index to the given value.
Trait Implementations
impl<R> Clone for BlockRng<R> where
R: Clone + BlockRngCore + ?Sized,
<R as BlockRngCore>::Results: Clone,
[src]
R: Clone + BlockRngCore + ?Sized,
<R as BlockRngCore>::Results: Clone,
impl<R> CryptoRng for BlockRng<R> where
R: BlockRngCore + CryptoRng,
[src]
R: BlockRngCore + CryptoRng,
impl<R> Debug for BlockRng<R> where
R: BlockRngCore + Debug,
[src]
R: BlockRngCore + Debug,
impl<R> RngCore for BlockRng<R> where
R: BlockRngCore<Item = u32>,
<R as BlockRngCore>::Results: AsRef<[u32]>,
<R as BlockRngCore>::Results: AsMut<[u32]>,
[src]
R: BlockRngCore<Item = u32>,
<R as BlockRngCore>::Results: AsRef<[u32]>,
<R as BlockRngCore>::Results: AsMut<[u32]>,
pub fn next_u32(&mut self) -> u32
[src]
pub fn next_u64(&mut self) -> u64
[src]
pub fn fill_bytes(&mut self, dest: &mut [u8])
[src]
pub fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
[src]
impl<R> SeedableRng for BlockRng<R> where
R: BlockRngCore + SeedableRng,
[src]
R: BlockRngCore + SeedableRng,
type Seed = <R as SeedableRng>::Seed
Seed type, which is restricted to types mutably-dereferencable as u8
arrays (we recommend [u8; N]
for some N
). Read more
pub fn from_seed(seed: <BlockRng<R> as SeedableRng>::Seed) -> BlockRng<R>
[src]
pub fn seed_from_u64(seed: u64) -> BlockRng<R>
[src]
pub fn from_rng<S>(rng: S) -> Result<BlockRng<R>, Error> where
S: RngCore,
[src]
S: RngCore,
Auto Trait Implementations
impl<R: ?Sized> RefUnwindSafe for BlockRng<R> where
R: RefUnwindSafe,
<R as BlockRngCore>::Results: RefUnwindSafe,
R: RefUnwindSafe,
<R as BlockRngCore>::Results: RefUnwindSafe,
impl<R: ?Sized> Send for BlockRng<R> where
R: Send,
<R as BlockRngCore>::Results: Send,
R: Send,
<R as BlockRngCore>::Results: Send,
impl<R: ?Sized> Sync for BlockRng<R> where
R: Sync,
<R as BlockRngCore>::Results: Sync,
R: Sync,
<R as BlockRngCore>::Results: Sync,
impl<R: ?Sized> Unpin for BlockRng<R> where
R: Unpin,
<R as BlockRngCore>::Results: Unpin,
R: Unpin,
<R as BlockRngCore>::Results: Unpin,
impl<R: ?Sized> UnwindSafe for BlockRng<R> where
R: UnwindSafe,
<R as BlockRngCore>::Results: UnwindSafe,
R: UnwindSafe,
<R as BlockRngCore>::Results: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Conv for T
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
R: 'a,
T: 'a,
Self: AsRef<T>,
R: 'a,
T: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
R: 'a,
T: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
R: 'a,
T: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
R: 'a,
T: 'a,
Self: Borrow<T>,
R: 'a,
T: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
R: 'a,
T: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
R: 'a,
T: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> TryConv for T
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,