Struct mp4ameta::Tag

pub struct Tag { /* fields omitted */ }

A MPEG-4 audio tag containing metadata atoms

Implementations

impl Tag

Standard genre

pub fn standard_genres(&self) -> impl Iterator<Item = u16> + '_

Returns all standard genres (gnre).

pub fn standard_genre(&self) -> Option<u16>

Returns the first standard genre (gnre).

pub fn set_standard_genre(&mut self, genre_code: u16)

Sets the standard genre (gnre). This will remove all other standard genres.

pub fn set_standard_genres(
    &mut self,
    genre_codes: impl IntoIterator<Item = u16>
)

Sets all standard genres (gnre). This will remove all other standard genres.

pub fn add_standard_genre(&mut self, genre_code: u16)

Adds a standard genre (gnre).

pub fn add_standard_genres(
    &mut self,
    genre_codes: impl IntoIterator<Item = u16>
)

Adds all standard genres (gnre).

pub fn remove_standard_genres(&mut self)

Removes all standard genres (gnre).

impl Tag

Genre

These are convenience methods that operate on values of both standard genres (gnre) and custom genres (©gen).

pub fn genres(&self) -> impl Iterator<Item = &str> + '_

Returns all genres, first the standard genres (gnre) then custom ones (©gen).

pub fn genre(&self) -> Option<&str>

Returns the first genre (gnre or ©gen).

pub fn take_genres(&mut self) -> impl Iterator<Item = String> + '_

Removes all custom genres (©gen) and returns all genres, first standard genres (gnre) then custom ones (©gen).

pub fn take_genre(&mut self) -> Option<String>

Removes all custom genres (©gen) and returns the first genre (gnre or ©gen).

pub fn set_genre(&mut self, genre: impl Into<String>)

Sets the custom genre (©gen). This will remove all other standard or custom genres.

pub fn set_genres(&mut self, genres: impl IntoIterator<Item = String>)

Sets the custom genre (©gen). This will remove all other standard or custom genres.

pub fn add_genre(&mut self, genre: impl Into<String>)

Adds a custom genre (©gen).

pub fn remove_genres(&mut self)

Removes the genre (gnre or ©gen).

impl Tag

Audio information

pub fn audio_info(&self) -> &AudioInfo

Returns a reference of the audio information.

pub fn duration(&self) -> Option<Duration>

Returns the duration in seconds.

pub fn channel_config(&self) -> Option<ChannelConfig>

Returns the channel configuration.

pub fn sample_rate(&self) -> Option<SampleRate>

Returns the channel configuration.

pub fn avg_bitrate(&self) -> Option<u32>

Returns the average bitrate.

pub fn max_bitrate(&self) -> Option<u32>

Returns the maximum bitrate.

impl Tag

Filetype

pub fn filetype(&self) -> &str

returns the filetype (ftyp).

impl Tag

Track

The track number and total number of tracks are stored in a tuple. If only one is present the other is represented as 0 and will be treated as if nonexistent.

pub fn track(&self) -> (Option<u16>, Option<u16>)

Returns the track number and the total number of tracks (trkn).

pub fn track_number(&self) -> Option<u16>

Returns the track number (trkn).

pub fn total_tracks(&self) -> Option<u16>

Returns the total number of tracks (trkn).

pub fn set_track(&mut self, track_number: u16, total_tracks: u16)

Sets the track number and the total number of tracks (trkn).

pub fn set_track_number(&mut self, track_number: u16)

Sets the track number (trkn).

pub fn set_total_tracks(&mut self, total_tracks: u16)

Sets the total number of tracks (trkn).

pub fn remove_track(&mut self)

Removes the track number and the total number of tracks (trkn).

pub fn remove_track_number(&mut self)

Removes the track number, preserving the total number of tracks if present (trkn).

pub fn remove_total_tracks(&mut self)

Removes the total number of tracks, preserving the track number if present (trkn).

impl Tag

Disc

The disc number and total number of discs are stored in a tuple. If only one is present the other is represented as 0 and will be treated as if nonexistent.

pub fn disc(&self) -> (Option<u16>, Option<u16>)

Returns the disc number and total number of discs (disk).

pub fn disc_number(&self) -> Option<u16>

Returns the disc number (disk).

pub fn total_discs(&self) -> Option<u16>

Returns the total number of discs (disk).

pub fn set_disc(&mut self, disc_number: u16, total_discs: u16)

Sets the disc number and the total number of discs (disk).

pub fn set_disc_number(&mut self, disc_number: u16)

Sets the disc number (disk).

pub fn set_total_discs(&mut self, total_discs: u16)

Sets the total number of discs (disk).

pub fn remove_disc(&mut self)

Removes the disc number and the total number of discs (disk).

pub fn remove_disc_number(&mut self)

Removes the disc number, preserving the total number of discs if present (disk).

pub fn remove_total_discs(&mut self)

Removes the total number of discs, preserving the disc number if present (disk).

impl Tag

pub const fn new(ftyp: String, info: AudioInfo, atoms: Vec<AtomData>) -> Self

Creates a new MPEG-4 audio tag containing the atom.

pub fn read_from(reader: &mut impl Read + Seek) -> Result<Self>

Attempts to read a MPEG-4 audio tag from the reader.

pub fn read_from_path(path: impl AsRef<Path>) -> Result<Self>

Attempts to read a MPEG-4 audio tag from the file at the indicated path.

pub fn write_to(&self, file: &File) -> Result<()>

Attempts to write the MPEG-4 audio tag to the writer. This will overwrite any metadata previously present on the file.

pub fn write_to_path(&self, path: impl AsRef<Path>) -> Result<()>

Attempts to write the MPEG-4 audio tag to the path. This will overwrite any metadata previously present on the file.

pub fn dump_to(&self, writer: &mut impl Write) -> Result<()>

Attempts to dump the MPEG-4 audio tag to the writer.

pub fn dump_to_path(&self, path: impl AsRef<Path>) -> Result<()>

Attempts to dump the MPEG-4 audio tag to the writer.

impl Tag

Album

pub fn album(&self) -> Option<&str>

Returns the album (©alb).

pub fn take_album(&mut self) -> Option<String>

Removes and returns the album (©alb).

pub fn set_album(&mut self, album: impl Into<String>)

Sets the album (©alb).

pub fn remove_album(&mut self)

Removes the album (©alb).

impl Tag

Copyright

pub fn copyright(&self) -> Option<&str>

Returns the copyright (cprt).

pub fn take_copyright(&mut self) -> Option<String>

Removes and returns the copyright (cprt).

pub fn set_copyright(&mut self, copyright: impl Into<String>)

Sets the copyright (cprt).

pub fn remove_copyright(&mut self)

Removes the copyright (cprt).

impl Tag

Encoder

pub fn encoder(&self) -> Option<&str>

Returns the encoder (©too).

pub fn take_encoder(&mut self) -> Option<String>

Removes and returns the encoder (©too).

pub fn set_encoder(&mut self, encoder: impl Into<String>)

Sets the encoder (©too).

pub fn remove_encoder(&mut self)

Removes the encoder (©too).

impl Tag

Lyrics

pub fn lyrics(&self) -> Option<&str>

Returns the lyrics (©lyr).

pub fn take_lyrics(&mut self) -> Option<String>

Removes and returns the lyrics (©lyr).

pub fn set_lyrics(&mut self, lyrics: impl Into<String>)

Sets the lyrics (©lyr).

pub fn remove_lyrics(&mut self)

Removes the lyrics (©lyr).

impl Tag

Movement

pub fn movement(&self) -> Option<&str>

Returns the movement (©mvn).

pub fn take_movement(&mut self) -> Option<String>

Removes and returns the movement (©mvn).

pub fn set_movement(&mut self, movement: impl Into<String>)

Sets the movement (©mvn).

pub fn remove_movement(&mut self)

Removes the movement (©mvn).

impl Tag

Title

pub fn title(&self) -> Option<&str>

Returns the title (©nam).

pub fn take_title(&mut self) -> Option<String>

Removes and returns the title (©nam).

pub fn set_title(&mut self, title: impl Into<String>)

Sets the title (©nam).

pub fn remove_title(&mut self)

Removes the title (©nam).

impl Tag

Tv episode name

pub fn tv_episode_name(&self) -> Option<&str>

Returns the tv episode name (tven).

pub fn take_tv_episode_name(&mut self) -> Option<String>

Removes and returns the tv episode name (tven).

pub fn set_tv_episode_name(&mut self, tv_episode_name: impl Into<String>)

Sets the tv episode name (tven).

pub fn remove_tv_episode_name(&mut self)

Removes the tv episode name (tven).

impl Tag

Tv network name

pub fn tv_network_name(&self) -> Option<&str>

Returns the tv network name (tvnn).

pub fn take_tv_network_name(&mut self) -> Option<String>

Removes and returns the tv network name (tvnn).

pub fn set_tv_network_name(&mut self, tv_network_name: impl Into<String>)

Sets the tv network name (tvnn).

pub fn remove_tv_network_name(&mut self)

Removes the tv network name (tvnn).

impl Tag

Tv show name

pub fn tv_show_name(&self) -> Option<&str>

Returns the tv show name (tvsh).

pub fn take_tv_show_name(&mut self) -> Option<String>

Removes and returns the tv show name (tvsh).

pub fn set_tv_show_name(&mut self, tv_show_name: impl Into<String>)

Sets the tv show name (tvsh).

pub fn remove_tv_show_name(&mut self)

Removes the tv show name (tvsh).

impl Tag

Work

pub fn work(&self) -> Option<&str>

Returns the work (©wrk).

pub fn take_work(&mut self) -> Option<String>

Removes and returns the work (©wrk).

pub fn set_work(&mut self, work: impl Into<String>)

Sets the work (©wrk).

pub fn remove_work(&mut self)

Removes the work (©wrk).

impl Tag

Year

pub fn year(&self) -> Option<&str>

Returns the year (©day).

pub fn take_year(&mut self) -> Option<String>

Removes and returns the year (©day).

pub fn set_year(&mut self, year: impl Into<String>)

Sets the year (©day).

pub fn remove_year(&mut self)

Removes the year (©day).

impl Tag

Isrc

pub fn isrc(&self) -> Option<&str>

Returns the isrc (----:com.apple.iTunes:ISRC).

pub fn take_isrc(&mut self) -> Option<String>

Removes and returns the isrc (----:com.apple.iTunes:ISRC).

pub fn set_isrc(&mut self, isrc: impl Into<String>)

Sets the isrc (----:com.apple.iTunes:ISRC).

pub fn remove_isrc(&mut self)

Removes the isrc (----:com.apple.iTunes:ISRC).

impl Tag

Album artist

pub fn album_artists(&self) -> impl Iterator<Item = &str>

Returns all album artists (aART).

pub fn album_artist(&self) -> Option<&str>

Returns the first album artist (aART).

pub fn take_album_artists(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all album artists (aART).

pub fn take_album_artist(&mut self) -> Option<String>

Removes all and returns the first album artist (aART).

pub fn set_album_artists(
    &mut self,
    album_artists: impl IntoIterator<Item = String>
)

Sets all album artists (aART). This will remove all other album artists.

pub fn set_album_artist(&mut self, album_artist: impl Into<String>)

Sets the album artist (aART). This will remove all other album artists.

pub fn add_album_artists(
    &mut self,
    album_artists: impl IntoIterator<Item = String>
)

Adds all album artists (aART).

pub fn add_album_artist(&mut self, album_artist: impl Into<String>)

Adds an album artist (aART).

pub fn remove_album_artists(&mut self)

Removes all album artists (aART).

impl Tag

Artist

pub fn artists(&self) -> impl Iterator<Item = &str>

Returns all artists (©ART).

pub fn artist(&self) -> Option<&str>

Returns the first artist (©ART).

pub fn take_artists(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all artists (©ART).

pub fn take_artist(&mut self) -> Option<String>

Removes all and returns the first artist (©ART).

pub fn set_artists(&mut self, artists: impl IntoIterator<Item = String>)

Sets all artists (©ART). This will remove all other artists.

pub fn set_artist(&mut self, artist: impl Into<String>)

Sets the artist (©ART). This will remove all other artists.

pub fn add_artists(&mut self, artists: impl IntoIterator<Item = String>)

Adds all artists (©ART).

pub fn add_artist(&mut self, artist: impl Into<String>)

Adds an artist (©ART).

pub fn remove_artists(&mut self)

Removes all artists (©ART).

impl Tag

Category

pub fn categories(&self) -> impl Iterator<Item = &str>

Returns all categories (catg).

pub fn category(&self) -> Option<&str>

Returns the first category (catg).

pub fn take_categories(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all categories (catg).

pub fn take_category(&mut self) -> Option<String>

Removes all and returns the first category (catg).

pub fn set_categories(&mut self, categories: impl IntoIterator<Item = String>)

Sets all categories (catg). This will remove all other categories.

pub fn set_category(&mut self, category: impl Into<String>)

Sets the category (catg). This will remove all other categories.

pub fn add_categories(&mut self, categories: impl IntoIterator<Item = String>)

Adds all categories (catg).

pub fn add_category(&mut self, category: impl Into<String>)

Adds an category (catg).

pub fn remove_categories(&mut self)

Removes all categories (catg).

impl Tag

Comment

pub fn comments(&self) -> impl Iterator<Item = &str>

Returns all comments (©cmt).

pub fn comment(&self) -> Option<&str>

Returns the first comment (©cmt).

pub fn take_comments(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all comments (©cmt).

pub fn take_comment(&mut self) -> Option<String>

Removes all and returns the first comment (©cmt).

pub fn set_comments(&mut self, comments: impl IntoIterator<Item = String>)

Sets all comments (©cmt). This will remove all other comments.

pub fn set_comment(&mut self, comment: impl Into<String>)

Sets the comment (©cmt). This will remove all other comments.

pub fn add_comments(&mut self, comments: impl IntoIterator<Item = String>)

Adds all comments (©cmt).

pub fn add_comment(&mut self, comment: impl Into<String>)

Adds an comment (©cmt).

pub fn remove_comments(&mut self)

Removes all comments (©cmt).

impl Tag

Composer

pub fn composers(&self) -> impl Iterator<Item = &str>

Returns all composers (©wrt).

pub fn composer(&self) -> Option<&str>

Returns the first composer (©wrt).

pub fn take_composers(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all composers (©wrt).

pub fn take_composer(&mut self) -> Option<String>

Removes all and returns the first composer (©wrt).

pub fn set_composers(&mut self, composers: impl IntoIterator<Item = String>)

Sets all composers (©wrt). This will remove all other composers.

pub fn set_composer(&mut self, composer: impl Into<String>)

Sets the composer (©wrt). This will remove all other composers.

pub fn add_composers(&mut self, composers: impl IntoIterator<Item = String>)

Adds all composers (©wrt).

pub fn add_composer(&mut self, composer: impl Into<String>)

Adds an composer (©wrt).

pub fn remove_composers(&mut self)

Removes all composers (©wrt).

impl Tag

Custom genre

pub fn custom_genres(&self) -> impl Iterator<Item = &str>

Returns all custom genres (©gen).

pub fn custom_genre(&self) -> Option<&str>

Returns the first custom genre (©gen).

pub fn take_custom_genres(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all custom genres (©gen).

pub fn take_custom_genre(&mut self) -> Option<String>

Removes all and returns the first custom genre (©gen).

pub fn set_custom_genres(
    &mut self,
    custom_genres: impl IntoIterator<Item = String>
)

Sets all custom genres (©gen). This will remove all other custom genres.

pub fn set_custom_genre(&mut self, custom_genre: impl Into<String>)

Sets the custom genre (©gen). This will remove all other custom genres.

pub fn add_custom_genres(
    &mut self,
    custom_genres: impl IntoIterator<Item = String>
)

Adds all custom genres (©gen).

pub fn add_custom_genre(&mut self, custom_genre: impl Into<String>)

Adds an custom genre (©gen).

pub fn remove_custom_genres(&mut self)

Removes all custom genres (©gen).

impl Tag

Description

pub fn descriptions(&self) -> impl Iterator<Item = &str>

Returns all descriptions (desc).

pub fn description(&self) -> Option<&str>

Returns the first description (desc).

pub fn take_descriptions(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all descriptions (desc).

pub fn take_description(&mut self) -> Option<String>

Removes all and returns the first description (desc).

pub fn set_descriptions(
    &mut self,
    descriptions: impl IntoIterator<Item = String>
)

Sets all descriptions (desc). This will remove all other descriptions.

pub fn set_description(&mut self, description: impl Into<String>)

Sets the description (desc). This will remove all other descriptions.

pub fn add_descriptions(
    &mut self,
    descriptions: impl IntoIterator<Item = String>
)

Adds all descriptions (desc).

pub fn add_description(&mut self, description: impl Into<String>)

Adds an description (desc).

pub fn remove_descriptions(&mut self)

Removes all descriptions (desc).

impl Tag

Grouping

pub fn groupings(&self) -> impl Iterator<Item = &str>

Returns all groupings (©grp).

pub fn grouping(&self) -> Option<&str>

Returns the first grouping (©grp).

pub fn take_groupings(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all groupings (©grp).

pub fn take_grouping(&mut self) -> Option<String>

Removes all and returns the first grouping (©grp).

pub fn set_groupings(&mut self, groupings: impl IntoIterator<Item = String>)

Sets all groupings (©grp). This will remove all other groupings.

pub fn set_grouping(&mut self, grouping: impl Into<String>)

Sets the grouping (©grp). This will remove all other groupings.

pub fn add_groupings(&mut self, groupings: impl IntoIterator<Item = String>)

Adds all groupings (©grp).

pub fn add_grouping(&mut self, grouping: impl Into<String>)

Adds an grouping (©grp).

pub fn remove_groupings(&mut self)

Removes all groupings (©grp).

impl Tag

Keyword

pub fn keywords(&self) -> impl Iterator<Item = &str>

Returns all keywords (keyw).

pub fn keyword(&self) -> Option<&str>

Returns the first keyword (keyw).

pub fn take_keywords(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all keywords (keyw).

pub fn take_keyword(&mut self) -> Option<String>

Removes all and returns the first keyword (keyw).

pub fn set_keywords(&mut self, keywords: impl IntoIterator<Item = String>)

Sets all keywords (keyw). This will remove all other keywords.

pub fn set_keyword(&mut self, keyword: impl Into<String>)

Sets the keyword (keyw). This will remove all other keywords.

pub fn add_keywords(&mut self, keywords: impl IntoIterator<Item = String>)

Adds all keywords (keyw).

pub fn add_keyword(&mut self, keyword: impl Into<String>)

Adds an keyword (keyw).

pub fn remove_keywords(&mut self)

Removes all keywords (keyw).

impl Tag

Lyricist

pub fn lyricists(&self) -> impl Iterator<Item = &str>

Returns all lyricists (----:com.apple.iTunes:LYRICIST).

pub fn lyricist(&self) -> Option<&str>

Returns the first lyricist (----:com.apple.iTunes:LYRICIST).

pub fn take_lyricists(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all lyricists (----:com.apple.iTunes:LYRICIST).

pub fn take_lyricist(&mut self) -> Option<String>

Removes all and returns the first lyricist (----:com.apple.iTunes:LYRICIST).

pub fn set_lyricists(&mut self, lyricists: impl IntoIterator<Item = String>)

Sets all lyricists (----:com.apple.iTunes:LYRICIST). This will remove all other lyricists.

pub fn set_lyricist(&mut self, lyricist: impl Into<String>)

Sets the lyricist (----:com.apple.iTunes:LYRICIST). This will remove all other lyricists.

pub fn add_lyricists(&mut self, lyricists: impl IntoIterator<Item = String>)

Adds all lyricists (----:com.apple.iTunes:LYRICIST).

pub fn add_lyricist(&mut self, lyricist: impl Into<String>)

Adds an lyricist (----:com.apple.iTunes:LYRICIST).

pub fn remove_lyricists(&mut self)

Removes all lyricists (----:com.apple.iTunes:LYRICIST).

impl Tag

Compilation

pub fn compilation(&self) -> bool

Returns the compilation flag (cpil).

pub fn set_compilation(&mut self)

Sets the compilation flag to true (cpil).

pub fn remove_compilation(&mut self)

Removes the compilation flag (cpil).

impl Tag

Gapless playback

pub fn gapless_playback(&self) -> bool

Returns the gapless playback flag (pgap).

pub fn set_gapless_playback(&mut self)

Sets the gapless playback flag to true (pgap).

pub fn remove_gapless_playback(&mut self)

Removes the gapless playback flag (pgap).

impl Tag

Show movement

pub fn show_movement(&self) -> bool

Returns the show movement flag (shwm).

pub fn set_show_movement(&mut self)

Sets the show movement flag to true (shwm).

pub fn remove_show_movement(&mut self)

Removes the show movement flag (shwm).

impl Tag

Bpm

pub fn bpm(&self) -> Option<u16>

Returns the bpm (tmpo)

pub fn set_bpm(&mut self, bpm: u16)

Sets the bpm (tmpo)

pub fn remove_bpm(&mut self)

Removes the bpm (tmpo).

impl Tag

Movement count

pub fn movement_count(&self) -> Option<u16>

Returns the movement count (©mvc)

pub fn set_movement_count(&mut self, movement_count: u16)

Sets the movement count (©mvc)

pub fn remove_movement_count(&mut self)

Removes the movement count (©mvc).

impl Tag

Movement index

pub fn movement_index(&self) -> Option<u16>

Returns the movement index (©mvi)

pub fn set_movement_index(&mut self, movement_index: u16)

Sets the movement index (©mvi)

pub fn remove_movement_index(&mut self)

Removes the movement index (©mvi).

impl Tag

Tv episode

pub fn tv_episode(&self) -> Option<u32>

Returns the tv episode (tves)

pub fn set_tv_episode(&mut self, tv_episode: u32)

Sets the tv episode (tves)

pub fn remove_tv_episode(&mut self)

Removes the tv episode (tves).

impl Tag

Tv season

pub fn tv_season(&self) -> Option<u32>

Returns the tv season (tvsn)

pub fn set_tv_season(&mut self, tv_season: u32)

Sets the tv season (tvsn)

pub fn remove_tv_season(&mut self)

Removes the tv season (tvsn).

impl Tag

Artwork

pub fn artworks(&self) -> impl Iterator<Item = ImgRef<'_>>

Returns all artwork images (covr).

pub fn artwork(&self) -> Option<ImgRef<'_>>

Returns the first artwork image (covr).

pub fn take_artworks(&mut self) -> impl Iterator<Item = ImgBuf> + '_

Removes and returns all artwork images (covr).

pub fn take_artwork(&mut self) -> Option<ImgBuf>

Removes all and returns the first artwork image (covr).

pub fn set_artwork(&mut self, image: Img<impl Into<Vec<u8>>>)

Sets the artwork image data (covr). This will remove all other artworks.

pub fn set_artworks(&mut self, images: impl IntoIterator<Item = ImgBuf>)

Sets all artwork image data (covr). This will remove all other artworks.

pub fn add_artwork(&mut self, image: Img<impl Into<Vec<u8>>>)

Adds artwork image data (covr).

pub fn add_artworks(&mut self, images: impl IntoIterator<Item = ImgBuf>)

Adds artwork image data (covr).

pub fn remove_artworks(&mut self)

Removes all artworks (covr).

impl Tag

Media type

pub fn media_type(&self) -> Option<MediaType>

Returns the media type (stik).

pub fn set_media_type(&mut self, media_type: MediaType)

Sets the media type (stik).

pub fn remove_media_type(&mut self)

Removes the media type (stik).

impl Tag

Advisory rating

pub fn advisory_rating(&self) -> Option<AdvisoryRating>

Returns the advisory rating (rtng).

pub fn set_advisory_rating(&mut self, rating: AdvisoryRating)

Sets the advisory rating (rtng).

pub fn remove_advisory_rating(&mut self)

Removes the advisory rating (rtng).

impl Tag

Data accessors

pub fn bytes_of<'a>(
    &'a self,
    ident: &'a impl Ident
) -> impl Iterator<Item = &[u8]>

Returns references to all byte data corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::BeSigned(b"data".to_vec()));
assert_eq!(tag.bytes_of(&test).next().unwrap(), b"data");

pub fn bytes_mut_of<'a>(
    &'a mut self,
    ident: &'a impl Ident
) -> impl Iterator<Item = &mut Vec<u8>>

Returns mutable references to all byte data corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Reserved(b"data".to_vec()));
tag.bytes_mut_of(&test).next().unwrap().push('1' as u8);
assert_eq!(tag.bytes_of(&test).next().unwrap(), b"data1");

pub fn take_bytes_of<'a>(
    &'a mut self,
    ident: &'a impl Ident
) -> impl Iterator<Item = Vec<u8>> + '_

Removes the atom corresponding to the identifier and returns all of it’s byte data.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Reserved(b"data".to_vec()));
assert_eq!(tag.take_bytes_of(&test).next().unwrap(), b"data");
assert_eq!(tag.bytes_of(&test).next(), None);

pub fn strings_of<'a>(
    &'a self,
    ident: &'a impl Ident
) -> impl Iterator<Item = &str>

Returns references to all strings corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.strings_of(&test).next().unwrap(), "data");

pub fn strings_mut_of<'a>(
    &'a mut self,
    ident: &'a impl Ident
) -> impl Iterator<Item = &mut String>

Returns all mutable string references corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("string".into()));
tag.strings_mut_of(&test).next().unwrap().push('1');
assert_eq!(tag.strings_of(&test).next().unwrap(), "string1");

pub fn take_strings_of<'a>(
    &'a mut self,
    ident: &'a impl Ident
) -> impl Iterator<Item = String>

Removes the atom corresponding to the identifier and returns all of it’s strings.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("string".into()));
assert_eq!(tag.take_strings_of(&test).next().unwrap(), "string");
assert_eq!(tag.strings_of(&test).next(), None);

pub fn images_of<'a>(
    &'a self,
    ident: &'a impl Ident
) -> impl Iterator<Item = ImgRef<'_>>

Returns references to all images corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Jpeg(b"image".to_vec()));
let img = tag.images_of(&test).next().unwrap();
assert_eq!(img.data, b"image");

pub fn images_mut_of<'a>(
    &'a mut self,
    ident: &'a impl Ident
) -> impl Iterator<Item = ImgMut<'a>>

Returns mutable references to all images corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Jpeg(b"image".to_vec()));
let img = tag.images_mut_of(&test).next().unwrap();
img.data.push('1' as u8);

let img = tag.images_of(&test).next().unwrap();
assert_eq!(img.data, b"image1");

pub fn take_images_of(
    &mut self,
    ident: &impl Ident
) -> impl Iterator<Item = ImgBuf>

Removes the atom corresponding to the identifier and returns all of it’s images.

Example

use mp4ameta::{Tag, Data, Fourcc, Img};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Png(b"image".to_vec()));
assert_eq!(tag.take_images_of(&test).next().unwrap(), Img::png(b"image".to_vec()));
assert_eq!(tag.images_of(&test).next(), None);

pub fn data_of<'a>(
    &'a self,
    ident: &'a impl Ident
) -> impl Iterator<Item = &Data>

Returns references to all data corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.data_of(&test).next().unwrap().string(), Some("data"));

pub fn data_mut_of(
    &mut self,
    ident: &impl Ident
) -> impl Iterator<Item = &mut Data>

Returns mutable references to all data corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
let data = tag.data_mut_of(&test).next().unwrap();
data.string_mut().unwrap().push('1');
assert_eq!(tag.strings_of(&test).next().unwrap(), "data1");

pub fn take_data_of(&mut self, ident: &impl Ident) -> impl Iterator<Item = Data>

Removes the atom corresponding to the identifier and returns all of it’s data.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.take_data_of(&test).next().unwrap(), Data::Utf8("data".into()));
assert_eq!(tag.data_of(&test).next(), None);

pub fn bytes(&self) -> impl Iterator<Item = (&DataIdent, &[u8])>

Returns an iterator over references to all byte data.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data1".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::BeSigned(b"data2".to_vec()));

let test = DataIdent::Fourcc(test);
let mut bytes = tag.bytes();
assert_eq!(bytes.next().unwrap(), (&test, &b"data1"[..]));
assert_eq!(bytes.next().unwrap(), (&test, &b"data2"[..]));
assert_eq!(bytes.next(), None);

pub fn bytes_mut(&mut self) -> impl Iterator<Item = (&DataIdent, &mut Vec<u8>)>

Returns an iterator over mutable references to all byte data.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let (ident, data) = tag.bytes_mut().next().unwrap();
data.push('1' as u8);

let test = DataIdent::Fourcc(test);
let mut bytes = tag.bytes();
assert_eq!(bytes.next().unwrap(), (&test, &b"data1"[..]));
assert_eq!(bytes.next(), None);

pub fn take_bytes(self) -> impl Iterator<Item = (Rc<DataIdent>, Vec<u8>)>

Consumes self and returns an iterator over all byte data.

Example

use std::rc::Rc;
use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let test = DataIdent::Fourcc(test);
let (ident, data) = tag.take_bytes().next().unwrap();
assert_eq!(ident.as_ref(), &test);
assert_eq!(data, b"data".to_vec());

pub fn strings(&self) -> impl Iterator<Item = (&DataIdent, &str)>

Returns an iterator over references to all strings.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string1".into()));
tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf16("string2".into()));

let test = DataIdent::Fourcc(test);
let mut strings = tag.strings();
assert_eq!(strings.next().unwrap(), (&test, "string1"));
assert_eq!(strings.next().unwrap(), (&test, "string2"));
assert_eq!(strings.next(), None);

pub fn strings_mut(&mut self) -> impl Iterator<Item = (&DataIdent, &mut String)>

Returns an iterator over mutable references to all strings.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let (ident, data) = tag.strings_mut().next().unwrap();
data.push('1');

let test = DataIdent::Fourcc(test);
let mut strings = tag.strings();
assert_eq!(strings.next().unwrap(), (&test, "string1"));
assert_eq!(strings.next(), None);

pub fn take_strings(self) -> impl Iterator<Item = (Rc<DataIdent>, String)>

Consumes self and returns an iterator over all strings.

Example

use std::rc::Rc;
use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let test = DataIdent::Fourcc(test);
let (ident, data) = tag.take_strings().next().unwrap();
assert_eq!(ident.as_ref(), &test);
assert_eq!(data, "string".to_string());

pub fn images(&self) -> impl Iterator<Item = (&DataIdent, ImgRef<'_>)>

Returns an iterator over references to all images.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc, Img};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Png(b"image1".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Jpeg(b"image2".to_vec()));

let test = DataIdent::Fourcc(test);
let mut images = tag.images();
assert_eq!(images.next().unwrap(), (&test, Img::png(&b"image1"[..])));
assert_eq!(images.next().unwrap(), (&test, Img::jpeg(&b"image2"[..])));
assert_eq!(images.next(), None);

pub fn images_mut(&mut self) -> impl Iterator<Item = (&DataIdent, ImgMut<'_>)>

Returns an iterator over mutable references to all images.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc, Img};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Bmp(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let (ident, image) = tag.images_mut().next().unwrap();
image.data.push('1' as u8);

let test = DataIdent::Fourcc(test);
let mut images = tag.images();
assert_eq!(images.next().unwrap(), (&test, Img::bmp(&b"data1"[..])));
assert_eq!(images.next(), None);

pub fn take_images(self) -> impl Iterator<Item = (Rc<DataIdent>, ImgBuf)>

Consumes self and returns an iterator over all images.

Example

use std::rc::Rc;
use mp4ameta::{Tag, Data, DataIdent, Fourcc, Img};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Jpeg(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let test = DataIdent::Fourcc(test);
let (ident, image) = tag.take_images().next().unwrap();
assert_eq!(ident.as_ref(), &test);
assert_eq!(image, Img::jpeg(b"data".to_vec()));

pub fn data(&self) -> impl Iterator<Item = (&DataIdent, &Data)>

Returns an iterator over references to all data.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Png(b"image".to_vec()));

let test = DataIdent::Fourcc(test);
let mut data = tag.data();
assert_eq!(data.next().unwrap(), (&test, &Data::Reserved(b"data".to_vec())));
assert_eq!(data.next().unwrap(), (&test, &Data::Utf8("string".into())));
assert_eq!(data.next().unwrap(), (&test, &Data::Png(b"image".to_vec())));
assert_eq!(data.next(), None);

pub fn data_mut(&mut self) -> impl Iterator<Item = (&DataIdent, &mut Data)>

Returns an iterator over mutable references to all data.

Example

use mp4ameta::{Tag, Data, DataIdent, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));

let (ident, data) = tag.data_mut().next().unwrap();
data.string_mut().unwrap().push('1');

let test = DataIdent::Fourcc(test);
let mut strings = tag.strings();
assert_eq!(strings.next().unwrap(), (&test, "string1"));
assert_eq!(strings.next(), None);

pub fn take_data(self) -> impl Iterator<Item = (Rc<DataIdent>, Data)>

Consumes self and returns an iterator over all data.

Example

use std::rc::Rc;
use mp4ameta::{Tag, Data, DataIdent, Fourcc, Img};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Jpeg(b"data".to_vec()));

let test = DataIdent::Fourcc(test);
let (ident, image) = tag.take_data().next().unwrap();
assert_eq!(ident.as_ref(), &test);
assert_eq!(image, Data::Jpeg(b"data".to_vec()));

pub fn remove_bytes_of(&mut self, ident: &impl Ident)

Removes all byte data corresponding to the identifier. Other data will remain unaffected.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::BeSigned("data".into()));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), Some(&Data::BeSigned(b"data".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.remove_bytes_of(&test);


let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), None);

pub fn remove_strings_of(&mut self, ident: &impl Ident)

Removes all strings corresponding to the identifier. Other data will remain unaffected.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Bmp("image".into()));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), Some(&Data::Bmp(b"image".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.remove_strings_of(&test);


let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Bmp(b"image".to_vec())));
assert_eq!(data.next(), None);

pub fn remove_images_of(&mut self, ident: &impl Ident)

Removes all images corresponding to the identifier. Other data will remain unaffected.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Bmp("image".into()));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), Some(&Data::Bmp(b"image".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.remove_images_of(&test);


let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), None);

pub fn remove_data_of(&mut self, ident: &impl Ident)

Removes all data corresponding to the identifier.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert!(tag.data_of(&test).next().is_some());
tag.remove_data_of(&test);
assert!(tag.data_of(&test).next().is_none());

pub fn retain_bytes_of(
    &mut self,
    ident: &impl Ident,
    predicate: impl Fn(&[u8]) -> bool
)

Retains only the bytes, of the atom corresponding to the identifier, that match the predicate.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::BeSigned(vec![4u8; 12]));
tag.add_data(test, Data::Reserved(vec![6u8; 16]));

let mut bytes = tag.bytes_of(&test);
assert_eq!(bytes.next(), Some(&[4u8; 12][..]));
assert_eq!(bytes.next(), Some(&[6u8; 16][..]));
assert_eq!(bytes.next(), None);
drop(bytes);

tag.retain_bytes_of(&test, |b| b[2..4] == [4u8, 4u8]);

let mut bytes = tag.bytes_of(&test);
assert_eq!(bytes.next(), Some(&[4u8; 12][..]));
assert_eq!(bytes.next(), None);

pub fn retain_strings_of(
    &mut self,
    ident: &impl Ident,
    predicate: impl Fn(&str) -> bool
)

Retains only the strings, of the atom corresponding to the identifier, that match the predicate.

Example

use mp4ameta::{Tag, Data, Fourcc, Img, ImgFmt};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string1".into()));
tag.add_data(test, Data::Utf8("string2".into()));

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("string1"));
assert_eq!(strings.next(), Some("string2"));
assert_eq!(strings.next(), None);
drop(strings);

tag.retain_strings_of(&test, |s| s.ends_with("1"));

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("string1"));
assert_eq!(strings.next(), None);

pub fn retain_images_of(
    &mut self,
    ident: &impl Ident,
    predicate: impl Fn(ImgRef<'_>) -> bool
)

Retains only the images, of the atom corresponding to the identifier, that match the predicate.

Example

use mp4ameta::{Tag, Data, Fourcc, Img, ImgFmt};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Png(vec![5u8; 4]));
tag.add_data(test, Data::Jpeg(vec![6u8; 16]));

let mut images = tag.images_of(&test);
assert_eq!(images.next(), Some(Img::new(ImgFmt::Png, &[5u8; 4][..])));
assert_eq!(images.next(), Some(Img::new(ImgFmt::Jpeg, &[6u8; 16][..])));
assert_eq!(images.next(), None);
drop(images);

tag.retain_images_of(&test, |d| d.fmt == ImgFmt::Jpeg);

let mut images = tag.images_of(&test);
assert_eq!(images.next(), Some(Img::new(ImgFmt::Jpeg, &[6u8; 16][..])));
assert_eq!(images.next(), None);

pub fn retain_data_of(
    &mut self,
    ident: &impl Ident,
    predicate: impl Fn(&Data) -> bool
)

Retains only the data, of the atom corresponding to the identifier, that matches the predicate.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("short".into()));
tag.add_data(test, Data::Reserved(vec![6u8; 16]));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("short".into())));
assert_eq!(data.next(), Some(&Data::Reserved(vec![6u8; 16])));
assert_eq!(data.next(), None);
drop(data);

tag.retain_data_of(&test, |d| d.len() < 10);

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("short".into())));
assert_eq!(data.next(), None);

pub fn retain_bytes(&mut self, predicate: impl Fn(&DataIdent, &[u8]) -> bool)

Retains only the byte data matching the predicate. Other data will remain unaffected.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Reserved(b"data1".to_vec()));
tag.add_data(tst2, Data::Png(b"data2".to_vec()));
tag.add_data(tst2, Data::BeSigned(b"data3".to_vec()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Reserved(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), Some(&Data::BeSigned(b"data3".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_bytes(|i, d| &tst1 == i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Reserved(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), None);

pub fn retain_strings(&mut self, predicate: impl Fn(&DataIdent, &str) -> bool)

Retains only the strings matching the predicate. Other data will remain unaffected.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Utf8("data1".into()));
tag.add_data(tst2, Data::Png(b"data2".to_vec()));
tag.add_data(tst2, Data::Utf8("data3".into()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data1".into())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), Some(&Data::Utf8("data3".into())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_strings(|i, d| &tst1 == i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data1".into())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), None);

pub fn retain_images(
    &mut self,
    predicate: impl Fn(&DataIdent, ImgRef<'_>) -> bool
)

Retains only the images matching the predicate. Other data will remain unaffected.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Jpeg(b"data1".to_vec()));
tag.add_data(tst2, Data::Png(b"data2".to_vec()));
tag.add_data(tst2, Data::Utf8("data3".into()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Jpeg(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), Some(&Data::Utf8("data3".into())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_images(|i, d| &tst1 == i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Jpeg(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Utf8("data3".into())));
assert_eq!(data.next(), None);

pub fn retain_data(&mut self, predicate: impl Fn(&DataIdent, &Data) -> bool)

Retains only the data matching the predicate.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Utf8("data1".into()));
tag.add_data(tst2, Data::Utf8("data2".into()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data1".into())));
assert_eq!(data.next(), Some(&Data::Utf8("data2".into())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_data(|i, d| &tst1 != i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data2".into())));
assert_eq!(data.next(), None);

pub fn clear(&mut self)

Removes all metadata atoms of the tag.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

assert!(tag.is_empty());
tag.set_data(test, Data::Utf8("data".into()));
assert!(!tag.is_empty());
tag.clear();
assert!(tag.is_empty());

pub fn set_data(&mut self, ident: impl Ident + Into<DataIdent>, data: Data)

If an atom corresponding to the identifier exists, it’s data will be replaced by the new data, otherwise a new atom containing the data will be created.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.strings_of(&test).next().unwrap(), "data");

pub fn set_all_data(
    &mut self,
    ident: impl Ident + Into<DataIdent>,
    data: impl IntoIterator<Item = Data>
)

If an atom corresponding to the identifier exists, it’s data will be replaced by the new data, otherwise a new atom containing the data will be created.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

let data = vec![
    Data::Utf8("data1".into()),
    Data::Utf8("data2".into()),
];
tag.set_all_data(test, data);

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("data1"));
assert_eq!(strings.next(), Some("data2"));
assert_eq!(strings.next(), None);

pub fn add_data(&mut self, ident: impl Ident + Into<DataIdent>, data: Data)

If an atom corresponding to the identifier exists, the new data will be added to it, otherwise a new atom containing the data will be created.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("data1".into()));
tag.add_data(test, Data::Utf8("data2".into()));

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("data1"));
assert_eq!(strings.next(), Some("data2"));
assert_eq!(strings.next(), None)

pub fn add_all_data(
    &mut self,
    ident: impl Ident + Into<DataIdent>,
    data: impl IntoIterator<Item = Data>
)

If an atom corresponding to the identifier exists, the new data will be added to it, otherwise a new atom containing the data will be created.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

let data = vec![
    Data::Utf8("data1".into()),
    Data::Utf8("data2".into()),
];
tag.add_all_data(test, data);

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("data1"));
assert_eq!(strings.next(), Some("data2"));
assert_eq!(strings.next(), None)

pub fn is_empty(&self) -> bool

Returns true if this tag contains any metadata atoms, false otherwise.

Example

use mp4ameta::{Tag, Data, Fourcc};

let mut tag = Tag::default();
let test = Fourcc(*b"test");

assert!(tag.is_empty());
tag.set_data(test, Data::Utf8("data".into()));
assert!(!tag.is_empty());
tag.clear();
assert!(tag.is_empty());

use mp4ameta::{Tag, Data, Fourcc};

Trait Implementations

impl Clone for Tag

fn clone(&self) -> Tag

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tag

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

Formats the value using the given formatter.

impl Default for Tag

fn default() -> Tag

Returns the “default value” for a type.

impl Display for Tag

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

Formats the value using the given formatter.

impl PartialEq<Tag> for Tag

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

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

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

This method tests for !=.

impl Eq for Tag

impl StructuralEq for Tag

impl StructuralPartialEq for Tag