Struct lofty::mp4::Atom

pub struct Atom<'a> { /* private fields */ }

Represents an MP4 atom

Implementations

impl<'a> Atom<'a>

pub const fn new(ident: AtomIdent<'a>, data: AtomData) -> Self

Create a new Atom

pub fn from_collection( ident: AtomIdent<'a>, data: Vec<AtomData>, ) -> Option<Self>

Create a new Atom from a collection of AtomDatas

This will return None if data is empty, as empty atoms are useless.

pub fn ident(&self) -> &AtomIdent<'_>

Returns the atom’s AtomIdent

pub fn data(&self) -> impl Iterator<Item = &AtomData>

Returns the atom’s AtomData

pub fn into_data(self) -> impl Iterator<Item = AtomData>

Consumes the atom, returning its AtomData

Examples

use lofty::mp4::{Atom, AtomData, AtomIdent};

let atom = Atom::new(
	AtomIdent::Fourcc(*b"\x49ART"),
	AtomData::UTF8(String::from("Foo")),
);
assert_eq!(atom.into_data().count(), 1);

pub fn push_data(&mut self, data: AtomData)

Append a value to the atom

pub fn merge(&mut self, other: Atom<'_>) -> Result<()>

Merge the data of another atom into this one

NOTE: Both atoms must have the same identifier

Errors

• self.ident() != other.ident()

Examples

use lofty::mp4::{Atom, AtomData, AtomIdent};

// Create an artist atom
let mut atom = Atom::new(
	AtomIdent::Fourcc(*b"\x49ART"),
	AtomData::UTF8(String::from("foo")),
);

// Create a second and merge it into the first
let atom2 = Atom::new(
	AtomIdent::Fourcc(*b"\x49ART"),
	AtomData::UTF8(String::from("bar")),
);
atom.merge(atom2)?;

// Our first atom now contains the second atom's content
assert_eq!(atom.data().count(), 2);

Trait Implementations

impl<'a> Clone for Atom<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Atom<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Atom<'a>

fn eq(&self, other: &Atom<'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> StructuralPartialEq for Atom<'a>