Struct Srt 

pub struct Srt<'a> { /* private fields */ }

A collection of subtitles representing an SRT file.

Srt is the main type for working with subtitle data. You can either parse an existing SRT string with Srt::try_parse or build a new subtitle collection with Srt::new and Srt::add_subtitle.

Lifetime

The 'a lifetime allows parsed subtitles to borrow text directly from the input string (zero-copy parsing). When building subtitles programmatically with owned String data, use Srt<'static>.

Example

use skrt::{Srt, Timestamp};

let mut srt = Srt::new();

srt.add_subtitle(
    Timestamp::from_millis(0).unwrap(),
    Timestamp::from_millis(2000).unwrap(),
    "First subtitle&quot".into(),
);

srt.add_subtitle(
    Timestamp::from_millis(2500).unwrap(),
    Timestamp::from_millis(5000).unwrap(),
    "Second subtitle".into(),
);

println!("{}", srt.serialize());

Implementations

impl<'a> Srt<'a>

pub fn new() -> Srt<'a>

Constructs an empty Srt with no subtitles.

Example

use skrt::Srt;

let srt = Srt::new();
assert!(srt.subtitles().is_empty());

Examples found in repository

examples/timeshift.rs (line 4)

fn main() {
    let mut srt = Srt::new();

    srt.add_subtitle(
        Timestamp::from_millis(0).unwrap(),
        Timestamp::from_millis(1000).unwrap(),
        "First".into(),
    );

    srt.add_subtitle(
        Timestamp::from_millis(1000).unwrap(),
        Timestamp::from_millis(2000).unwrap(),
        "Second".into(),
    );

    for sub in &mut srt {
        sub.set_start(sub.start().shift_millis(300).unwrap());
        sub.set_end(sub.end().shift_millis(300).unwrap());
    }

    println!("{}", srt.serialize());
}

pub fn subtitles(&self) -> &[Subtitle<'a>]

Returns a slice of all subtitles.

Example

use skrt::Srt;

let data = "1\n00:00:00,000 --> 00:00:01,000\nHello\n\n";
let srt = Srt::try_parse(data).unwrap();

for sub in srt.subtitles() {
    println!("{}: {}", sub.start(), sub.text());
}

pub fn iter(&self) -> Iter<'_, Subtitle<'a>>

Returns an iterator over the subtitles.

Example

use skrt::Srt;

let data = "1\n00:00:00,000 --> 00:00:01,000\nHello\n\n2\n00:00:02,000 --> 00:00:03,000\nWorld\n\n";
let srt = Srt::try_parse(data).unwrap();

let texts: Vec<_> = srt.iter().map(|s| s.text()).collect();
assert_eq!(vec!["Hello", "World"], texts);

pub fn iter_mut<'b>(&'b mut self) -> IterMut<'b, Subtitle<'a>>

Returns a mutable iterator over the subtitles.

This allows in-place modification of subtitles, such as adjusting timestamps or updating text.

Example

use skrt::{Srt, Timestamp};

let data = "1\n00:00:00,000 --> 00:00:01,000\nHello\n\n";
let mut srt = Srt::try_parse(data).unwrap();

// Shift all subtitles forward by 5 seconds
for sub in srt.iter_mut() {
    sub.set_start(sub.start().shift_millis(5000).unwrap());
    sub.set_end(sub.end().shift_millis(5000).unwrap());
}

assert_eq!(5000, srt.subtitles()[0].start().to_millis());

pub fn add_subtitle( &mut self, start: Timestamp, end: Timestamp, text: Cow<'a, str>, )

Adds a new subtitle to the end of the collection.

The sequence number is automatically assigned based on the current number of subtitles (i.e., the new subtitle gets the next number in sequence).

Example

use skrt::{Srt, Timestamp};

let mut srt = Srt::new();

srt.add_subtitle(
    Timestamp::from_millis(0).unwrap(),
    Timestamp::from_millis(1000).unwrap(),
    "First".into(),
);

srt.add_subtitle(
    Timestamp::from_millis(1000).unwrap(),
    Timestamp::from_millis(2000).unwrap(),
    "Second".into(),
);

assert_eq!(2, srt.subtitles().len());

Examples found in repository

examples/timeshift.rs (lines 6-10)

fn main() {
    let mut srt = Srt::new();

    srt.add_subtitle(
        Timestamp::from_millis(0).unwrap(),
        Timestamp::from_millis(1000).unwrap(),
        "First".into(),
    );

    srt.add_subtitle(
        Timestamp::from_millis(1000).unwrap(),
        Timestamp::from_millis(2000).unwrap(),
        "Second".into(),
    );

    for sub in &mut srt {
        sub.set_start(sub.start().shift_millis(300).unwrap());
        sub.set_end(sub.end().shift_millis(300).unwrap());
    }

    println!("{}", srt.serialize());
}

pub fn try_parse(srt: &str) -> Result<Srt<'_>>

Parses an SRT-formatted string.

This performs zero-copy parsing where possible. Subtitle text is borrowed directly from the input string.

Supported Variations

• LF (\n) and CRLF (\r\n) line endings
• Optional UTF-8 BOM at the start
• Trailing whitespace after timestamp lines
• Missing final blank line

Errors

Returns an SrtError if the input is malformed. The error includes position information for debugging.

Example

use skrt::Srt;

let data = r#"1
00:00:01,000 --> 00:00:04,000
Hello!

"#;

let srt = Srt::try_parse(data).unwrap();
assert_eq!(1, srt.subtitles().len());

Examples found in repository

examples/parse.rs (line 14)

fn main() {
    let data = r#"2
00:00:01,000 --> 00:00:04,000
Hello,

1
00:00:05,000 --> 00:00:08,000
World!

"#;

    let mut srt = Srt::try_parse(data).unwrap();
    srt.resequence();

    println!("{srt:#?}");
}

pub fn resequence(&mut self)

Reassigns sequence numbers starting from 1.

This is useful after modifying the subtitle list (e.g., removing or reordering entries) to ensure sequence numbers are contiguous.

Example

use skrt::{Srt, Timestamp};

let mut srt = Srt::new();
srt.add_subtitle(
    Timestamp::from_millis(0).unwrap(),
    Timestamp::from_millis(1000).unwrap(),
    "Hello".into(),
);

// After some modifications...
srt.resequence();

assert_eq!(1, srt.subtitles()[0].seq());

Examples found in repository

examples/parse.rs (line 15)

fn main() {
    let data = r#"2
00:00:01,000 --> 00:00:04,000
Hello,

1
00:00:05,000 --> 00:00:08,000
World!

"#;

    let mut srt = Srt::try_parse(data).unwrap();
    srt.resequence();

    println!("{srt:#?}");
}

pub fn serialize(&self) -> String

Serializes the subtitles to an SRT-formatted string.

The output uses LF line endings. Each subtitle block is separated by a blank line.

Example

use skrt::{Srt, Timestamp};

let mut srt = Srt::new();
srt.add_subtitle(
    Timestamp::from_millis(1000).unwrap(),
    Timestamp::from_millis(2000).unwrap(),
    "Hello, world!".into(),
);

let output = srt.serialize();
assert!(output.contains("00:00:01,000 --> 00:00:02,000"));
assert!(output.contains("Hello, world!"));

Examples found in repository

examples/timeshift.rs (line 23)

fn main() {
    let mut srt = Srt::new();

    srt.add_subtitle(
        Timestamp::from_millis(0).unwrap(),
        Timestamp::from_millis(1000).unwrap(),
        "First".into(),
    );

    srt.add_subtitle(
        Timestamp::from_millis(1000).unwrap(),
        Timestamp::from_millis(2000).unwrap(),
        "Second".into(),
    );

    for sub in &mut srt {
        sub.set_start(sub.start().shift_millis(300).unwrap());
        sub.set_end(sub.end().shift_millis(300).unwrap());
    }

    println!("{}", srt.serialize());
}

Trait Implementations

impl<'a> Clone for Srt<'a>

fn clone(&self) -> Srt<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Srt<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Srt<'a>

fn default() -> Srt<'a>

Returns the “default value” for a type.

impl<'a, 'b> IntoIterator for &'b Srt<'a>

type Item = &'b Subtitle<'a>

The type of the elements being iterated over.

type IntoIter = Iter<'b, Subtitle<'a>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, 'b> IntoIterator for &'b mut Srt<'a>

type Item = &'b mut Subtitle<'a>

The type of the elements being iterated over.

type IntoIter = IterMut<'b, Subtitle<'a>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for Srt<'a>

Consuming iterator implementation for Srt.

This allows using Srt directly in a for loop, consuming the collection and yielding owned Subtitle values.

Example

use skrt::Srt;

let data = "1\n00:00:00,000 --> 00:00:01,000\nHello\n\n2\n00:00:02,000 --> 00:00:03,000\nWorld\n\n";
let srt = Srt::try_parse(data).unwrap();

for subtitle in srt {
    println!("{}: {}", subtitle.seq(), subtitle.text());
}

type Item = Subtitle<'a>

The type of the elements being iterated over.

type IntoIter = IntoIter<Subtitle<'a>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq for Srt<'a>

fn eq(&self, other: &Srt<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for Srt<'a>

impl<'a> StructuralPartialEq for Srt<'a>