Struct twitchchat::messages::Whisper

pub struct Whisper<'t> {
    pub name: Cow<'t, str>,
    pub data: Cow<'t, str>,
    pub tags: Tags<'t>,
}

Message sent by a user

Fields

name: Cow<'t, str>

User who sent this messages

data: Cow<'t, str>

Data that the user provided

tags: Tags<'t>

Tags attached to the message

Implementations

impl<'t> Whisper<'t>

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

Badges 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 WHISPER testing :this is a test.\r\n";
let msg = decode(data).next().unwrap().unwrap();
let pm = Whisper::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 WHISPER testing :this is a test.\r\n";
let msg = decode(data).next().unwrap().unwrap();
let pm = Whisper::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 Whisper<'_>) -> Cow<'a, str> {
    msg.display_name()
        .unwrap_or_else(|| Cow::Borrowed(&*msg.name))
}

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

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

let data = "@display-name=FOO :foo!foo@foo WHISPER testing :this is a test.\r\n";
let msg = decode(data).next().unwrap().unwrap();
let pm = Whisper::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_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 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 Whisper<'t>

type Owned = Whisper<'static>

The owned type

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

Get an owned version

impl<'t> Clone for Whisper<'t>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'t> Debug for Whisper<'t>

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

Formats the value using the given formatter.

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

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

Deserialize this value from the given Serde deserializer.

impl<'a: 't, 't> Extract<'a, &'a Whisper<'t>> for &'a AllCommands<'t>

fn extract(&'a self) -> Option<&'a Whisper<'t>>

Tries to extract the value

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

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

Performs the conversion.

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

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

Tries to parse the input as this message

impl<'t> PartialEq<Whisper<'t>> for Whisper<'t>

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

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

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

This method tests for !=.

impl<'t> Serialize for Whisper<'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 Whisper<'t>