Enum twitch_irc::message::ServerMessage

#[non_exhaustive]
pub enum ServerMessage {
    ClearChat(ClearChatMessage),
    ClearMsg(ClearMsgMessage),
    GlobalUserState(GlobalUserStateMessage),
    Join(JoinMessage),
    Notice(NoticeMessage),
    Part(PartMessage),
    Ping(PingMessage),
    Pong(PongMessage),
    Privmsg(PrivmsgMessage),
    Reconnect(ReconnectMessage),
    RoomState(RoomStateMessage),
    UserNotice(UserNoticeMessage),
    UserState(UserStateMessage),
    Whisper(WhisperMessage),
    // some variants omitted
}

An IRCMessage that has been parsed into a more concrete type based on its command.

This type is non-exhausive, because more types of commands exist and can be added.

If you wish to (manually) parse a type of command that is not already parsed by this library, use IRCMessage::from to convert the ServerMessage back to an IRCMessage, then check the message’s command and perform your parsing.

There is intentionally no generic Unparsed variant here. If there was, and the library added parsing for the command you were trying to catch by matching against the Unparsed variant, your code would be broken without any compiler error.

Examples

use twitch_irc::message::{IRCMessage, ServerMessage};
use std::convert::TryFrom;

let irc_message = IRCMessage::parse(":tmi.twitch.tv PING").unwrap();
let server_message = ServerMessage::try_from(irc_message).unwrap();

match server_message {
    // match against known types first
    ServerMessage::Ping { .. } => println!("Got pinged!"),
    rest => {
        // can do manual parsing here
        let irc_message = IRCMessage::from(rest);
        if irc_message.command == "CUSTOMCMD" {
             // ...
        }
    }
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ClearChat(ClearChatMessage)

CLEARCHAT message

ClearMsg(ClearMsgMessage)

CLEARMSG message

GlobalUserState(GlobalUserStateMessage)

GLOBALUSERSTATE message

Join(JoinMessage)

JOIN message

Notice(NoticeMessage)

NOTICE message

Part(PartMessage)

PART message

Ping(PingMessage)

PING message

Pong(PongMessage)

PONG message

Privmsg(PrivmsgMessage)

PRIVMSG message

Reconnect(ReconnectMessage)

RECONNECT message

RoomState(RoomStateMessage)

ROOMSTATE message

UserNotice(UserNoticeMessage)

USERNOTICE message

UserState(UserStateMessage)

USERSTATE message

Whisper(WhisperMessage)

WHISPER message

Implementations

impl ServerMessage

pub fn source(&self) -> &IRCMessage

Get a reference to the IRCMessage this ServerMessage was parsed from.

Trait Implementations

impl AsRawIRC for ServerMessage

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

Writes the raw IRC message to the given formatter.

fn as_raw_irc(&self) -> Stringwhere
    Self: Sized,

Creates a new string with the raw IRC message.

impl Clone for ServerMessage

fn clone(&self) -> ServerMessage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ServerMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ServerMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ServerMessage> for IRCMessage

fn from(msg: ServerMessage) -> IRCMessage

Converts to this type from the input type.

impl Serialize for ServerMessage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<IRCMessage> for ServerMessage

type Error = ServerMessageParseError

The type returned in the event of a conversion error.

fn try_from(
    source: IRCMessage
) -> Result<ServerMessage, ServerMessageParseError>

Performs the conversion.