Struct metaflac::Tag

pub struct Tag { /* fields omitted */ }

A structure representing a flac metadata tag.

Implementations

impl<'a> Tag

pub fn new() -> Tag

Creates a new FLAC tag with no blocks.

pub fn push_block(&mut self, block: Block)

Adds a block to the tag.

pub fn blocks(&'a self) -> impl Iterator<Item = &'a Block> + 'a

Returns a reference to the blocks in the tag.

pub fn get_blocks(
    &'a self,
    block_type: BlockType
) -> impl Iterator<Item = &'a Block> + 'a

Returns references to the blocks with the specified type.

pub fn remove_blocks(&mut self, block_type: BlockType)

Removes blocks with the specified type.

Example

use metaflac::{Tag, Block, BlockType};

let mut tag = Tag::new();
tag.push_block(Block::Padding(10));
tag.push_block(Block::Unknown((20, Vec::new())));
tag.push_block(Block::Padding(15));

tag.remove_blocks(BlockType::Padding);
assert_eq!(tag.blocks().count(), 1);

pub fn vorbis_comments(&self) -> Option<&VorbisComment>

Returns a reference to the first vorbis comment block. Returns None if no vorbis comment blocks are found.

Example

use metaflac::Tag;

let mut tag = Tag::new();
assert!(tag.vorbis_comments().is_none());
tag.set_vorbis("key", vec!("value"));
assert!(tag.vorbis_comments().is_some());

pub fn vorbis_comments_mut(&mut self) -> &mut VorbisComment

Returns a mutable reference to the first vorbis comment block. If no block is found, a new vorbis comment block is added to the tag and a reference to the newly added block is returned.

Example

use metaflac::Tag;

let mut tag = Tag::new();
assert!(tag.vorbis_comments().is_none());

let key = "key".to_owned();
let value1 = "value1".to_owned();
let value2 = "value2".to_owned();

tag.vorbis_comments_mut().comments.insert(key.clone(), vec!(value1.clone(),
    value2.clone()));

assert!(tag.vorbis_comments().is_some());
assert!(tag.vorbis_comments().unwrap().comments.get(&key).is_some());

pub fn get_vorbis(
    &'a self,
    key: &str
) -> Option<impl Iterator<Item = &'a str> + 'a>

Returns a vector of strings values for the specified vorbis comment key. Returns None if the tag does not contain a vorbis comment or if the vorbis comment does not contain a comment with the specified key.

Example

use metaflac::Tag;

let mut tag = Tag::new();

let key = "key".to_owned();
let value1 = "value1".to_owned();
let value2 = "value2".to_owned();

tag.set_vorbis(&key, vec!(&value1, &value2));

assert_eq!(tag.get_vorbis(&key).unwrap().collect::<Vec<_>>(), &[&value1, &value2]);

pub fn set_vorbis<K: Into<String>, V: Into<String>>(
    &mut self,
    key: K,
    values: Vec<V>
)

Sets the values for the specified vorbis comment key.

Example

use metaflac::Tag;

let mut tag = Tag::new();

let key = "key".to_owned();
let value1 = "value1".to_owned();
let value2 = "value2".to_owned();

tag.set_vorbis(&key, vec!(&value1, &value2));

assert_eq!(tag.get_vorbis(&key).unwrap().collect::<Vec<_>>(), &[&value1, &value2]);

pub fn remove_vorbis(&mut self, key: &str)

Removes the values for the specified vorbis comment key.

Example

use metaflac::Tag;

let mut tag = Tag::new();

let key = "key".to_owned();
let value1 = "value1".to_owned();
let value2 = "value2".to_owned();

tag.set_vorbis(&key, vec!(&value1, &value2));
assert_eq!(tag.get_vorbis(&key).unwrap().collect::<Vec<_>>(), &[&value1, &value2]);

tag.remove_vorbis(&key);
assert!(tag.get_vorbis(&key).is_none());

pub fn remove_vorbis_pair(&mut self, key: &str, value: &str)

Removes the vorbis comments with the specified key and value.

Example

use metaflac::Tag;

let mut tag = Tag::new();

let key = "key".to_owned();
let value1 = "value1".to_owned();
let value2 = "value2".to_owned();

tag.set_vorbis(key.clone(), vec!(&value1, &value2));
assert_eq!(tag.get_vorbis(&key).unwrap().collect::<Vec<_>>(), &[&value1, &value2]);

tag.remove_vorbis_pair(&key, &value1);
assert_eq!(tag.get_vorbis(&key).unwrap().collect::<Vec<_>>(), &[&value2]);

pub fn pictures(&'a self) -> impl Iterator<Item = &'a Picture> + 'a

Returns an iterator of references to the pictures in the tag.

Example

use metaflac::Tag;
use metaflac::block::PictureType::CoverFront;

let mut tag = Tag::new();
assert_eq!(tag.pictures().count(), 0);
tag.add_picture("image/jpeg", CoverFront, vec!(0xFF));
assert_eq!(tag.pictures().count(), 1);

pub fn add_picture<T: Into<String>>(
    &mut self,
    mime_type: T,
    picture_type: PictureType,
    data: Vec<u8>
)

Adds a picture block.

Example

use metaflac::Tag;
use metaflac::block::PictureType::CoverFront;

let mut tag = Tag::new();
assert_eq!(tag.pictures().count(), 0);

tag.add_picture("image/jpeg", CoverFront, vec!(0xFF));

let picture = tag.pictures().next().unwrap();
assert_eq!(&picture.mime_type, "image/jpeg");
assert_eq!(picture.picture_type, CoverFront);
assert_eq!(&picture.data, &vec!(0xFF));

pub fn remove_picture_type(&mut self, picture_type: PictureType)

Removes the picture with the specified picture type.

Example

use metaflac::Tag;
use metaflac::block::PictureType::{CoverFront, Other};

let mut tag = Tag::new();
assert_eq!(tag.pictures().count(), 0);

tag.add_picture("image/jpeg", CoverFront, vec!(0xFF));
tag.add_picture("image/png", Other, vec!(0xAB));
assert_eq!(tag.pictures().count(), 2);

tag.remove_picture_type(CoverFront);
assert_eq!(tag.pictures().count(), 1);

let picture = tag.pictures().next().unwrap();
assert_eq!(&picture.mime_type, "image/png");
assert_eq!(picture.picture_type, Other);
assert_eq!(&picture.data, &vec!(0xAB));

pub fn get_streaminfo(&self) -> Option<&StreamInfo>

Returns a reference to the first streaminfo block. Returns None if no streaminfo blocks are found.

Example

use metaflac::Tag;
use metaflac::block::StreamInfo;

let mut tag = Tag::new();
assert!(tag.get_streaminfo().is_none());
tag.set_streaminfo(StreamInfo::new());
assert!(tag.get_streaminfo().is_some());

pub fn set_streaminfo(&mut self, block: StreamInfo)

Sets the streaminfo block. If there is already a streaminfo block then it will be replaced.

Example

use metaflac::Tag;
use metaflac::block::StreamInfo;

let mut tag = Tag::new();
tag.set_streaminfo(StreamInfo::new());
assert!(tag.get_streaminfo().is_some());

pub fn save(&mut self) -> Result<()>

Attempts to save the tag back to the file which it was read from. An Error::InvalidInput will be returned if this is called on a tag which was not read from a file.

pub fn skip_metadata<R: Read + Seek>(reader: &mut R) -> Vec<u8>

Returns the contents of the reader without any FLAC metadata.

pub fn is_candidate<R: Read + Seek>(reader: &mut R) -> bool

Will return true if the reader is a candidate for FLAC metadata. The reader position will be reset back to the previous position before returning.

pub fn read_from(reader: &mut dyn Read) -> Result<Tag>

Attempts to read a FLAC tag from the reader.

pub fn write_to(&mut self, writer: &mut dyn Write) -> Result<()>

Attempts to write the FLAC tag to the writer.

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

Attempts to write the FLAC tag to a file at the indicated path. If the specified path is the same path which the tag was read from, then the tag will be written to the padding if possible.

pub fn read_from_path<P: AsRef<Path>>(path: P) -> Result<Tag>

Attempts to read a FLAC tag from the file at the specified path.

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 Default for Tag

fn default() -> Self

Returns the “default value” for a type.