Struct ChaCha8State 

pub struct ChaCha8State {
    pub seed: [u8; 32],
    pub bytes_consumed: u16,
}

Snapshot of the state of a ChaCha8Rand instance.

Created with ChaCha8Rand::clone_state and used by ChaCha8Rand::try_restore_state. It simply records the seed of the current iteration of the generator and how many output bytes of that iteration have already been consumed. Restoring from it is effectively the same as calling rng.set_seed(&seed) and then throwing away bytes_consumed many bytes of output. However, going through ChaCha8Rand::try_restore_state can catch some possible mistakes because it validates that bytes_consumed is in the range it should be.

Possible use cases include:

• Saving and restoring the RNG state as part of a game’s (auto-)save feature.
• Suspending and later resume a long-running computation by saving the RNG (and all other state) to disk.
• Forking a randomized algorithm, running it twice with the same randomness but handling different input, to see how they diverge (e.g., “what if” queries).

There are no serde impls. Instead, the fields are public so you can (de-)serialize them in any way you see fit. In this case you should be prepared to handle errors due to out-of-range bytes_consumed values gracefully.

Nothing stops you from constructing a ChaCha8State out of thin air (rather than cloning from an existing generator), but there’s probably no reason to do so. You can supply a new seed directly with ChaCha8Rand::new or ChaCha8Rand::set_seed.

Finally, note that ChaCha8Rand also implements Clone. Cloning a generator achieves the same effect as taking a snapshot of its state and restoring from it, but the generator is much larger because it includes a big buffer of output. If you want to duplicate a generator and consume output from both copies, cloning is easier and doesn’t have to re-compute the output that’s already buffered. But if you store several snapshots and possibly use some of them at a later time, cloning would waste a lot of memory.

Examples

let state = rng.clone_state();
let first_output = rng.read_u64();
rng.try_restore_state(&state).expect("snapshot is valid because it was not modified");
assert_eq!(rng.read_u64(), first_output);

Fields

seed: [u8; 32]

The seed of the current ChaCha8Rand iteration.

bytes_consumed: u16

How much output from the current ChaCha8Rand iteration was already consumed.

Trait Implementations

impl Clone for ChaCha8State

fn clone(&self) -> ChaCha8State

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChaCha8State

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

Formats the value using the given formatter.

impl Copy for ChaCha8State