# Struct bonsaidb::local::argon2::password_hash::rand_core::block::BlockRng64

source · ```
pub struct BlockRng64<R>where
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> BlockRng64<R>where
R: BlockRngCore,

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

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

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

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

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

#### 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 for BlockRng64<R>

### impl<R> Clone for BlockRng64<R>

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

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

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

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

`source`

. Read moresource§### impl<R> Debug for BlockRng64<R>where
R: BlockRngCore + Debug,

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

source§### impl<R> RngCore for BlockRng64<R>

### impl<R> RngCore for BlockRng64<R>

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

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

`dest`

with random data. Read moresource§### impl<R> SeedableRng for BlockRng64<R>where
R: BlockRngCore + SeedableRng,

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

§#### type Seed = <R as SeedableRng>::Seed

#### type Seed = <R as SeedableRng>::Seed

`u8`

arrays (we recommend `[u8; N]`

for some `N`

). Read moresource§#### fn from_seed(seed: <BlockRng64<R> as SeedableRng>::Seed) -> BlockRng64<R>

#### fn from_seed(seed: <BlockRng64<R> as SeedableRng>::Seed) -> BlockRng64<R>

source§#### fn seed_from_u64(seed: u64) -> BlockRng64<R>

#### fn seed_from_u64(seed: u64) -> BlockRng64<R>

`u64`

seed. Read moresource§#### fn from_rng<S>(rng: S) -> Result<BlockRng64<R>, Error>where
S: RngCore,

#### fn from_rng<S>(rng: S) -> Result<BlockRng64<R>, Error>where
S: RngCore,

`Rng`

. Read moresource§#### fn from_entropy() -> Self

#### fn from_entropy() -> Self

## Auto Trait Implementations§

### impl<R: ?Sized> RefUnwindSafe for BlockRng64<R>

### impl<R: ?Sized> Send for BlockRng64<R>

### impl<R: ?Sized> Sync for BlockRng64<R>

### impl<R: ?Sized> Unpin for BlockRng64<R>

### impl<R: ?Sized> UnwindSafe for BlockRng64<R>

## Blanket Implementations§

§### impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,

### impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,

§### impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,

### impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

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

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

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

§### impl<T> Instrument for T

### impl<T> Instrument for T

§#### fn instrument(self, span: Span) -> Instrumented<Self>

#### fn instrument(self, span: Span) -> Instrumented<Self>

§#### fn in_current_span(self) -> Instrumented<Self>

#### fn in_current_span(self) -> Instrumented<Self>

source§### impl<R> Rng for R

### impl<R> Rng for R

source§#### fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,

#### fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,

source§#### fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,

#### fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,

source§#### fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,

#### fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,

source§#### fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,

#### fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,

source§#### fn gen_bool(&mut self, p: f64) -> bool

#### fn gen_bool(&mut self, p: f64) -> bool

`p`

of being true. Read moresource§#### fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool

#### fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool

`numerator/denominator`

of being
true. I.e. `gen_ratio(2, 3)`

has chance of 2 in 3, or about 67%, of
returning true. If `numerator == denominator`

, then the returned value
is guaranteed to be `true`

. If `numerator == 0`

, then the returned
value is guaranteed to be `false`

. Read more