Struct coins_bip32::ecdsa::signature::rand_core::block::BlockRng64 [−][src]
A wrapper type implementing RngCore
for some type implementing
BlockRngCore
with u64
array buffer; i.e. this can be used to implement
a full RNG from just a generate
function.
This is similar to BlockRng
, but specialized for algorithms that operate
on u64
values.
No whole generated u64
values are thrown away and all values are consumed
in-order. next_u64
simply takes the next available u64
value.
next_u32
is however a bit special: half of a u64
is consumed, leaving
the other half in the buffer. If the next function called is next_u32
then the other half is then consumed, however both next_u64
and
fill_bytes
discard the rest of any half-consumed u64
s when called.
fill_bytes
and try_fill_bytes
consume a whole number of u64
values. If the requested length is not a multiple of 8, some bytes will be
discarded.
Fields
core: R
The core part of the RNG, implementing the generate
function.
Implementations
impl<R> BlockRng64<R> where
R: BlockRngCore,
[src]
R: BlockRngCore,
pub fn new(core: R) -> BlockRng64<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 BlockRng64<R> where
R: Clone + BlockRngCore + ?Sized,
<R as BlockRngCore>::Results: Clone,
[src]
R: Clone + BlockRngCore + ?Sized,
<R as BlockRngCore>::Results: Clone,
pub fn clone(&self) -> BlockRng64<R>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<R> Debug for BlockRng64<R> where
R: BlockRngCore + Debug,
[src]
R: BlockRngCore + Debug,
impl<R> RngCore for BlockRng64<R> where
R: BlockRngCore<Item = u64>,
<R as BlockRngCore>::Results: AsRef<[u64]>,
<R as BlockRngCore>::Results: AsMut<[u64]>,
[src]
R: BlockRngCore<Item = u64>,
<R as BlockRngCore>::Results: AsRef<[u64]>,
<R as BlockRngCore>::Results: AsMut<[u64]>,
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 BlockRng64<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: <BlockRng64<R> as SeedableRng>::Seed) -> BlockRng64<R>
[src]
pub fn seed_from_u64(seed: u64) -> BlockRng64<R>
[src]
pub fn from_rng<S>(rng: S) -> Result<BlockRng64<R>, Error> where
S: RngCore,
[src]
S: RngCore,
Auto Trait Implementations
impl<R: ?Sized> RefUnwindSafe for BlockRng64<R> where
R: RefUnwindSafe,
<R as BlockRngCore>::Results: RefUnwindSafe,
R: RefUnwindSafe,
<R as BlockRngCore>::Results: RefUnwindSafe,
impl<R: ?Sized> Send for BlockRng64<R> where
R: Send,
<R as BlockRngCore>::Results: Send,
R: Send,
<R as BlockRngCore>::Results: Send,
impl<R: ?Sized> Sync for BlockRng64<R> where
R: Sync,
<R as BlockRngCore>::Results: Sync,
R: Sync,
<R as BlockRngCore>::Results: Sync,
impl<R: ?Sized> Unpin for BlockRng64<R> where
R: Unpin,
<R as BlockRngCore>::Results: Unpin,
R: Unpin,
<R as BlockRngCore>::Results: Unpin,
impl<R: ?Sized> UnwindSafe for BlockRng64<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>,