Struct cord_client::ClientConn

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

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.

Methods

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

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

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".parse().unwrap()).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.