Struct Publisher 

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

The sending end of a gyre channel.

Publisher is responsible for sending events to the shared ring buffer. It is Send and Sync, and can be cloned to support multiple concurrent producers. The channel is closed when the last Publisher (including all its clones) is dropped.

Implementations

impl<T> Publisher<T>

pub async fn publish(&self, event: T) -> Result<(), T>

Asynchronously publishes an event to the channel.

This method first claims an exclusive slot in the ring buffer, then waits if necessary for the slowest consumer to advance (asynchronous backpressure). Once a slot is confirmed to be free, it writes the event and makes it visible to all consumers.

Arguments

• event: The event to be published.

Returns

• Ok(()): If the event was successfully published.
• Err(T): If there are currently no active Consumers. In this case, the event is not published and is returned to the caller.

Cancellation Safety

This method is cancellation safe. A publisher task first acquires a temporary, exclusive lock to “claim” a slot. If the future is cancelled at any await point (e.g., while waiting for backpressure), the lock is automatically released, and the global state remains consistent. No sequence number “gap” is created.

The next publisher will simply acquire the lock and attempt to publish to the same slot. It is safe to use this method in tokio::select!, timeouts, etc.

pub async fn subscribe(&self) -> Consumer<T>

Dynamically subscribes a new Consumer to the event bus.

The newly created Consumer will receive all events that are newly published after this method call completes. It will not receive any historical events that were already in the ring buffer before the subscription.

This is different from consumer.clone(), which creates a copy that starts consuming from the same position.

Returns

A new Consumer instance.

Cancellation Safety

This method is cancellation safe. If the future is cancelled, it will be before any changes to the shared state are made. The new consumer is only registered with the bus after all await points have completed. It is safe to use this method in contexts like tokio::select!.

Trait Implementations

impl<T> Clone for Publisher<T>

fn clone(&self) -> Self

Clones a Publisher.

All cloned Publisher instances share the same publish sequence number, allowing multiple producers to publish to the same channel in a thread-safe manner.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Publisher<T>

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

Formats the value using the given formatter.