ass-core 0.1.2

High-performance ASS subtitle format parser and analyzer
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
135
136
137
138
139
140
141
142
143
144
145
146

//! Synthetic ASS script generator configuration and constructors.
//!
//! Defines the [`ScriptGenerator`] configuration struct and the
//! [`ComplexityLevel`] enum together with the constructors that build
//! generators for each supported benchmarking scenario.

#[cfg(not(feature = "std"))]
extern crate alloc;
#[cfg(not(feature = "std"))]
use alloc::string::{String, ToString};

/// Synthetic ASS script generator for benchmarking
pub struct ScriptGenerator {
    /// Script title for metadata
    pub title: String,
    /// Number of styles to generate
    pub styles_count: usize,
    /// Number of events to generate
    pub events_count: usize,
    /// Complexity level for generated content
    pub complexity_level: ComplexityLevel,
}

/// Script complexity levels for testing
#[derive(Debug, Clone, Copy)]
pub enum ComplexityLevel {
    /// Simple text with minimal formatting
    Simple,
    /// Moderate formatting and some animations
    Moderate,
    /// Heavy animations, complex styling, karaoke
    Complex,
    /// Extreme complexity to stress-test parser
    Extreme,
    /// Anime subtitles - heavy styling and effects
    AnimeRealistic,
    /// Movie subtitles - simple, timing-focused
    MovieRealistic,
    /// Karaoke files - complex animations and timing
    KaraokeRealistic,
    /// Sign translations - positioning and styling
    SignRealistic,
    /// Educational content - long dialogues and formatting
    EducationalRealistic,
}

impl ScriptGenerator {
    /// Create generator for simple scripts
    #[must_use]
    pub fn simple(events_count: usize) -> Self {
        Self {
            title: "Simple Benchmark Script".to_string(),
            styles_count: 1,
            events_count,
            complexity_level: ComplexityLevel::Simple,
        }
    }

    /// Create generator for moderate complexity scripts
    #[must_use]
    pub fn moderate(events_count: usize) -> Self {
        Self {
            title: "Moderate Benchmark Script".to_string(),
            styles_count: 5,
            events_count,
            complexity_level: ComplexityLevel::Moderate,
        }
    }

    /// Create generator for complex scripts
    #[must_use]
    pub fn complex(events_count: usize) -> Self {
        Self {
            title: "Complex Benchmark Script".to_string(),
            styles_count: 10,
            events_count,
            complexity_level: ComplexityLevel::Complex,
        }
    }

    /// Create generator for extreme complexity scripts
    #[must_use]
    pub fn extreme(events_count: usize) -> Self {
        Self {
            title: "Extreme Benchmark Script".to_string(),
            styles_count: 20,
            events_count,
            complexity_level: ComplexityLevel::Extreme,
        }
    }

    /// Create generator for anime-style subtitles
    #[must_use]
    pub fn anime_realistic(events_count: usize) -> Self {
        Self {
            title: "Anime Subtitles".to_string(),
            styles_count: 15,
            events_count,
            complexity_level: ComplexityLevel::AnimeRealistic,
        }
    }

    /// Create generator for movie subtitles
    #[must_use]
    pub fn movie_realistic(events_count: usize) -> Self {
        Self {
            title: "Movie Subtitles".to_string(),
            styles_count: 3,
            events_count,
            complexity_level: ComplexityLevel::MovieRealistic,
        }
    }

    /// Create generator for karaoke files
    #[must_use]
    pub fn karaoke_realistic(events_count: usize) -> Self {
        Self {
            title: "Karaoke Script".to_string(),
            styles_count: 8,
            events_count,
            complexity_level: ComplexityLevel::KaraokeRealistic,
        }
    }

    /// Create generator for sign translation subtitles
    #[must_use]
    pub fn sign_realistic(events_count: usize) -> Self {
        Self {
            title: "Sign Translation".to_string(),
            styles_count: 12,
            events_count,
            complexity_level: ComplexityLevel::SignRealistic,
        }
    }

    /// Create generator for educational content
    #[must_use]
    pub fn educational_realistic(events_count: usize) -> Self {
        Self {
            title: "Educational Content".to_string(),
            styles_count: 6,
            events_count,
            complexity_level: ComplexityLevel::EducationalRealistic,
        }
    }
}