Struct async_mp4::mp4box::trun::TrunFirstSampleFlags

pub struct TrunFirstSampleFlags(pub Option<SampleFlags>);

Tuple Fields

0: Option<SampleFlags>

Methods from Deref<Target = Option<SampleFlags>>

pub fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

pub fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

pub fn as_ref(&self) -> Option<&T>

Converts from &Option<T> to Option<&T>.

Examples

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");

pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>

Converts from Pin<&Option<T>> to Option<Pin<&T>>.

pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>

Converts from Pin<&mut Option<T>> to Option<Pin<&mut T>>.

pub fn as_deref(&self) -> Option<&<T as Deref>::Target>where
    T: Deref,

Converts from Option<T> (or &Option<T>) to Option<&T::Target>.

Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Examples

let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

pub fn contains<U>(&self, x: &U) -> boolwhere
    U: PartialEq<T>,

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

Returns true if the option is a Some value containing the given value.

Examples

#![feature(option_result_contains)]

let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);

let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);

let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);

Trait Implementations

impl Clone for TrunFirstSampleFlags

fn clone(&self) -> TrunFirstSampleFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TrunFirstSampleFlags

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

Formats the value using the given formatter.

impl Default for TrunFirstSampleFlags

fn default() -> TrunFirstSampleFlags

Returns the “default value” for a type.

impl Deref for TrunFirstSampleFlags

type Target = Option<SampleFlags>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<Option<SampleFlags>> for TrunFirstSampleFlags

fn from(t: Option<SampleFlags>) -> Self

Converts to this type from the input type.

impl From<SampleFlags> for TrunFirstSampleFlags

fn from(t: SampleFlags) -> Self

Converts to this type from the input type.

impl Hash for TrunFirstSampleFlags

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 Mp4VersionedReadable<TrunFlags> for TrunFirstSampleFlags

fn versioned_read<'life0, 'async_trait, R>(
    version: u8,
    flags: TrunFlags,
    reader: &'life0 mut R
) -> Pin<Box<dyn Future<Output = Result<Self, MP4Error>> + Send + 'async_trait>>where
    R: 'async_trait + ReadMp4,
    Self: 'async_trait,
    'life0: 'async_trait,

impl Mp4VersionedWritable<TrunFlags> for TrunFirstSampleFlags

fn required_flags(&self) -> TrunFlags

fn versioned_byte_size(&self, version: u8, flags: TrunFlags) -> usize

fn versioned_write<W: WriteMp4>(
    &self,
    version: u8,
    flags: TrunFlags,
    writer: &mut W
) -> Result<usize, MP4Error>

fn required_version(&self) -> u8

impl PartialEq<TrunFirstSampleFlags> for TrunFirstSampleFlags

fn eq(&self, other: &TrunFirstSampleFlags) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for TrunFirstSampleFlags

impl Eq for TrunFirstSampleFlags

impl StructuralEq for TrunFirstSampleFlags

impl StructuralPartialEq for TrunFirstSampleFlags