lrc 0.2.0

A pure Rust implementation of LyRiCs which is a computer file format that synchronizes song lyrics with an audio file.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::collections::BTreeMap;

use educe::Educe;
use unicase::UniCase;

use crate::{IDTag, LyricsError};

/// Metadata tags keyed by their case-insensitive LRC label.
#[derive(Debug, Clone, Educe)]
#[educe(Default(new), PartialEq, Eq, PartialOrd, Ord)]
pub struct Metadata {
    tags: BTreeMap<UniCase<String>, IDTag>,
}

impl Metadata {
    #[inline]
    fn key<L: AsRef<str>>(label: L) -> UniCase<String> {
        UniCase::new(label.as_ref().trim().to_string())
    }

    /// Insert an ID tag and return the previous tag with the same label.
    #[inline]
    pub fn insert(&mut self, tag: IDTag) -> Option<IDTag> {
        self.tags.insert(Self::key(tag.label()), tag)
    }

    /// Create and insert an ID tag from a label and text.
    #[inline]
    pub fn set<L: Into<String>, T: Into<String>>(
        &mut self,
        label: L,
        text: T,
    ) -> Result<Option<IDTag>, LyricsError> {
        Ok(self.insert(IDTag::from_string(label, text)?))
    }

    /// Get an ID tag by label.
    #[inline]
    pub fn get<L: AsRef<str>>(&self, label: L) -> Option<&IDTag> {
        self.tags.get(&Self::key(label))
    }

    /// Get an ID tag's text by label.
    #[inline]
    pub fn get_text<L: AsRef<str>>(&self, label: L) -> Option<&str> {
        self.get(label).map(IDTag::text)
    }

    /// Remove and return an ID tag by label.
    #[inline]
    pub fn remove<L: AsRef<str>>(&mut self, label: L) -> Option<IDTag> {
        self.tags.remove(&Self::key(label))
    }

    /// Iterate over metadata tags in label order.
    #[inline]
    pub fn iter(&self) -> impl Iterator<Item = &IDTag> {
        self.tags.values()
    }

    /// Get the number of metadata tags.
    #[inline]
    pub fn len(&self) -> usize {
        self.tags.len()
    }

    /// Check whether this metadata collection is empty.
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.tags.is_empty()
    }
}

impl Metadata {
    /// Get the title tag text.
    #[inline]
    pub fn title(&self) -> Option<&str> {
        self.get_text("ti")
    }

    /// Set the title tag text.
    #[inline]
    pub fn set_title<T: Into<String>>(&mut self, title: T) -> Result<Option<IDTag>, LyricsError> {
        self.set("ti", title)
    }

    /// Get the artist tag text.
    #[inline]
    pub fn artist(&self) -> Option<&str> {
        self.get_text("ar")
    }

    /// Set the artist tag text.
    #[inline]
    pub fn set_artist<T: Into<String>>(&mut self, artist: T) -> Result<Option<IDTag>, LyricsError> {
        self.set("ar", artist)
    }

    /// Get the album tag text.
    #[inline]
    pub fn album(&self) -> Option<&str> {
        self.get_text("al")
    }

    /// Set the album tag text.
    #[inline]
    pub fn set_album<T: Into<String>>(&mut self, album: T) -> Result<Option<IDTag>, LyricsError> {
        self.set("al", album)
    }

    /// Get the author tag text.
    #[inline]
    pub fn author(&self) -> Option<&str> {
        self.get_text("au")
    }

    /// Set the author tag text.
    #[inline]
    pub fn set_author<T: Into<String>>(&mut self, author: T) -> Result<Option<IDTag>, LyricsError> {
        self.set("au", author)
    }

    /// Get the length tag text.
    #[inline]
    pub fn length(&self) -> Option<&str> {
        self.get_text("length")
    }

    /// Set the length tag text.
    #[inline]
    pub fn set_length<T: Into<String>>(&mut self, length: T) -> Result<Option<IDTag>, LyricsError> {
        self.set("length", length)
    }
}