Struct BlockSync 

pub struct BlockSync { /* private fields */ }

One editor’s standing with its block: the value it holds and the history revision it was last in step at, so a frame in which nothing changed costs one integer comparison.

Implementations

impl BlockSync

pub fn new(block: Block) -> Self

pub fn block(&self) -> Block

pub fn unreported(&mut self, lines: Vec<String>) -> Vec<String>

Which of lines this block has not already reported, remembering the set for next time.

An UNLINKED component is a STANDING state, not an event: the fold reports it on every sheet edit, and one toast per keystroke is noise. A problem that goes and comes back is reported again, which is right — it is news both times.

pub fn store( &mut self, history: &mut History, value: Value, coalesce: Option<&str>, ) -> Result<(), String>

Write an edit the editor reported: value is the editor’s document (to_value), coalesce its Change::coalesce. Refused while the block is Self::unreadable.

pub fn pulled(&self) -> bool

Whether Self::pull has run at all: false until the editor first loads this block, which is the document’s OPEN as far as the editor can tell (a document is built with its syncs, and a load builds a document).

pub fn adopt( &mut self, history: &mut History, document: &Value, value: Value, ) -> Result<(), String>

Write value as the block with NO undo step: document is the whole saved document with value already in it, adopted as it stands. For what the editor did to a block the frame it first loaded it — an older file brought up to the current shape, which is part of opening it and not an edit anyone made (see viewport::ecad::store). Refused while the block is Self::unreadable, as Self::store is.

pub fn pull(&mut self, history: &History) -> Option<Option<Value>>

The host’s copy when the editor does not hold it: Some(Some(block)), or Some(None) when the block is absent (never written, or undone past its first edit), for the editor to load its empty document. None when the editor is in step. The first call always loads.

Every Some clears Self::unreadable, so the caller owes this after EACH Some(Some(block)): try to read it (from_value) and call Self::refuse if that fails. Refusing once and not again on a later Some lets the stand-in the editor shows be stored over the block.

pub fn hold_unwritten(&mut self, history: &History, value: Value)

On a read-only document, the editor’s first frame brought the block up to the current shape: keep that on screen as held, unwritten. The saved bytes do not move (History::lock), and the next pull does not undo what the editor showed on opening.

pub fn reload(&mut self)

On a read-only document an edit is taken back: the next Self::pull loads the stored block again whatever the editor holds.

pub fn reloads(&self) -> u64

How many edits a read-only document has taken back from this editor.

pub fn refused_again(&mut self, value: &Value) -> bool

Whether value is the edit a read-only document refused last time, so an editor that reports the same change every frame is told once.

pub fn refuse(&mut self, reason: String)

The editor could not read the block Self::pull just handed it.

pub fn unreadable(&self) -> Option<&str>

Why the block is not being edited, while the editor cannot read it.

Trait Implementations

impl Debug for BlockSync

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

Formats the value using the given formatter.