Struct Producer 

pub struct Producer<T> { /* private fields */ }

Publishes a JSON value over a track, choosing snapshots and deltas automatically.

An Encoder that owns its track: it writes each encoded frame and rolls a group whenever the encoder emits a snapshot. When something else already owns the track, use the Encoder directly.

Cheaply clonable: clones share one underlying track and publishing state, like other MoQ producers.

Implementations

impl<T> Producer<T>

pub fn consume(&self) -> Subscriber

Create a subscriber for the underlying track.

pub fn is_used(&self) -> bool

Whether any consumer for the underlying track currently exists.

The demand signal for a producer serving on request: an unused track is cached state nobody is watching, safe to drop and recreate on the next request.

impl<T: Serialize> Producer<T>

pub fn new(track: Producer, config: ProducerConfig) -> Self

Create a producer that publishes to the given track.

pub fn update(&mut self, value: &T) -> Result<()>

Publish a new value, emitting a snapshot or a delta automatically.

Does nothing if the value is unchanged from the previous publish.

pub fn lock(&mut self) -> Guard<'_, T>

where T: Default + DeserializeOwned,

Lock the current value for in-place editing, publishing on drop.

The returned Guard derefs to the current value: everything published through this producer so far, composed, or T::default() if nothing has been. Editing it through DerefMut marks the guard dirty; when a dirty guard drops it publishes the result, a no-op if unchanged.

After a rejected frame the current value is what the producer last tried to publish, which consumers never received. That is deliberate. The guard exists so independent owners can each edit their own field without clobbering, and dropping a rejected owner’s field would clobber it for whoever edits next, which is the failure this API exists to prevent. The owner whose write failed sees the error and can act on it; the next successful publish is a full snapshot carrying the composed value, so consumers converge on it either way.

This is the counterpart to a callback: hold the guard, mutate, drop. The guard holds the producer’s lock for its lifetime, so independent owners are serialized: each one starts from the latest value and their changes compose instead of clobbering. Don’t hold a guard across an .await, since that keeps the lock held while suspended.

Publishing on drop can fail (a closed track, a value that won’t serialize) and only logs a warning. Call Guard::commit instead to handle the error.

pub fn finish(&mut self) -> Result<()>

Finish the track, closing any open group.

Trait Implementations

impl<T> Clone for Producer<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.