Struct hls_m3u8::types::KeyFormatVersions

pub struct KeyFormatVersions { /* fields omitted */ }

A list of numbers that can be used to indicate which version(s) this instance complies with, if more than one version of a particular KeyFormat is defined.

Note on maximum size

To reduce the memory usage and to make this struct implement Copy, a fixed size array is used internally ([u8; 9]), which can store a maximum number of 9 u8 numbers.

If you encounter any m3u8 file, which fails to parse, because the buffer is too small, feel free to make an issue.

Example

use hls_m3u8::types::KeyFormatVersions;

assert_eq!(
    KeyFormatVersions::from([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]).to_string(),
    "\"255/255/255/255/255/255/255/255/255\"".to_string()
);

Implementations

impl KeyFormatVersions

pub fn new() -> Self

Constructs an empty KeyFormatVersions.

Example

let versions = KeyFormatVersions::new();

assert_eq!(versions, KeyFormatVersions::default());

pub fn push(&mut self, value: u8)

Add a value to the end of KeyFormatVersions.

Panics

This function panics, if you try to push more elements, than KeyFormatVersions::remaining returns.

Example

let mut versions = KeyFormatVersions::new();

versions.push(1);
assert_eq!(versions, KeyFormatVersions::from([1]));

This will panic, because it exceeded the maximum number of elements:

let mut versions = KeyFormatVersions::new();

for _ in 0..=versions.capacity() {
    versions.push(1); // <- panics
}

pub fn remaining(&self) -> usize

KeyFormatVersions has a limited capacity and this function returns how many elements can be pushed, until it panics.

Example

let mut versions = KeyFormatVersions::new();

assert_eq!(versions.remaining(), versions.capacity());

versions.push(1);
versions.push(2);
versions.push(3);
assert_eq!(versions.remaining(), 6);

pub const fn len(&self) -> usize

Returns the number of elements.

Example

let mut versions = KeyFormatVersions::new();

assert_eq!(versions.len(), 0);

versions.push(2);
assert_eq!(versions.len(), 1);

pub fn capacity(&self) -> usize

Returns the total number of elements that can be stored.

Note

It should not be relied on that this function will always return 9. In the future this number might increase.

pub fn truncate(&mut self, len: usize)

Shortens the internal array to the provided length.

Note

If len is greater than the current length, this has no effect.

Example

let mut versions = KeyFormatVersions::from([1, 2, 3, 4, 5, 6]);
versions.truncate(3);

assert_eq!(versions, KeyFormatVersions::from([1, 2, 3]));

pub const fn is_empty(&self) -> bool

Returns true if there are no elements.

Example

let mut versions = KeyFormatVersions::new();

assert_eq!(versions.is_empty(), true);

versions.push(2);
assert_eq!(versions.is_empty(), false);

pub fn pop(&mut self) -> Option<u8>

Removes the last element and returns it, or None if it is empty.

Example

let mut versions = KeyFormatVersions::new();

assert_eq!(versions.pop(), None);

versions.push(2);
assert_eq!(versions.pop(), Some(2));
assert_eq!(versions.is_empty(), true);

pub fn is_default(&self) -> bool

Returns true, if it is either empty or has a length of 1 and the first element is 1.

Example

let mut versions = KeyFormatVersions::new();

assert_eq!(versions.is_default(), true);

versions.push(1);
assert_eq!(versions.is_default(), true);

assert_eq!(KeyFormatVersions::default().is_default(), true);

Trait Implementations

impl AsMut<[u8]> for KeyFormatVersions

fn as_mut(&mut self) -> &mut [u8]

Performs the conversion.

impl AsRef<[u8]> for KeyFormatVersions

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

Performs the conversion.

impl Clone for KeyFormatVersions

fn clone(&self) -> KeyFormatVersions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeyFormatVersions

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

Formats the value using the given formatter.

impl Default for KeyFormatVersions

fn default() -> Self

Returns the “default value” for a type.

impl Display for KeyFormatVersions

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

Formats the value using the given formatter.

impl<'a> Extend<&'a u8> for KeyFormatVersions

fn extend<I: IntoIterator<Item = &'a u8>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<u8> for KeyFormatVersions

fn extend<I: IntoIterator<Item = u8>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a> From<&'a KeyFormatVersions> for IntoIter<u8>

fn from(value: &'a KeyFormatVersions) -> Self

Performs the conversion.

impl From<KeyFormatVersions> for IntoIter<u8>

fn from(value: KeyFormatVersions) -> Self

Performs the conversion.

impl<T: AsRef<[usize]>> From<T> for KeyFormatVersions

fn from(value: T) -> Self

Performs the conversion.

impl<'a> FromIterator<&'a u8> for KeyFormatVersions

fn from_iter<I: IntoIterator<Item = &'a u8>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u8> for KeyFormatVersions

fn from_iter<I: IntoIterator<Item = u8>>(iter: I) -> Self

Creates a value from an iterator.

impl FromStr for KeyFormatVersions

type Err = Error

The associated error which can be returned from parsing.

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

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

impl Hash for KeyFormatVersions

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, 

Feeds a slice of this type into the given Hasher.

impl<I: SliceIndex<[u8]>> Index<I> for KeyFormatVersions

type Output = I::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I: SliceIndex<[u8]>> IndexMut<I> for KeyFormatVersions

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IntoIterator for KeyFormatVersions

type IntoIter = IntoIter<u8>

Which kind of iterator are we turning this into?

type Item = u8

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for KeyFormatVersions

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<KeyFormatVersions> for KeyFormatVersions

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

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

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

This method tests for !=.

impl PartialOrd<KeyFormatVersions> for KeyFormatVersions

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for KeyFormatVersions

impl Eq for KeyFormatVersions