Enum ServerMsgKindRaw

pub enum ServerMsgKindRaw<'a> {
    Numeric(Numeric),
    Cmd(Cmd<'a>),
}

Either an alphabetic command or a numeric reply.

Variants

Numeric(Numeric)

Cmd(Cmd<'a>)

Implementations

impl<'a> ServerMsgKindRaw<'a>

pub fn owning(self) -> ServerMsgKindRaw<'static>

Converts self into a version that owns its data.

pub const fn as_arg(&self) -> Arg<'_>

Returns self’s value as an Arg.

pub const fn as_str(&self) -> &str

Returns a reference to self’s value as a str.

pub const fn len(&self) -> usize

The length of the server message kind, in bytes.

This value is guaranteed to be non-zero.

pub const fn is_error(&self) -> Option<bool>

Returns Some(true) if self represents an error, Some(false) if it does not, or None if it’s unknown.

Trait Implementations

impl<'a> Borrow<[u8]> for ServerMsgKindRaw<'a>

fn borrow(&self) -> &[u8]

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for ACCOUNT

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for AUTHENTICATE

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for AWAY

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for BATCH

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for CAP

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for CHGHOST

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for ERROR

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for FAIL

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for INVITE

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for JOIN

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for KICK

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for MODE

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for NICK

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for NOTE

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for NOTICE

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for PART

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for PING

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for PONG

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for PRIVMSG

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for QUIT

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for REGISTER

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for SETNAME

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for TAGMSG

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for TOPIC

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for VERIFY

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for WALLOPS

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Borrow<ServerMsgKindRaw<'a>> for WARN

fn borrow(&self) -> &ServerMsgKindRaw<'a>

Immutably borrows from an owned value.

impl<'a> Clone for ServerMsgKindRaw<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ServerMsgKindRaw<'a>

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ACCOUNT> for ServerMsgKindRaw<'static>

fn from(v: ACCOUNT) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<AUTHENTICATE> for ServerMsgKindRaw<'static>

fn from(v: AUTHENTICATE) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<AWAY> for ServerMsgKindRaw<'static>

fn from(v: AWAY) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<BATCH> for ServerMsgKindRaw<'static>

fn from(v: BATCH) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<CAP> for ServerMsgKindRaw<'static>

fn from(v: CAP) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<CHGHOST> for ServerMsgKindRaw<'static>

fn from(v: CHGHOST) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl<'a> From<Cmd<'a>> for ServerMsgKindRaw<'a>

fn from(value: Cmd<'a>) -> Self

Converts to this type from the input type.

impl From<ERROR> for ServerMsgKindRaw<'static>

fn from(v: ERROR) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<FAIL> for ServerMsgKindRaw<'static>

fn from(v: FAIL) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<INVITE> for ServerMsgKindRaw<'static>

fn from(v: INVITE) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<JOIN> for ServerMsgKindRaw<'static>

fn from(v: JOIN) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<KICK> for ServerMsgKindRaw<'static>

fn from(v: KICK) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<MODE> for ServerMsgKindRaw<'static>

fn from(v: MODE) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<NICK> for ServerMsgKindRaw<'static>

fn from(v: NICK) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<NOTE> for ServerMsgKindRaw<'static>

fn from(v: NOTE) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<NOTICE> for ServerMsgKindRaw<'static>

fn from(v: NOTICE) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl<'a> From<Numeric> for ServerMsgKindRaw<'a>

fn from(value: Numeric) -> Self

Converts to this type from the input type.

impl From<PART> for ServerMsgKindRaw<'static>

fn from(v: PART) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<PING> for ServerMsgKindRaw<'static>

fn from(v: PING) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<PONG> for ServerMsgKindRaw<'static>

fn from(v: PONG) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<PRIVMSG> for ServerMsgKindRaw<'static>

fn from(v: PRIVMSG) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<QUIT> for ServerMsgKindRaw<'static>

fn from(v: QUIT) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<REGISTER> for ServerMsgKindRaw<'static>

fn from(v: REGISTER) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<SETNAME> for ServerMsgKindRaw<'static>

fn from(v: SETNAME) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<TAGMSG> for ServerMsgKindRaw<'static>

fn from(v: TAGMSG) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<TOPIC> for ServerMsgKindRaw<'static>

fn from(v: TOPIC) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<VERIFY> for ServerMsgKindRaw<'static>

fn from(v: VERIFY) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<WALLOPS> for ServerMsgKindRaw<'static>

fn from(v: WALLOPS) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl From<WARN> for ServerMsgKindRaw<'static>

fn from(v: WARN) -> ServerMsgKindRaw<'static>

Converts to this type from the input type.

impl<'a> Hash for ServerMsgKindRaw<'a>

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<'a> Ord for ServerMsgKindRaw<'a>

fn cmp(&self, other: &ServerMsgKindRaw<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq<&[u8]> for ServerMsgKindRaw<'a>

fn eq(&self, other: &&[u8]) -> 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<'a> PartialEq<&str> for ServerMsgKindRaw<'a>

fn eq(&self, other: &&str) -> 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<'a> PartialEq<[u8]> for ServerMsgKindRaw<'a>

fn eq(&self, other: &[u8]) -> 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<'a> PartialEq<ACCOUNT> for ServerMsgKindRaw<'a>

fn eq(&self, other: &ACCOUNT) -> 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<'a> PartialEq<AUTHENTICATE> for ServerMsgKindRaw<'a>

fn eq(&self, other: &AUTHENTICATE) -> 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<'a> PartialEq<AWAY> for ServerMsgKindRaw<'a>

fn eq(&self, other: &AWAY) -> 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<'a> PartialEq<BATCH> for ServerMsgKindRaw<'a>

fn eq(&self, other: &BATCH) -> 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<'a> PartialEq<CAP> for ServerMsgKindRaw<'a>

fn eq(&self, other: &CAP) -> 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<'a> PartialEq<CHGHOST> for ServerMsgKindRaw<'a>

fn eq(&self, other: &CHGHOST) -> 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<'a> PartialEq<Cmd<'_>> for ServerMsgKindRaw<'a>

fn eq(&self, other: &Cmd<'_>) -> 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<'a> PartialEq<ERROR> for ServerMsgKindRaw<'a>

fn eq(&self, other: &ERROR) -> 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<'a> PartialEq<FAIL> for ServerMsgKindRaw<'a>

fn eq(&self, other: &FAIL) -> 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<'a> PartialEq<INVITE> for ServerMsgKindRaw<'a>

fn eq(&self, other: &INVITE) -> 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<'a> PartialEq<JOIN> for ServerMsgKindRaw<'a>

fn eq(&self, other: &JOIN) -> 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<'a> PartialEq<KICK> for ServerMsgKindRaw<'a>

fn eq(&self, other: &KICK) -> 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<'a> PartialEq<MODE> for ServerMsgKindRaw<'a>

fn eq(&self, other: &MODE) -> 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<'a> PartialEq<NICK> for ServerMsgKindRaw<'a>

fn eq(&self, other: &NICK) -> 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<'a> PartialEq<NOTE> for ServerMsgKindRaw<'a>

fn eq(&self, other: &NOTE) -> 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<'a> PartialEq<NOTICE> for ServerMsgKindRaw<'a>

fn eq(&self, other: &NOTICE) -> 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<'a> PartialEq<Numeric> for ServerMsgKindRaw<'a>

fn eq(&self, other: &Numeric) -> 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<'a> PartialEq<PART> for ServerMsgKindRaw<'a>

fn eq(&self, other: &PART) -> 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<'a> PartialEq<PING> for ServerMsgKindRaw<'a>

fn eq(&self, other: &PING) -> 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<'a> PartialEq<PONG> for ServerMsgKindRaw<'a>

fn eq(&self, other: &PONG) -> 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<'a> PartialEq<PRIVMSG> for ServerMsgKindRaw<'a>

fn eq(&self, other: &PRIVMSG) -> 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<'a> PartialEq<QUIT> for ServerMsgKindRaw<'a>

fn eq(&self, other: &QUIT) -> 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<'a> PartialEq<REGISTER> for ServerMsgKindRaw<'a>

fn eq(&self, other: &REGISTER) -> 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<'a> PartialEq<SETNAME> for ServerMsgKindRaw<'a>

fn eq(&self, other: &SETNAME) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for ACCOUNT

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for AUTHENTICATE

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for AWAY

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for BATCH

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for CAP

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for CHGHOST

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for ERROR

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for FAIL

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for INVITE

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for JOIN

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for KICK

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for MODE

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for NICK

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for NOTE

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for NOTICE

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for PART

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for PING

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for PONG

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for PRIVMSG

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for QUIT

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for REGISTER

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for SETNAME

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for TAGMSG

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for TOPIC

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for VERIFY

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for WALLOPS

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<ServerMsgKindRaw<'a>> for WARN

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialEq<TAGMSG> for ServerMsgKindRaw<'a>

fn eq(&self, other: &TAGMSG) -> 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<'a> PartialEq<TOPIC> for ServerMsgKindRaw<'a>

fn eq(&self, other: &TOPIC) -> 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<'a> PartialEq<VERIFY> for ServerMsgKindRaw<'a>

fn eq(&self, other: &VERIFY) -> 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<'a> PartialEq<WALLOPS> for ServerMsgKindRaw<'a>

fn eq(&self, other: &WALLOPS) -> 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<'a> PartialEq<WARN> for ServerMsgKindRaw<'a>

fn eq(&self, other: &WARN) -> 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<'a> PartialEq<str> for ServerMsgKindRaw<'a>

fn eq(&self, other: &str) -> 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<'a> PartialEq for ServerMsgKindRaw<'a>

fn eq(&self, other: &ServerMsgKindRaw<'a>) -> 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<'a> PartialOrd for ServerMsgKindRaw<'a>

fn partial_cmp(&self, other: &ServerMsgKindRaw<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Serialize for ServerMsgKindRaw<'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 ServerMsgKindRaw<'a>

impl<'a> StructuralPartialEq for ServerMsgKindRaw<'a>