Struct IndexedCheckpoint 

#[non_exhaustive]
pub struct IndexedCheckpoint {
    pub schema_version: u32,
    pub plan_crc32: u32,
    pub fs_ops_done: bool,
    pub next_target_idx: u64,
    pub next_region_idx: u64,
    pub bytes_written: u64,
}

Indexed-apply checkpoint payload.

Emitted by the crate::index::IndexApplier::execute driver at the same per-target / per-64-regions cadence as the existing cancellation poll.

• plan_crc32 — identity of the crate::index::Plan the checkpoint was produced against, computed via crate::index::Plan::crc32. crate::index::IndexApplier::resume_execute re-computes the CRC at resume time and warns-and-restarts on mismatch (same precedent as the sequential resume’s patch_name / patch_size check).
• next_target_idx — zero-based index of the next target the driver will write into. Equal to the count of fully-written targets.
• next_region_idx — zero-based index of the next region within next_target_idx’s timeline. Zero at the target boundary; advances by 64 for each mid-target poll.
• bytes_written — cumulative bytes written across all targets and regions completed so far. Mirrors the same counter the indexed driver carries internally.
• fs_ops_done — true once every crate::index::FilesystemOp in crate::index::Plan::fs_ops has been applied. A resume that sees this true skips the fs_ops pass; otherwise it re-runs every op (each op is idempotent w.r.t. the install state the prior partial run would have left behind).

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

schema_version: u32

Layout version of this checkpoint struct. See Self::CURRENT_SCHEMA_VERSION.

plan_crc32: u32

CRC32 of the crate::index::Plan this checkpoint was produced against. See crate::index::Plan::crc32.

0 is a legitimate CRC32 output — the hash space is uniform over u32 and a real plan can hash to zero. Consumers must represent “no checkpoint yet” via Option<IndexedCheckpoint> (i.e. pass None to crate::index::IndexApplier::resume_execute); a sentinel plan_crc32: 0 would collide with that legitimate output and either trigger a spurious warn-and-restart against a plan that happens to hash to zero, or silently accept a stale checkpoint from a plan that does.

fs_ops_done: bool

true once every crate::index::FilesystemOp in crate::index::Plan::fs_ops has been applied.

next_target_idx: u64

Index of the next target to apply. Equal to the number of targets fully written at this checkpoint.

next_region_idx: u64

Index of the next region within next_target_idx’s timeline.

bytes_written: u64

Cumulative bytes written across all targets and regions completed.

Implementations

impl IndexedCheckpoint

pub const CURRENT_SCHEMA_VERSION: u32 = 2

Current schema-version constant for IndexedCheckpoint.

Bumped to 2 alongside the addition of plan_crc32 and fs_ops_done; a 1-vintage persisted checkpoint will fail check_schema_version-style validation at resume time.

pub fn new( plan_crc32: u32, fs_ops_done: bool, next_target_idx: u64, next_region_idx: u64, bytes_written: u64, ) -> Self

Construct an IndexedCheckpoint with the given fields.

Exists because the struct is #[non_exhaustive], which forbids external code from using the struct-literal syntax. Consumers hand-rolling a synthetic checkpoint (typically in tests, or when migrating a persisted checkpoint from an older schema) construct one via this method instead.

Notes

Permissive by design: any combination of fields is accepted, including pairings the indexed driver would never emit (e.g. fs_ops_done: false with next_target_idx > 0). crate::index::IndexApplier::resume_execute re-validates the checkpoint’s plan_crc32 against the plan it is handed, and re-runs every step that has not been confirmed durable; a contradictory checkpoint either matches a re-derivable resume state or triggers the warn-and-restart path on CRC mismatch.

Trait Implementations

impl Clone for IndexedCheckpoint

fn clone(&self) -> IndexedCheckpoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndexedCheckpoint

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

Formats the value using the given formatter.

impl PartialEq for IndexedCheckpoint

fn eq(&self, other: &IndexedCheckpoint) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for IndexedCheckpoint

impl StructuralPartialEq for IndexedCheckpoint