Struct rsubs_lib::srt::SRTFile

pub struct SRTFile {
    pub lines: Vec<SRTLine>,
}

Contains a Vec<SRTLine>

The .srt format is relatively simple to parse and generally looks like :

 0
 00:00:00,000 --> 00:00:02,000
 This is my text

 1
 00:00:02,000 --> 00:00:04,000
 This is my second text

The parse function takes as input a String that represents either the parsed file or the path to it.

A simple example of working with this would be the following :

use rsubs_lib::srt::parse;

let mut a = parse("./tests/fixtures/test.srt".to_string()).unwrap();
for line in a.lines.iter_mut(){
    line.line_text.push_str(" Ipsum"); // add "Ipsum" to the end of each line.
}
// print the parsed and modified `.srt` file
println!("{}",a.clone());

// and then write it to a file
a.to_file("./tests/fixtures/doctest1.srt");

Fields

lines: Vec<SRTLine>

Implementations

impl SRTFile

pub fn to_ass(self) -> SSAFile

Convert from SRTFile to SSAFile replacing \r\n to \\N since SSA/ASS is single line

pub fn to_vtt(self) -> VTTFile

Convert from SRTFile to VTTFile, WebVTT at its core is exactly the same as Subrip

pub fn to_file(self, path: &str) -> Result<()>

Takes the path of the file in the form of a String to be written to as input.

Examples found in repository

examples/convert_around.rs (line 17)

fn main() {
    vtt::VTTFile::from(srt::SRTFile::from_str("./tests/fixtures/test.srt").unwrap()) // Can read either a file or a string
        // converts file to WEBVTT
        .to_file("./tests/fixtures/ex_test_1.vtt") // Writes the converted subtitle to a file
        .unwrap();
    ssa::SSAFile::from(vtt::parse("./tests/fixtures/test.vtt".to_string()).unwrap()) // converts file to SSA/ASS
        .to_file("./tests/fixtures/ex_test_1.ass")
        .unwrap();
    srt::SRTFile::from(ssa::parse("./tests/fixtures/test.ass".to_string()).unwrap())
        // converts file to SRT
        .to_file("./tests/fixtures/ex_test_1.srt")
        .unwrap();
}

Trait Implementations

impl Clone for SRTFile

fn clone(&self) -> SRTFile

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SRTFile

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

Formats the value using the given formatter.

impl Default for SRTFile

fn default() -> SRTFile

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SRTFile

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SRTFile

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

Consumes self and dumps the file to String.

impl From<SRTFile> for SSAFile

fn from(a: SRTFile) -> Self

Converts to this type from the input type.

impl From<SRTFile> for VTTFile

fn from(a: SRTFile) -> Self

Converts to this type from the input type.

impl From<SSAFile> for SRTFile

fn from(a: SSAFile) -> Self

Converts to this type from the input type.

impl From<Subtitle> for SRTFile

fn from(value: Subtitle) -> Self

Converts to this type from the input type.

impl From<VTTFile> for SRTFile

fn from(a: VTTFile) -> Self

Converts to this type from the input type.

impl FromStr for SRTFile

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for SRTFile

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for SRTFile

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SRTFile

impl StructuralEq for SRTFile

impl StructuralPartialEq for SRTFile