Struct twitchchat::Tags

pub struct Tags<'a> { /* fields omitted */ }

Tags are IRCv3 message tags. Twitch uses them extensively.

This type is usually obstained temporarily from ::tags() call on a message type.

This type is intentionall very cheap and just borrows a pre-computed set of indices and a wrapped string

Implementations

impl<'a> Tags<'a>

pub fn from_data_indices(data: &'a Str<'a>, indices: &'a TagIndices) -> Self

Build the tags view from this borrowed Str and an associated TagIndices

pub fn raw_tags(&self) -> &'a str

Gets the raw string that represents the tags

pub fn len(&self) -> usize

Returns how many tags were parsed

pub fn is_empty(&self) -> bool

Returns whether there are any tags

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

Tries to get this key

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: Str<'_> = "@foo=42;color=#1E90FF".into();
let indices = TagIndices::build_indices(&*input);
let tags = Tags::from_data_indices(&input, &indices);

// '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: Str<'_> = "@foo=42;ok=true;nope=false;test=1;not_test=0".into();
let indices = TagIndices::build_indices(&*input);
let tags = Tags::from_data_indices(&input, &indices);

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

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

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

// key 'test' is 1, which is true
assert!(tags.get_as_bool("test"));

// key 'not_test' is 0, which is false
assert!(!tags.get_as_bool("not_test"));

// missing key 'foobar' is missing, which is false
assert!(!tags.get_as_bool("this-key-is-missing"));

pub fn iter(&self) -> TagsIter<'_>

Get an iterator over all of the key, value pairs of tags

Trait Implementations

impl<'a> Clone for Tags<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Tags<'a>

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

Formats the value using the given formatter.

impl<'a> IntoIterator for &'a Tags<'a>

type Item = (&'a str, &'a str)

The type of the elements being iterated over.

type IntoIter = TagsIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq<Tags<'a>> for Tags<'a>

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

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

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

This method tests for !=.

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