Struct showdown::Stream

pub struct Stream { /* fields omitted */ }

Message stream.

Examples

use futures::{SinkExt, StreamExt};
use showdown::message::{Kind, UpdateUser};
use showdown::{Result, RoomId, Stream};

#[tokio::main]
async fn main() -> Result<()> {
    let mut stream = Stream::connect("showdown").await?;
    let message = stream.next().await.unwrap()?;
    match message.kind() {
        Kind::UpdateUser(UpdateUser {
            username,
            named: false,
            ..
        }) => {
            assert!(username.starts_with(" Guest "));
        }
        _ => panic!(),
    }
    Ok(())
}

Implementations

impl Stream

pub async fn connect(name: &str) -> Result<Self>

Connects to a named Showdown server.

Returns a structure implementing Sink and Stream traits which can be used to send and receives messages respectively.

It's possible to use StreamExt::split to split returned structure into separate Sink and Stream objects.

Examples

use showdown::{Result, Stream};

#[tokio::main]
async fn main() {
    assert!(Stream::connect("showdown").await.is_ok());
    assert!(Stream::connect("fakestofservers").await.is_err());
}

pub async fn connect_to_url(url: &Url) -> Result<Self>

Connects to an URL.

This URL is provided by fetch_server_url function.

Examples

use showdown::{fetch_server_url, Result, Stream};

#[tokio::main]
async fn main() -> Result<()> {
    let url = fetch_server_url("smogtours").await?;
    assert_eq!(url.as_str(), "ws://sim3.psim.us:8002/showdown/websocket");
    Stream::connect_to_url(&url).await?;
    Ok(())
}

Trait Implementations

impl Debug for Stream

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

Formats the value using the given formatter.

impl Sink<SendMessage> for Stream

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<()>>

Attempts to prepare the Sink to receive a value.

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

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<()>>

Flush any remaining output from this sink.

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

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

impl Stream for Stream

type Item = Result<Message>

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.