Enum ReactionType

#[non_exhaustive]
pub enum ReactionType {
    Custom {
        animated: bool,
        id: EmojiId,
        name: Option<String>,
    },
    Unicode(String),
}

The type of a Reaction sent.

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.

Custom

A reaction with a Guilds custom Emoji, which is unique to the guild.

Fields

animated: bool

Whether the emoji is animated.

id: EmojiId

The Id of the custom Emoji.

name: Option<String>

The name of the custom emoji. This is primarily used for decoration and distinguishing the emoji client-side.

Unicode(String)

A reaction with a twemoji.

Implementations

impl ReactionType

pub fn as_data(&self) -> String

Creates a data-esque display of the type. This is not very useful for displaying, as the primary client can not render it, but can be useful for debugging.

Note: This is mainly for use internally. There is otherwise most likely little use for it.

pub fn unicode_eq(&self, other: &str) -> bool

Helper function to allow testing equality of unicode emojis without having to perform any allocation. Will always return false if the reaction was not a unicode reaction.

pub fn unicode_partial_cmp(&self, other: &str) -> Option<Ordering>

Helper function to allow comparing unicode emojis without having to perform any allocation. Will return None if the reaction was not a unicode reaction.

Trait Implementations

impl Clone for ReactionType

fn clone(&self) -> ReactionType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ReactionType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReactionType

fn deserialize<D: Deserializer<'de>>( deserializer: D, ) -> StdResult<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for ReactionType

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

Formats the reaction type, displaying the associated emoji in a way that clients can understand.

If the type is a custom emoji, then refer to the documentation for emoji’s formatter on how this is displayed. Otherwise, if the type is a unicode, then the inner unicode is displayed.

impl From<Emoji> for ReactionType

fn from(emoji: Emoji) -> ReactionType

Converts to this type from the input type.

impl From<EmojiId> for ReactionType

fn from(emoji_id: EmojiId) -> ReactionType

Converts to this type from the input type.

impl From<EmojiIdentifier> for ReactionType

fn from(emoji_id: EmojiIdentifier) -> ReactionType

Converts to this type from the input type.

impl From<char> for ReactionType

fn from(ch: char) -> ReactionType

Creates a ReactionType from a char.

Examples

Reacting to a message with an apple:

message.react(ctx, '🍎').await?;

impl FromStr for ReactionType

type Err = ReactionConversionError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for ReactionType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ReactionType

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ReactionType

fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for ReactionType

type Error = ReactionConversionError

Creates a ReactionType from a string slice.

Examples

Creating a ReactionType from a 🍎, modeling a similar API as the rest of the library:

use std::convert::TryInto;
use std::fmt::Debug;

use serenity::model::channel::ReactionType;

fn foo<R: TryInto<ReactionType>>(bar: R)
where
    R::Error: Debug,
{
    println!("{:?}", bar.try_into().unwrap());
}

foo("🍎");

Creating a ReactionType from a custom emoji argument in the following format:

use serenity::model::channel::ReactionType;
use serenity::model::id::EmojiId;

let emoji_string = "<:customemoji:600404340292059257>";
let reaction = ReactionType::try_from(emoji_string).unwrap();
let reaction2 = ReactionType::Custom {
    animated: false,
    id: EmojiId::new(600404340292059257),
    name: Some("customemoji".to_string()),
};

assert_eq!(reaction, reaction2);

fn try_from(emoji_str: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for ReactionType

type Error = ReactionConversionError

The type returned in the event of a conversion error.

fn try_from(emoji_string: String) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for ReactionType

impl StructuralPartialEq for ReactionType