Struct EmbedCheckpoint 

pub struct EmbedCheckpoint {

    pub version: u32,
    pub created_at: u64,
    pub updated_at: u64,
    pub repo_id: CheckpointRepoId,
    pub repo_path: String,
    pub settings_hash: String,
    pub processed_files: BTreeSet<String>,
    pub remaining_files: Vec<String>,
    pub chunks_by_file: BTreeMap<String, Vec<ChunkReference>>,
    pub total_chunks: usize,
    pub total_tokens: u64,
    pub failed_files: BTreeMap<String, String>,
    pub phase: CheckpointPhase,
    pub integrity_hash: String,
}

Checkpoint state for embedding operations

Fields

version: u32

Format version for forward compatibility

created_at: u64

When this checkpoint was created (Unix timestamp)

updated_at: u64

When this checkpoint was last updated

repo_id: CheckpointRepoId

Repository identifier (bincode-compatible version)

repo_path: String

Repository root path (for validation)

settings_hash: String

Hash of the settings used (for validation)

processed_files: BTreeSet<String>

Files that have been fully processed

remaining_files: Vec<String>

Files remaining to process (for progress tracking)

chunks_by_file: BTreeMap<String, Vec<ChunkReference>>

Chunks generated so far (stored by file for efficient resume)

total_chunks: usize

Total chunks generated

total_tokens: u64

Total tokens across all chunks

failed_files: BTreeMap<String, String>

Files that failed processing (with error messages)

phase: CheckpointPhase

Current phase of processing

integrity_hash: String

Integrity hash of checkpoint content

Implementations

impl EmbedCheckpoint

pub fn new( repo_path: &Path, repo_id: RepoIdentifier, settings: &EmbedSettings, ) -> Self

Create a new checkpoint for a repository

pub fn set_files(&mut self, files: Vec<String>)

Set the list of files to process

pub fn mark_file_processed(&mut self, file: &str, chunks: &[EmbedChunk])

Record that a file has been processed

pub fn mark_file_failed(&mut self, file: &str, error: &str)

Record that a file failed processing

pub fn set_phase(&mut self, phase: CheckpointPhase)

Set the current processing phase

pub fn is_chunking_complete(&self) -> bool

Check if all files have been processed

pub fn progress_percent(&self) -> u32

Get progress as a percentage (0-100)

pub fn files_processed(&self) -> usize

Get number of files processed

pub fn files_remaining(&self) -> usize

Get number of files remaining

pub fn files_failed(&self) -> usize

Get number of files that failed

pub fn validate( &self, repo_path: &Path, settings: &EmbedSettings, ) -> Result<(), CheckpointError>

Validate that this checkpoint matches the given settings and repo

pub fn compute_integrity(&mut self)

Compute integrity hash for the checkpoint

pub fn verify_integrity(&self) -> bool

Verify integrity hash

Trait Implementations

impl Clone for EmbedCheckpoint

fn clone(&self) -> EmbedCheckpoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EmbedCheckpoint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EmbedCheckpoint

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&EmbedCheckpoint> for CheckpointStats

fn from(cp: &EmbedCheckpoint) -> Self

Converts to this type from the input type.

impl Serialize for EmbedCheckpoint

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

where __S: Serializer,

Serialize this value into the given Serde serializer.