Struct StateManager 

pub struct StateManager { /* private fields */ }

Tracks the last published state so changes can go out as patches.

let mut states = StateManager::new();
let notes = "the document the user is editing, at some length";

// First publish: a snapshot, whatever the size.
let first = states.publish(json!({"step": 1, "notes": notes}))?;
assert!(matches!(first, StatePublish::Snapshot(_)));

// One field of a large document: a patch, because it is smaller.
let second = states.publish(json!({"step": 2, "notes": notes}))?;
assert_eq!(
    second,
    StatePublish::Delta(vec![PatchOperation::replace("/step", 2)])
);

// A small document changing wholesale: back to a snapshot, because the
// patch would be bigger than the state it describes.
let mut small = StateManager::new();
small.publish(json!({"a": 1}))?;
assert_eq!(
    small.publish(json!({"b": 2}))?,
    StatePublish::Snapshot(json!({"b": 2}))
);

Implementations

impl StateManager

pub fn new() -> Self

A manager that has published nothing yet.

pub fn published(&self) -> Option<&Value>

The last published state, or None before the first publish.

pub fn reset(&mut self)

Forgets the last publish, so the next one is a snapshot again.

Call this after emitting a STATE_SNAPSHOT by hand, or after a reconnect where the client’s copy is no longer known.

pub fn publish(&mut self, next: Value) -> Result<StatePublish>

Decides how to publish next and records it as the new baseline.

Returns StatePublish::Unchanged when nothing moved, so callers can skip emitting entirely.

Trait Implementations

impl Clone for StateManager

fn clone(&self) -> StateManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StateManager

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

Formats the value using the given formatter.

impl Default for StateManager

fn default() -> StateManager

Returns the “default value” for a type.