Struct showdown::SendMessage

pub struct SendMessage(/* private fields */);

Implementations

impl SendMessage

pub fn global_command(command: impl Display) -> Self

Creates a global command.

Example

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

#[tokio::main]
async fn main() -> Result<()> {
    let mut stream = Stream::connect("showdown").await?;
    stream.send(SendMessage::global_command("cmd rooms")).await?;
    while let Some(received) = stream.next().await {
        if let Kind::QueryResponse(QueryResponse::Rooms(rooms)) = received?.kind() {
            assert!(rooms
                .official
                .iter()
                .any(|room| room.title == "Tournaments"));
            return Ok(());
        }
    }
    panic!("Server didn't provide a list of rooms")
}

pub fn chat_message(room_id: RoomId<'_>, message: impl Display) -> Self

Creates a chat room message.

pub fn chat_command(room_id: RoomId<'_>, command: impl Display) -> Self

Creates a command that executes in a chat room.

Examples

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

#[tokio::main]
async fn main() -> Result<()> {
    let mut stream = Stream::connect("showdown").await?;
    stream.send(SendMessage::global_command("join lobby")).await?;
    stream.send(SendMessage::chat_command(RoomId::LOBBY, "roomdesc")).await;
    while let Some(message) = stream.next().await {
        if let Kind::Html(html) = message?.kind() {
            assert!(html.contains("Relax here amidst the chaos."));
            return Ok(());
        }
    }
    panic!("Server didn't provide a room description")
}

pub fn broadcast_command(room_id: RoomId<'_>, command: impl Display) -> Self

Trait Implementations

impl Clone for SendMessage

fn clone(&self) -> SendMessage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SendMessage

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

Formats the value using the given formatter.

impl PartialEq<SendMessage> for SendMessage

fn eq(&self, other: &SendMessage) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 Eq for SendMessage

impl StructuralEq for SendMessage

impl StructuralPartialEq for SendMessage