Struct DocWriter 

pub struct DocWriter { /* private fields */ }

Persists one owner’s live document; see the module docs. Failures are sticky: after one, DocWriter::request sends nothing until a DocWriter::request_checkpoint full save becomes durable.

A disabled writer persists nothing and reports why, so an app without usable storage runs on the same code path.

Implementations

impl DocWriter

pub fn try_start(owner: &Rc<DocOwner>) -> Result<DocWriter, StoreError>

Claim the owner’s one writer, continuing from its accepted document, or from nothing when the owner holds a new one.

Errors

StoreError::WriterBusy while another writer for this owner lives.

pub fn start_new( owner: &Rc<DocOwner>, doc: &mut AutoCommit, ) -> Result<DocWriter, StoreError>

Start the writer for a new document and submit its first full save.

Errors

As Self::try_start, or when the store refuses the first write; the claim is released either way.

pub fn disabled(reason: impl Into<String>) -> DocWriter

A writer that persists nothing; Self::last_error carries reason.

pub fn is_enabled(&self) -> bool

pub fn owner(&self) -> Option<&DocOwner>

The owner this writer persists through; None when disabled.

pub fn package_id(&self) -> &str

The package whose document this is; empty when disabled.

pub fn document_path(&self) -> &Path

See [DocOwner::label]; empty when disabled.

pub fn seed(&mut self, doc: &mut AutoCommit)

Treat doc as exactly what is already stored: its heads are durable and later requests append only what follows them.

pub fn request(&mut self, doc: &mut AutoCommit)

Submit the changes doc has beyond what was last submitted. Cheap when nothing changed. Does nothing while a failure is outstanding, so a failed writer never closes the caller’s typing transaction.

pub fn offer(&mut self, doc: &mut AutoCommit) -> Result<(), String>

Offer current changes without waiting for host acknowledgement. An accepted replacement may still have a sticky durability failure until its own revision is acknowledged; that is not a submission refusal.

Errors

Returns a disabled writer or a synchronous store submission refusal.

pub fn request_checkpoint(&mut self, doc: &mut AutoCommit)

Submit the full current document regardless of what was submitted before — the one write that clears an outstanding failure.

pub fn save(&mut self, doc: &mut AutoCommit)

Self::request normally, Self::request_checkpoint after a failure.

pub fn durability_snapshot(&self) -> DurabilitySnapshot

What is durable and whether a failure is outstanding, without submitting or closing anything.

pub fn last_error(&self) -> Option<String>

pub fn try_flush(&self) -> Result<(), String>

Ask the store to commit everything submitted and report the outcome.

Errors

The outstanding failure, or writes the store could not yet commit.

pub fn flush(&self)

Self::try_flush, logging a failure instead of returning it. Does nothing for a disabled writer.

pub fn full_writes(&self) -> usize

pub fn appends(&self) -> usize

Trait Implementations

impl Drop for DocWriter

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.