Struct ClientConn

pub struct ClientConn<S> { /* private fields */ }

The ClientConn manages the connection between you and a Cord Broker.

Using a generic Sink (S) allows us to build mocks for testing. However for normal use, it is strongly recommended to use the type alias, Client.

Implementations

impl<S> ClientConn<S>

where S: Sink<Message, Error = Error> + Unpin,

pub async fn connect<A>(addr: A) -> Result<Client>

where A: ToSocketAddrs,

Connect to a broker

pub async fn provide(&mut self, namespace: Pattern) -> Result<()>

Inform the broker that you will be providing a new namespace

pub async fn revoke(&mut self, namespace: Pattern) -> Result<()>

Inform the broker that you will no longer be providing a namespace

pub async fn subscribe(&mut self, namespace: Pattern) -> Result<Subscriber>

Subscribe to another provider’s namespace

Examples

let mut conn = Client::connect(("127.0.0.1", 7101)).await?;
conn.subscribe("/users/".into())
    .and_then(|sub| async {
        sub.for_each(|(namespace, data)| {
            // Handle the message...
            dbg!("Received the namespace '{}' with data: {}", namespace, data);
            future::ready(())
        })
        .await;
        Ok(())
    })
    .await

pub async fn unsubscribe(&mut self, namespace: Pattern) -> Result<()>

Unsubscribe from another provider’s namespace

pub async fn event<Str: Into<String>>( &mut self, namespace: Pattern, data: Str, ) -> Result<()>

Publish an event to your subscribers

Trait Implementations

impl<E, S, T> Sink<T> for ClientConn<S>

where S: Sink<T, Error = E>, E: Into<Error>,

type Error = Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.