# [−][src]Struct rand_core::block::BlockRng64

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.

## Methods

`impl<R: BlockRngCore> BlockRng64<R>`

[src]

`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: BlockRngCore<Item = u64>> RngCore for BlockRng64<R> where`

<R as BlockRngCore>::Results: AsRef<[u64]> + AsMut<[u64]>,

[src]

<R as BlockRngCore>::Results: AsRef<[u64]> + AsMut<[u64]>,

`fn next_u32(&mut self) -> u32`

[src]

`fn next_u64(&mut self) -> u64`

[src]

`fn fill_bytes(&mut self, dest: &mut [u8])`

[src]

`fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>`

[src]

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

[src]

`type Seed = R::Seed`

Seed type, which is restricted to types mutably-dereferencable as `u8`

arrays (we recommend `[u8; N]`

for some `N`

). Read more

`fn from_seed(seed: Self::Seed) -> Self`

[src]

`fn seed_from_u64(seed: u64) -> Self`

[src]

`fn from_rng<S: RngCore>(rng: S) -> Result<Self, Error>`

[src]

`fn from_entropy() -> Self`

[src]

Creates a new instance of the RNG seeded via [`getrandom`

]. Read more

`impl<R: Clone + BlockRngCore + ?Sized> Clone for BlockRng64<R> where`

R::Results: Clone,

[src]

R::Results: Clone,

`fn clone(&self) -> BlockRng64<R>`

[src]

`fn clone_from(&mut self, source: &Self)`

1.0.0[src]

Performs copy-assignment from `source`

. Read more

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

[src]

`impl<R: BlockRngCore + ?Sized> Serialize for BlockRng64<R> where`

R: Serialize,

R::Results: Serialize,

[src]

R: Serialize,

R::Results: Serialize,

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

__S: Serializer,

[src]

__S: Serializer,

`impl<'de, R: BlockRngCore + ?Sized> Deserialize<'de> for BlockRng64<R> where`

R: Deserialize<'de>,

R::Results: Deserialize<'de>,

[src]

R: Deserialize<'de>,

R::Results: Deserialize<'de>,

`fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where`

__D: Deserializer<'de>,

[src]

__D: Deserializer<'de>,

## Auto Trait Implementations

`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> 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> RefUnwindSafe for BlockRng64<R> where`

R: RefUnwindSafe,

<R as BlockRngCore>::Results: RefUnwindSafe,

R: RefUnwindSafe,

<R as BlockRngCore>::Results: RefUnwindSafe,

`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> From<T> for T`

[src]

`impl<T, U> Into<U> for T where`

U: From<T>,

[src]

U: From<T>,

`impl<T> ToOwned for T where`

T: Clone,

[src]

T: Clone,

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`

[src]

`fn clone_into(&self, target: &mut T)`

[src]

`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.

`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>,

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

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

[src]

`impl<T> BorrowMut<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

`fn borrow_mut(&mut self) -> &mut T`

[src]

`impl<T> Borrow<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

`impl<T> Any for T where`

T: 'static + ?Sized,

[src]

T: 'static + ?Sized,

`impl<T> DeserializeOwned for T where`

T: Deserialize<'de>,

[src]

T: Deserialize<'de>,