Struct Synced 

pub struct Synced { /* private fields */ }

A document as markdown and as blocks, each kept up with the other.

Every block owns a range of the text. The ranges partition it in block order, each running from where the parser starts its block to where it starts the next, and a block that is not written owns an empty one. Read back, the text gives the blocks with their texts normalized.

Self::set_doc rewrites the text of the blocks that changed and leaves every other byte as it was. Self::set_text reads again the blocks whose text changed. Each works on a window of top-level blocks around the change, read back with the top-level block on either side of it and widened until those read as they did, up to the whole document.

Implementations

impl Synced

pub fn new(text: impl Into<String>, marks: &Marks) -> Self

pub fn text(&self) -> &str

pub fn doc(&self) -> &Rc<Doc>

pub fn ranges(&self) -> &[Range<usize>]

Each block’s range of Self::text, in block order.

pub fn set_doc(&mut self, doc: Rc<Doc>)

The blocks are now doc. The blocks that differ from the ones before are written again.

pub fn set_text(&mut self, text: &str)

The text is now text. The blocks whose text changed are read again.

pub fn offsets(&mut self, at: &[Cursor]) -> Vec<Option<usize>>

Where each of at lands in the text, None for one this cannot place.

The top-level blocks holding them are written again, with the positions in, as crate::serialize_at_many writes a document: a trailing space with a position after it is no longer trailing, and stays.

pub fn cursors(&self, offsets: &[usize]) -> Vec<Option<Cursor>>

The position each of offsets stands for, None for one this cannot place — see crate::parse_at_many.