Struct twitchchat::messages::Privmsg

pub struct Privmsg<'t> {
    pub name: Cow<'t, str>,
    pub channel: Cow<'t, str>,
    pub data: Cow<'t, str>,
    pub tags: Tags<'t>,
    pub ctcp: Option<Ctcp<'t>>,
}

Message sent by a user

Fields

name: Cow<'t, str>

User who sent this messages

channel: Cow<'t, str>

Channel this message was sent on

data: Cow<'t, str>

Data that the user provided

tags: Tags<'t>

Tags attached to the message

ctcp: Option<Ctcp<'t>>

The kind of CTCP this message contains, if any.

Implementations

impl<'t> Privmsg<'t>

pub fn badge_info(&'t self) -> Vec<BadgeInfo<'t>>

Metadata related to the chat badges

Currently used only for subscriber, to indicate the exact number of months the user has been a subscriber

pub fn badges(&'t self) -> Vec<Badge<'t>>

Badges attached to this message

pub fn bits(&self) -> Option<u64>

How many bits were attached to this message

pub fn color(&self) -> Option<Color>

The color of the user who sent this message, if set

pub fn display_name(&'t self) -> Option<Cow<'t, str>>

Returns the display name of the user, if set.

Users can changed the casing and encoding of their names, if they choose to.

By default, their display name is not set. If the user foo changes their display name to FOO then this'll return that FOO. Otherwise it'll return None. This also applies to users who have decided to user a localized version of their name.

You can get their username with the field name.

// without their display name set
let data = ":foo!foo@foo PRIVMSG #testing :this is a test.\r\n";
let msg = decode(data).next().unwrap().unwrap();
let pm = Privmsg::parse(&msg).unwrap();
assert_eq!(pm.name, "foo");
assert!(pm.display_name().is_none());

// with their display name set
let data = "@display-name=FOO :foo!foo@foo PRIVMSG #testing :this is a test.\r\n";
let msg = decode(data).next().unwrap().unwrap();
let pm = Privmsg::parse(&msg).unwrap();
assert_eq!(pm.name, "foo");
assert_eq!(pm.display_name().unwrap(), "FOO");

A useful thing to do is to try to get the display_name and fallback to the username.

use std::borrow::Cow;
fn get_user_or_display<'a>(msg: &'a Privmsg<'_>) -> Cow<'a, str> {
    msg.display_name()
        .unwrap_or_else(|| Cow::Borrowed(&*msg.name))
}

let data = ":foo!foo@foo PRIVMSG #testing :this is a test.\r\n";
let msg = decode(data).next().unwrap().unwrap();
let pm = Privmsg::parse(&msg).unwrap();

let name = get_user_or_display(&pm);
assert_eq!(name, "foo");

let data = "@display-name=FOO :foo!foo@foo PRIVMSG #testing :this is a test.\r\n";
let msg = decode(data).next().unwrap().unwrap();
let pm = Privmsg::parse(&msg).unwrap();

let name = get_user_or_display(&pm);
assert_eq!(name, "FOO");    

pub fn emotes(&self) -> Vec<Emotes>

Emotes attached to this message

pub fn is_action(&self) -> bool

Whether this message was an Action (a /me or /action)

pub fn ctcp(&'t self) -> Option<Ctcp<'t>>

Gets the 'CTCP' kind associated with this message, if any;

pub fn is_broadcaster(&self) -> bool

Whether the user sending this message was a broadcaster

pub fn is_moderator(&self) -> bool

Whether the user sending this message was a moderator

pub fn is_vip(&self) -> bool

Whether the user sending this message was a vip

pub fn is_subscriber(&self) -> bool

Whether the user sending this message was a susbcriber

pub fn is_staff(&self) -> bool

Whether the user sending this message was a staff member

pub fn is_turbo(&self) -> bool

Whether the user sending this message had turbo

pub fn is_global_moderator(&self) -> bool

Whether the user sending this message was a global moderator

pub fn room_id(&self) -> Option<u64>

The id of the room this message was sent to

pub fn tmi_sent_ts(&self) -> Option<u64>

The timestamp of when this message was received by Twitch

pub fn user_id(&self) -> Option<u64>

The id of the user who sent this message

Trait Implementations

impl<'t> AsOwned for Privmsg<'t>

type Owned = Privmsg<'static>

The owned type

fn as_owned(&self) -> Self::Owned

Get an owned version

impl<'t> Clone for Privmsg<'t>

fn clone(&self) -> Privmsg<'t>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'t> Debug for Privmsg<'t>

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

Formats the value using the given formatter.

impl<'de, 't> Deserialize<'de> for Privmsg<'t>

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

Deserialize this value from the given Serde deserializer.

impl<'t> From<Privmsg<'t>> for AllCommands<'t>

fn from(msg: Privmsg<'t>) -> Self

Performs the conversion.

impl<'a: 't, 't> Parse<&'a Message<'t>> for Privmsg<'t>

fn parse(msg: &'a Message<'t>) -> Result<Self, InvalidMessage>

Tries to parse the input as this message

impl<'t> PartialEq<Privmsg<'t>> for Privmsg<'t>

fn eq(&self, other: &Privmsg<'t>) -> bool

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

fn ne(&self, other: &Privmsg<'t>) -> bool

This method tests for !=.

impl<'t> Serialize for Privmsg<'t>

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

Serialize this value into the given Serde serializer.

impl<'t> StructuralPartialEq for Privmsg<'t>