Struct trillium_channels::ChannelConn

pub struct ChannelConn<'a> { /* fields omitted */ }

A ChannelConn is a wrapper around a WebSocketConn that also contains a ChannelClient

It that provides convenient access to functions from the ChannelClient held in the WebSocketConn’s StateSet, and dereferences to the WebSocketConn for other functionality.

Implementations

impl ChannelConn<'_>

pub fn client(&self) -> Option<&ChannelClient>

Borrow the channel client

pub fn conn(&self) -> &WebSocketConn

Borrow the websocket conn

pub fn broadcast(&self, event: impl Into<ChannelEvent>)

Send a ChannelEvent to all connected clients. Note that these messages will only reach clients that subscribe to the event’s topic.

pub async fn send_event(&self, event: impl Into<ChannelEvent>)

Send a ChannelEvent to this specific client. Note that this message will only be received if the client subscribes to the event’s topic.

pub async fn reply_ok(&self, event: &ChannelEvent, response: &impl Serialize)

Send an ok reply in reference to the provided ChannelEvent with the provided response payload.

Note that this sets the event as "phx_reply" and the payload as {"status": "ok", "response": response }, as well as setting the reference field.

pub async fn reply_error(&self, event: &ChannelEvent, error: &impl Serialize)

Send an error reply in reference to the provided ChannelEvent with the provided response payload.

Note that this sets the event as "phx_error" as well as setting the reference field.

pub async fn allow_join(&self, event: &ChannelEvent, value: &impl Serialize)

Join a topic, sending an ok reply with the provided optional value. This sends an ok reply to the client as well as adding the topic to the client’s subscriptions.

pub async fn allow_leave(&self, event: &ChannelEvent, payload: &impl Serialize)

Leave a topic as requested by the provided channel event, including the optional payload. This sends an ok reply to the client as well as removing the channel from the client’s subscriptions.

Methods from Deref<Target = WebSocketConn>

pub async fn send_string(&'_ mut self, string: String)

send a [Message::Text] variant

pub async fn send_bytes(&'_ mut self, bin: Vec<u8, Global>)

send a [Message::Binary] variant

pub async fn send_json(
    &'_ mut self,
    json: &'_ impl Serialize
) -> Result<(), Error>

send a [Message::Text] that contains json note that json messages are not actually part of the websocket specification

pub async fn send(&'_ mut self, message: Message) -> Result<(), Error>

Sends a [Message] to the client

pub fn stopper(&self) -> Stopper

retrieve a clone of the server’s [Stopper]

pub async fn close(&'_ mut self) -> Result<(), Error>

close the websocket connection gracefully

pub fn headers(&self) -> &Headers

retrieve the request headers for this conn

pub fn path(&self) -> &str

retrieves the path part of the request url, up to and excluding any query component

pub fn querystring(&self) -> &str

Retrieves the query component of the path, excluding ?. Returns an empty string if there is no query component.

pub fn method(&self) -> Method

retrieve the request method for this conn

pub fn state<T>(&self) -> Option<&T> where
    T: 'static, 

retrieve state from the state set that has been accumulated by trillium handlers run on the trillium::Conn before it became a websocket. see trillium::Conn::state for more information

pub fn state_mut<T>(&mut self) -> Option<&mut T> where
    T: 'static, 

retrieve a mutable borrow of the state from the state set

pub fn set_state<T>(&mut self, val: T) where
    T: 'static + Send + Sync, 

set state on this connection

pub fn take_state<T>(&mut self) -> Option<T> where
    T: 'static, 

take some type T out of the state set that has been accumulated by trillium handlers run on the trillium::Conn before it became a websocket. see trillium::Conn::take_state for more information

pub fn take_inbound_stream(
    &mut self
) -> Option<impl Stream<Item = Result<Message, Error>>>

take the inbound Message stream from this conn

pub fn inbound_stream(
    &mut self
) -> Option<impl Stream<Item = Result<Message, Error>>>

borrow the inbound Message stream from this conn

Trait Implementations

impl<'a> Debug for ChannelConn<'a>

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

Formats the value using the given formatter.

impl Deref for ChannelConn<'_>

type Target = WebSocketConn

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> DerefMut for ChannelConn<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.