Struct twitchchat::twitch::Client

pub struct Client<R, W> { /* fields omitted */ }

Client is the IRC client for interacting with Twitch's chat.

Methods

impl<R, W> Client<R, W> where
    R: Read,
    W: Write, 

pub fn new(read: R, write: W) -> Self

Create a new Client from a Read, Write pair

pub fn run(self) -> Result<(), Error>

Runs, consuming all messages. (pumping them through .on() filters)

pub fn register(&mut self, config: UserConfig) -> Result<(), Error>

pub fn wait_for_ready(&mut self) -> Result<LocalUser, Error>

Waits for the GLOBALUSERSTATE before continuing, discarding any messages received

Returns some useful information about your user

pub fn wait_for_irc_ready(&mut self) -> Result<String, Error>

Like wait_for_ready but waits for the end of the IRC MOTD

This will generally happen before GLOBALUSERSTATE but don't rely on that

Returns the username assigned to you by the server

pub fn read_message(&mut self) -> Result<Message, Error>

Reads a message

This can be an IRC Message, or a parsed Twitch Command Will automatically handle some ~tedious~ messages, like the /heartbeat/

impl<R, W> Client<R, W>

pub fn on<F, T>(&mut self, f: F) where
    F: Fn(T) + 'static + Send + Sync,
    T: From<Message>,
    T: MessageFilter, 

When a message, matching the type of the closure, is received run this function with it.

impl<R, W> Client<R, W> where
    W: Write, 

pub fn host(&mut self, channel: &str) -> Result<(), Error>

pub fn unhost(&mut self) -> Result<(), Error>

pub fn marker(&mut self, comment: Option<&str>) -> Result<(), Error>

pub fn raid(&mut self, channel: &str) -> Result<(), Error>

pub fn unraid(&mut self) -> Result<(), Error>

pub fn color<C: Into<Color>>(&mut self, color: C) -> Result<(), Error>

pub fn disconnect(&mut self) -> Result<(), Error>

pub fn help(&mut self) -> Result<(), Error>

pub fn mods(&mut self) -> Result<(), Error>

pub fn vips(&mut self) -> Result<(), Error>

pub fn commercial(&mut self, length: Option<usize>) -> Result<(), Error>

pub fn ban(&mut self, username: &str, reason: Option<&str>) -> Result<(), Error>

pub fn unban(&mut self, username: &str) -> Result<(), Error>

pub fn clear(&mut self) -> Result<(), Error>

pub fn emoteonly(&mut self) -> Result<(), Error>

pub fn emoteonlyoff(&mut self) -> Result<(), Error>

pub fn followers(&mut self, duration: &str) -> Result<(), Error>

pub fn followersoff(&mut self) -> Result<(), Error>

pub fn op(&mut self, username: &str) -> Result<(), Error>

pub fn unmod(&mut self, username: &str) -> Result<(), Error>

pub fn r9kbeta(&mut self) -> Result<(), Error>

pub fn r9kbetaoff(&mut self) -> Result<(), Error>

pub fn slow(&mut self, duration: Option<usize>) -> Result<(), Error>

pub fn slowoff(&mut self) -> Result<(), Error>

pub fn subscribers(&mut self) -> Result<(), Error>

pub fn subscribersoff(&mut self) -> Result<(), Error>

pub fn timeout(
    &mut self,
    username: &str,
    duration: Option<&str>,
    reason: Option<&str>
) -> Result<(), Error>

pub fn untimeout(&mut self, username: &str) -> Result<(), Error>

pub fn vip(&mut self, username: &str) -> Result<(), Error>

pub fn unvip(&mut self, username: &str) -> Result<(), Error>

pub fn whisper(&mut self, username: &str, message: &str) -> Result<(), Error>

pub fn join<C: Into<Channel>>(&mut self, channel: C) -> Result<(), Error>

Joins a channel

pub fn part<C: Into<Channel>>(&mut self, channel: C) -> Result<(), Error>

Parts a channel

pub fn me<C, S>(&mut self, channel: C, message: S) -> Result<(), Error> where
    C: Into<Channel>,
    S: AsRef<str>, 

Sends an "emote" message in the third person to the channel

pub fn privmsg<C, S>(&mut self, channel: C, message: S) -> Result<(), Error> where
    C: Into<Channel>,
    S: AsRef<str>, 

Sends the message to the channel

Same as send

pub fn send<C, S>(&mut self, channel: C, message: S) -> Result<(), Error> where
    C: Into<Channel>,
    S: AsRef<str>, 

Sends the message to the channel

pub fn command<S>(&mut self, data: S) -> Result<(), Error> where
    S: AsRef<str>, 

Sends the command: data (e.g. /color #FFFFFF)

pub fn raw<S>(&mut self, data: S) -> Result<(), Error> where
    S: AsRef<str>, 

Sends a raw line (appends the required \r\n)

Trait Implementations

impl<R, W: Write> ClientExt for Client<R, W>

fn join_many<'a, I, S>(&mut self, channels: I) -> Result<(), Error> where
    I: IntoIterator<Item = S> + 'a,
    S: AsRef<str> + 'a, 

Join a (huge) list of channels

impl<R, W> Clone for Client<R, W>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.