Struct `BlockRng64`

struct BlockRng64<R: BlockRngCore + ?Sized> { ... }

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 u64s when called.

fill_bytes consumes 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: BlockRngCore> BlockRng64<R>`

fn new(core: R) -> BlockRng64<R>

Create a new BlockRng from an existing RNG implementing BlockRngCore. Results will be generated on first use.

fn index(self: &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.

fn reset(self: &mut Self)

Reset the number of available results. This will force a new set of results to be generated on next use.

fn generate_and_set(self: &mut Self, index: usize)

Generate a new set of results immediately, setting the index to the given value.

`impl<'de, R> Deserialize for BlockRng64<R>`

fn deserialize<__D>(__deserializer: __D) -> Result<Self, <__D as >::Error> where __D: Deserializer<'de>

`impl<R> Freeze for BlockRng64<R>`

`impl<R> RefUnwindSafe for BlockRng64<R>`

`impl<R> Send for BlockRng64<R>`

`impl<R> Serialize for BlockRng64<R>`

fn serialize<__S>(self: &Self, __serializer: __S) -> Result<<__S as >::Ok, <__S as >::Error> where __S: Serializer

`impl<R> Sync for BlockRng64<R>`

`impl<R> TryCryptoRng for BlockRng64<R>`

`impl<R> TryRngCore for BlockRng64<R>`

fn try_next_u32(self: &mut Self) -> Result<u32, <R as TryRngCore>::Error>
fn try_next_u64(self: &mut Self) -> Result<u64, <R as TryRngCore>::Error>
fn try_fill_bytes(self: &mut Self, dst: &mut [u8]) -> Result<(), <R as TryRngCore>::Error>

`impl<R> Unpin for BlockRng64<R>`

`impl<R> UnsafeUnpin for BlockRng64<R>`

`impl<R> UnwindSafe for BlockRng64<R>`

`impl<R: $crate::clone::Clone + BlockRngCore + ?Sized> Clone for BlockRng64<R>`

fn clone(self: &Self) -> BlockRng64<R>

`impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng64<R>`

fn from_seed(seed: <Self as >::Seed) -> Self
fn seed_from_u64(seed: u64) -> Self
fn from_rng<impl RngCore: RngCore>(rng: &mut impl RngCore) -> Self
fn try_from_rng<S: TryRngCore>(rng: &mut S) -> Result<Self, <S as >::Error>

`impl<R: BlockRngCore + fmt::Debug> Debug for BlockRng64<R>`

fn fmt(self: &Self, fmt: &mut Formatter<'_>) -> Result

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

fn next_u32(self: &mut Self) -> u32
fn next_u64(self: &mut Self) -> u64
fn fill_bytes(self: &mut Self, dest: &mut [u8])

`impl<R: CryptoBlockRng + BlockRngCore<Item = u64>> CryptoRng for BlockRng64<R>`

`impl<T> Any for BlockRng64<R>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BlockRng64<R>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for BlockRng64<R>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for BlockRng64<R>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> DeserializeOwned for BlockRng64<R>`

`impl<T> From for BlockRng64<R>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for BlockRng64<R>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for BlockRng64<R>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for BlockRng64<R>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for BlockRng64<R>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>