Struct IncrementalCheckpointChain 

pub struct IncrementalCheckpointChain {
    pub base_snapshot_token: String,
    pub incremental_tokens: Vec<String>,
    pub total_delta_entries: u64,
    pub is_complete: bool,
}

Incremental checkpoint chain information

Fields

base_snapshot_token: String

Base snapshot token (the full snapshot this chain starts from)

incremental_tokens: Vec<String>

List of incremental checkpoint tokens in order

total_delta_entries: u64

Total number of delta entries across all incremental checkpoints

is_complete: bool

Whether the chain is complete (valid from base to latest)

Implementations

impl IncrementalCheckpointChain

pub fn new(base_snapshot_token: CheckpointToken) -> Self

Create a new chain starting from a base snapshot

pub fn add_incremental(&mut self, token: CheckpointToken, num_entries: u64)

Add an incremental checkpoint to the chain

pub fn latest_token(&self) -> Result<CheckpointToken>

Get the latest token in the chain (or base if no incrementals)

pub fn num_incrementals(&self) -> usize

Get number of incremental checkpoints in the chain

pub fn serialize_json(&self) -> Result<Vec<u8>>

Serialize to JSON bytes

pub fn deserialize_json(data: &[u8]) -> Result<Self>

Deserialize from JSON bytes

pub fn write_to_file(&self, path: &Path) -> Result<()>

Write to file (JSON format)

pub fn read_from_file(path: &Path) -> Result<Self>

Read from file (JSON format)

Trait Implementations

impl Clone for IncrementalCheckpointChain

fn clone(&self) -> IncrementalCheckpointChain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IncrementalCheckpointChain

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IncrementalCheckpointChain

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for IncrementalCheckpointChain

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

where __S: Serializer,

Serialize this value into the given Serde serializer.