Struct lofty::BoundTaggedFile

pub struct BoundTaggedFile { /* private fields */ }

A variant of TaggedFile that holds a File handle, and reflects changes such as tag removals.

For example:

use lofty::{AudioFile, Tag, TagType, TaggedFileExt};

// We create an empty tag
let tag = Tag::new(TagType::Id3v2);

let mut tagged_file = lofty::read_from_path(path)?;

// Push our empty tag into the TaggedFile
tagged_file.insert_tag(tag);

// After saving, our file still "contains" the ID3v2 tag, but if we were to read
// "foo.mp3", it would not have an ID3v2 tag. Lofty does not write empty tags, but this
// change will not be reflected in `TaggedFile`.
tagged_file.save_to_path("foo.mp3")?;
assert!(tagged_file.contains_tag_type(TagType::Id3v2));

However, when using BoundTaggedFile:

use lofty::{AudioFile, BoundTaggedFile, ParseOptions, Tag, TagType, TaggedFileExt};
use std::fs::OpenOptions;

// We create an empty tag
let tag = Tag::new(TagType::Id3v2);

// We'll need to open our file for reading *and* writing
let file = OpenOptions::new().read(true).write(true).open(path)?;
let parse_options = ParseOptions::new();

let mut bound_tagged_file = BoundTaggedFile::read_from(file, parse_options)?;

// Push our empty tag into the TaggedFile
bound_tagged_file.insert_tag(tag);

// Now when saving, we no longer have to specify a path, and the tags in the `BoundTaggedFile`
// reflect those in the actual file on disk.
bound_tagged_file.save()?;
assert!(!bound_tagged_file.contains_tag_type(TagType::Id3v2));

Implementations

impl BoundTaggedFile

pub fn read_from(file: File, parse_options: ParseOptions) -> Result<Self>

Create a new BoundTaggedFile

Errors

See AudioFile::read_from

Examples

use lofty::{AudioFile, BoundTaggedFile, ParseOptions, Tag, TagType, TaggedFileExt};
use std::fs::OpenOptions;

// We'll need to open our file for reading *and* writing
let file = OpenOptions::new().read(true).write(true).open(path)?;
let parse_options = ParseOptions::new();

let bound_tagged_file = BoundTaggedFile::read_from(file, parse_options)?;

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

Save the tags to the file stored internally

Errors

See TaggedFile::save_to

Examples

use lofty::{AudioFile, BoundTaggedFile, ParseOptions, Tag, TagType, TaggedFileExt};
use std::fs::OpenOptions;

// We'll need to open our file for reading *and* writing
let file = OpenOptions::new().read(true).write(true).open(path)?;
let parse_options = ParseOptions::new();

let mut bound_tagged_file = BoundTaggedFile::read_from(file, parse_options)?;

// Do some work to the tags...

// This will save the tags to the file we provided to `read_from`
bound_tagged_file.save()?;

Trait Implementations

impl AudioFile for BoundTaggedFile

type Properties = FileProperties

The struct the file uses for audio properties

fn read_from<R>(_: &mut R, _: ParseOptions) -> Result<Self>where R: Read + Seek, Self: Sized,

Read a file from a reader

fn save_to(&self, file: &mut File) -> Result<()>

Attempts to write all tags to a file

fn properties(&self) -> &Self::Properties

Returns a reference to the file’s properties

fn contains_tag(&self) -> bool

Checks if the file contains any tags

fn contains_tag_type(&self, tag_type: TagType) -> bool

Checks if the file contains the given TagType

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

Attempts to write all tags to a path

impl From<BoundTaggedFile> for TaggedFile

fn from(input: BoundTaggedFile) -> Self

Converts to this type from the input type.

impl TaggedFileExt for BoundTaggedFile

fn file_type(&self) -> FileType

Returns the file’s FileType

fn tags(&self) -> &[Tag]

Returns all tags

fn tag(&self, tag_type: TagType) -> Option<&Tag>

Get a reference to a specific TagType

fn tag_mut(&mut self, tag_type: TagType) -> Option<&mut Tag>

Get a mutable reference to a specific TagType

fn first_tag_mut(&mut self) -> Option<&mut Tag>

Gets a mutable reference to the first tag, if there are any

fn insert_tag(&mut self, tag: Tag) -> Option<Tag>

Inserts a Tag

fn remove(&mut self, tag_type: TagType) -> Option<Tag>

Removes a specific TagType and returns it

fn clear(&mut self)

Removes all tags from the file

fn primary_tag_type(&self) -> TagType

Returns the file type’s primary TagType

fn supports_tag_type(&self, tag_type: TagType) -> bool

Determines whether the file supports the given TagType

fn primary_tag(&self) -> Option<&Tag>

Returns the primary tag

fn primary_tag_mut(&mut self) -> Option<&mut Tag>

Gets a mutable reference to the file’s “Primary tag”

fn first_tag(&self) -> Option<&Tag>

Gets the first tag, if there are any