Struct SyncEngine 

pub struct SyncEngine<S, D> { /* private fields */ }

Available on crate feature sync only.

Sync engine for bidirectional state synchronization

The engine is generic over:

• S: The state type being synchronized
• D: The diff type for that state

The engine manages:

• Version tracking via SyncTracker
• State snapshots for diff computation
• Diff generation and application

Implementations

impl<S: Clone, D> SyncEngine<S, D>

pub fn new( encode_diff: fn(&D) -> Vec<u8>, decode_diff: fn(&[u8]) -> Result<D, String>, compute_diff: fn(&S, &S) -> D, apply_diff: fn(&mut S, &D) -> Result<(), String>, is_diff_empty: fn(&D) -> bool, ) -> Self

Create a new sync engine with the required callbacks

pub fn init(&mut self, initial_state: S)

Initialize the engine with initial state

pub fn is_initialized(&self) -> bool

Check if the engine is initialized

pub fn state(&self) -> Option<&S>

Get a reference to the current state

pub fn state_mut(&mut self) -> Option<&mut S>

Get a mutable reference to the current state

Note: After modifying, call mark_changed() to bump version

pub fn mark_changed(&mut self) -> u64

Mark that the local state has changed

Call this after modifying the state to bump the version.

pub fn update_state(&mut self, new_state: S) -> u64

Update local state and bump version atomically

pub fn tracker(&self) -> &SyncTracker

Get the tracker for inspection

pub fn has_pending_updates(&self) -> bool

Check if we have updates to send

pub fn needs_ack(&self) -> bool

Check if we need to send an ack

pub fn generate_message(&mut self) -> Result<Option<SyncMessage>, SyncError>

Generate a sync message to send to peer

Returns None if there’s nothing to send

pub fn generate_ack(&self) -> Result<SyncMessage, SyncError>

Generate an ack-only message

pub fn process_message( &mut self, msg: &SyncMessage, ) -> Result<ProcessResult, SyncError>

Process an incoming sync message

Returns the result of processing

pub fn current_version(&self) -> u64

Get current local version

pub fn peer_version(&self) -> u64

Get peer’s version

pub fn is_synchronized(&self) -> bool

Check if synchronized with peer

pub fn reset(&mut self)

Reset the engine