Enum Prefix

pub enum Prefix<'a> {
    User {
        name: Cow<'a, str>,
        user: Cow<'a, str>,
        host: Cow<'a, str>,
    },
    Server {
        host: Cow<'a, str>,
    },
    None,
}

An IRC-styled prefix.

A prefix is attached to certain messages denoting whom sent it.

Variants

User

A user prefix.

This is attached for messages sent by a user

Currently, with Twitch, only name is is relevant

Fields

name: Cow<'a, str>

Their (nick) name

user: Cow<'a, str>

Their user name

host: Cow<'a, str>

Their host

Server

A server prefix.

This is attached for messages sent by the server

Fields

host: Cow<'a, str>

The host of the server

None

No prefix was attached

Implementations

impl<'a> Prefix<'a>

pub const fn is_user(&self) -> bool

Is this a User prefix?

pub const fn is_server(&self) -> bool

Is this a Server prefix?

pub fn as_name_str(&self) -> Option<&str>

Get the prefix as a &str (the user name, or the server host name)

Trait Implementations

impl<'a> Clone for Prefix<'a>

fn clone(&self) -> Prefix<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Prefix<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Prefix<'a>

fn default() -> Prefix<'a>

Returns the “default value” for a type.

impl<'de, 'a> Deserialize<'de> for Prefix<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> IntoStatic for Prefix<'a>

where 'static: 'a,

type Output = Prefix<'static>

Output of IntoStatic::into_static.

fn into_static(self) -> Self::Output

This method casts self between Self<'a> and Self<'static>.

impl<'a> PartialEq for Prefix<'a>

fn eq(&self, other: &Prefix<'a>) -> bool

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

const 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<'a> Serialize for Prefix<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for Prefix<'a>

impl<'a> StructuralPartialEq for Prefix<'a>