Struct twitchchat::Tags

pub struct Tags<'t>(_);

Tags are IRCv3 message tags. Twitch uses them extensively.

Implementations

impl<'t> Tags<'t>

pub fn parse(input: &'t str) -> Option<Self>

Parses a @k=v;k=v string into a Tags type

WARNING

Use this with caution because it doesn't valid any of the parsing logic and may panic.

This is only made public for convenience of construction Tags outside the normal use-case for this crate.

This isn't fully IRCv3 compliant

pub fn get<K: ?Sized>(&'t self, key: &K) -> Option<Cow<'t, str>> where
    K: Borrow<str>, 

Tries to get the tag for this key.

Note

This doesn't clone, but rather reborrows the key as another Cow

pub fn get_ref<K: ?Sized>(&'t self, key: &K) -> Option<&'t Cow<'t, str>> where
    K: Borrow<str>, 

Tries to get a reference to the tag for this key

Note

This is provided so you don't have to play as much type-tetris

pub fn get_parsed<K: ?Sized, E>(&self, key: &K) -> Option<E> where
    K: Borrow<str>,
    E: FromStr, 

Tries to get the tag as a parsable [FromStr] type.

This returns None if it cannot parse, or cannot find the tag

let input = "@foo=42;color=#1E90FF";
let tags = Tags::parse(input).unwrap();

// 'foo' can be parsed as a usize
let answer: usize = tags.get_parsed("foo").unwrap();
assert_eq!(answer, 42);

// 'foo' can be parsed a String (this shows how to use this with a 'turbofish')
assert_eq!(
    tags.get_parsed::<_, String>("foo").unwrap(),
    "42".to_string()
);

// 'foo' cannot be parsed as a bool
assert!(tags.get_parsed::<_, bool>("foo").is_none());

// a non-std type with a FromStr impl
let color: Color = tags.get_parsed("color").unwrap();
assert_eq!(color.rgb, RGB(0x1E, 0x90, 0xFF));

pub fn get_as_bool<K: ?Sized>(&self, key: &K) -> bool where
    K: Borrow<str>, 

Tries to get the tag as a bool.

If it wasn't found it'll return false

let input = "@foo=42;ok=true;nope=false";
let tags = Tags::parse(input).unwrap();

// 'foo' is not a bool
assert!(!tags.get_as_bool("foo"));

// 'ok' is a bool and is true
assert!(tags.get_as_bool("ok"));

// 'nope' is a bool but its false
assert!(!tags.get_as_bool("nope"));

pub fn iter(&'t self) -> impl Iterator<Item = (Cow<'t, str>, Cow<'t, str>)> + '_

Get an iterator over the key,value pairs in the tags

Note

This doesn't clone, but rather reborrows the key as another Cow

pub fn iter_ref(
    &self
) -> impl Iterator<Item = (&Cow<'t, str>, &Cow<'t, str>)> + '_

Get an iterator over the key,value pairs in the tags

Note

This is provided so you don't have to play as much type-tetris

pub fn keys(&'t self) -> impl Iterator<Item = Cow<'t, str>> + '_

Get an iterator over the keys in the tags

Note

This doesn't clone, but rather reborrows the key as another Cow

pub fn keys_ref(&self) -> impl Iterator<Item = &Cow<'t, str>> + '_

Get an iterator over the keys in the tags

Note

This is provided so you don't have to play as much type-tetris

pub fn values(&'t self) -> impl Iterator<Item = Cow<'t, str>> + '_

Get an iterator over the values in the tags

Note

This doesn't clone, but rather reborrows the key as another Cow

pub fn values_ref(&self) -> impl Iterator<Item = &Cow<'t, str>> + '_

Get an iterator over the values in the tags

Note

This is provided so you don't have to play as much type-tetris

pub fn into_inner(self) -> HashMap<Cow<'t, str>, Cow<'t, str>>

Take ownership of the inner HashMap

Trait Implementations

impl<'a> AsOwned for Tags<'a>

type Owned = Tags<'static>

The owned type

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

Get an owned version

impl<'t> Clone for Tags<'t>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'t> Debug for Tags<'t>

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

Formats the value using the given formatter.

impl<'t> Default for Tags<'t>

fn default() -> Tags<'t>

Returns the "default value" for a type.

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

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

Deserialize this value from the given Serde deserializer.

impl<'t> PartialEq<Tags<'t>> for Tags<'t>

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

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

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

This method tests for !=.

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