Struct SyncedLyrics 

pub struct SyncedLyrics {
    pub title: Option<String>,
    pub artist: Option<String>,
    pub album: Option<String>,
    pub author: Option<String>,
    pub lyricist: Option<String>,
    pub length: Option<Duration>,
    pub file_author: Option<String>,
    pub tool: Option<LRCTool>,
    pub comments: Vec<String>,
    pub lines: Vec<LineTag>,
}

Lyrics grouped into timestamped segments with additional metadata.

Fields

title: Option<String>

Title of the song.

artist: Option<String>

Artist performing the song.

album: Option<String>

Album the song is from.

author: Option<String>

Author of the song.

lyricist: Option<String>

Lyricist of the song.

length: Option<Duration>

Length of the song.

file_author: Option<String>

Author of the LRC file (not the song).

tool: Option<LRCTool>

Info on the player or editor that created the LRC file.

comments: Vec<String>

Comments found in the lyrics.

lines: Vec<LineTag>

LRC segments grouped by lines.

Implementations

impl SyncedLyrics

pub fn line( &mut self, line: LineTag, ) -> Result<&mut SyncedLyrics, TimestampError>

Adds a line to the lyrics.

Prefer using this method over manually adding lines to lyrics as it ensures that the timestamp order stays correct. If you need to add lines manually, use the check_timestamp_order method to verify the timestamp order.

pub fn lines( &mut self, lines: &[LineTag], ) -> Result<&mut SyncedLyrics, TimestampError>

Adds multiple lines to the lyrics.

Prefer using this method over manually adding lines to lyrics as it ensures that the timestamp order stays correct. If you need to add lines manually, use the check_timestamp_order method to verify the timestamp order.

pub fn try_new(tags: Vec<LineTag>) -> Result<SyncedLyrics, TimestampError>

Creates an empty synced lyrics struct with some timed tags.

Returns an error if the timestamp order is not correct.

pub fn serialize(self) -> String

Serialize the struct to LRC format.

NOTE: This method may not always produce the same output as the input parsed to create the data structure. For instance, the original placement of ID tags and comments is not preserved, and the offset tag is omitted as it is applied by the parser.

It should, however, always produce the same result for input serialized from its output.

For instance:

let input = include_str!("../assets/example.lrc");
let parsed = SyncedLyrics::parse(&input).unwrap();
let parsed_twice = SyncedLyrics::parse(&parsed.clone().serialize())
    .unwrap()
    .serialize();
assert_eq!(parsed.serialize(), parsed_twice);

pub fn parse(input: &str) -> Result<SyncedLyrics, Error>

Parses LRC lyrics data.

Examples

Parse some lyrics

let content = "[ti:My awesome song]
[00:02.50] La la la
[00:05.10] <00:05.10> La la la <00:06.30> la la la";
let lyrics = SyncedLyrics::parse(content).unwrap();

Parser fails to parse content with invalid ID tags

let content = "[fun:I am an invalid ID tag]";
assert_eq!(
    SyncedLyrics::parse(content),
    Err(Error::UnknownKey { key: "fun".to_string() })
);

Parser fails to parse content with invalid timestamp order

let content = "[00:02.10] First line
[00:01.90] My timestamp is wrong!";
assert_eq!(
    SyncedLyrics::parse(content),
    Err(Error::Timestamp(lrc_rs::TimestampError {
        line: Some(1),
        segment: None,
        expected: lrc_rs::TimestampConstraint::GreaterThan(Duration::from_secs_f32(2.10)),
        actual: Duration::from_secs_f32(1.9),
    }))
);

Trait Implementations

impl Clone for SyncedLyrics

fn clone(&self) -> SyncedLyrics

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyncedLyrics

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

Formats the value using the given formatter.

impl Default for SyncedLyrics

fn default() -> SyncedLyrics

Returns the “default value” for a type.

impl Eq for SyncedLyrics

impl Hash for SyncedLyrics

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LyricsAccess<LineTag> for SyncedLyrics

fn is_active(&self, timestamp: Duration) -> bool

Returns whether the lyrics are active for the given timestamp.

Lyrics are considered active if timestamp is greater than or equal to the timestamp of the first line of the lyrics. The first line is assumed to have the earliest timestamp, so if the line order is not correct this method may return wrong results.

Examples

let lyrics = SyncedLyrics::try_new(vec![
    LineTag {
        // Checking whether lyrics are active is delegated to the first line
        timestamp: Duration::from_secs(11),
        segments: vec![
            SegmentTag::new(Duration::from_secs(12), String::new()),
            SegmentTag::new(Duration::from_secs(15), String::new())
        ]
    },
    // All other stuff doesn't matter
    LineTag {
        timestamp: Duration::from_secs(17),
        segments: vec![SegmentTag::new(Duration::from_secs(17), String::new())]
    }
])
.unwrap();

assert!(!lyrics.is_active(Duration::default()));
assert!(!lyrics.is_active(Duration::from_secs(3)));
assert!(lyrics.is_active(Duration::from_secs(11)));
assert!(lyrics.is_active(Duration::from_secs(67)));
assert!(lyrics.is_active(Duration::from_secs(u64::MAX)));

fn to_unsynced(self) -> String

Returns unsynced lyrics without timestamps or additional metadata.

fn active_tag_index(&self, timestamp: Duration) -> Option<usize>

Returns the index of the active tag or None if no tag is active for the given timestamp.

fn active_tag(&self, timestamp: Duration) -> Option<&LineTag>

Returns the active tag or None if no tag is active for the given timestamp.

fn check_timestamp_order(&self) -> Result<(), TimestampError>

Checks if timed tag timestamps are ordered correctly.

fn is_enhanced_lrc(&self) -> bool

Returns whether the element contains tags indicating that it uses the enhanced LRC format.

impl Ord for SyncedLyrics

fn cmp(&self, other: &SyncedLyrics) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for SyncedLyrics

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for SyncedLyrics

fn partial_cmp(&self, other: &SyncedLyrics) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for SyncedLyrics