# BlockRng64 in rand_core::block - Rust
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.
Keywords: rust, rustlang, rust-lang, BlockRng64

# Struct rand_core::block::BlockRng64

source · [−]

    pub struct BlockRng64<R: BlockRngCore + ?Sized> {
        pub core: R,
        /* private fields */
    }

Expand description

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

source

### impl<R: BlockRngCore> BlockRng64<R>

source

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

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

source

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

source

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

source

#### pub fn generate_and_set(&mut self, index: usize)

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

## Trait Implementations

source

### impl<R: Clone + BlockRngCore + ?Sized> Clone for BlockRng64<R> where
R::Results: Clone,

source

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

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

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

source

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

Formats the value using the given formatter. Read more

source

### impl<R: BlockRngCore<Item = u64>> RngCore for BlockRng64<R> where
<R as BlockRngCore>::Results: AsRef<[ u64 ]> + AsMut<[ u64 ]>,

source

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

Return the next random `u32`. Read more

source

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

Return the next random `u64`. Read more

source

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

Fill `dest` with random data. Read more

source

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

Fill `dest` entirely with random data. Read more

source

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

#### 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

source

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

Create a new PRNG using the given seed. Read more

source

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

Create a new PRNG using a `u64` seed. Read more

source

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

Create a new PRNG seeded from another `Rng`. Read more

source

#### fn from_entropy() -> Self

Creates a new instance of the RNG seeded via `getrandom`. Read more

## Auto Trait Implementations

### impl<R: ?Sized> RefUnwindSafe for BlockRng64<R> where
R: RefUnwindSafe,
<R as BlockRngCore>::Results: RefUnwindSafe,

### impl<R: ?Sized> Send for BlockRng64<R> where
R: Send,
<R as BlockRngCore>::Results: Send,

### impl<R: ?Sized> Sync for BlockRng64<R> where
R: Sync,
<R as BlockRngCore>::Results: Sync,

### impl<R: ?Sized> Unpin for BlockRng64<R> where
R: Unpin,
<R as BlockRngCore>::Results: Unpin,

### impl<R: ?Sized> UnwindSafe for BlockRng64<R> where
R: UnwindSafe,
<R as BlockRngCore>::Results: UnwindSafe,

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

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

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

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

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

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

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

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

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

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

The type returned in the event of a conversion error.

const: unstable · source

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

Performs the conversion.