Struct twitchchat::Client

pub struct Client { /* fields omitted */ }

Client allows for reading and writing.

It reads from an tokio::io::AsyncRead and allows subscription to events via a Dispatcher.

It allows encoding of messages to a tokio::io::AsyncWrite

Event subcription returns a Stream of Messages for that event.

The client allows you to get a Writer which lets you send messages to the connection.

Using the client

You drive a Client to completion with an AsyncRead and AsyncWrite pair by calling run.

run will read from the connection end an error or EOF is received, dispatching messages to any event subscribers.

The Writer uses the AsyncWrite part to encode messages to it.

Example

// make a client
let mut client = Client::new();
// get a cloneable writer
let mut writer = client.writer()
// subscribe to the join events (multiple subscriptions to the same event is allowed)
let mut join_stream = client.dispatcher().await.subscribe::<event::Join>();
tokio::task::spawn(async move {
    // will read until the client drops, or the event subscription is cleared
    while let Some(join_msg) = join_stream.next().await {
        // join_msg is a twitchchat::messages::JoinMessage
    }
});

// wait for the client to read to the end, driving any subscriptions
client.run(read_impl, write_impl).await;

Methods

impl Client

pub fn new() -> Self

Create a new client

pub async fn dispatcher<'_, '_>(&'_ self) -> MutexGuard<'_, Dispatcher>

Get the dispatcher

pub fn writer(&self) -> Writer

Get a new writer

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

Stops the running task

run will return Ok(Status::Canceled)

pub async fn run<'_, R, W>(&'_ self, read: R, write: W) -> Result<Status, Error> where
    R: AsyncRead + Send + Sync + Unpin + 'static,
    W: AsyncWrite + Send + Sync + Unpin + 'static, 

Run the client to completion, dispatching messages to the subscribers

Returns

• An error if one was encountered while in operation
• Ok(Status::Eof) if it ran to completion
• Ok(Status::Canceled) if stop was called

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.

impl Default for Client

fn default() -> Self

Returns the "default value" for a type.