ass-editor 0.1.2

High-performance, ergonomic editor layer for ASS subtitles
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

//! Aggregated validation results.
//!
//! Defines `ValidationResult`, which collects validation issues along with
//! summary statistics and optional timing/caching metadata.

use super::{ValidationIssue, ValidationSeverity};

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

#[cfg(feature = "std")]
use std::time::Instant;

/// Validation results with caching and statistics
#[derive(Debug, Clone)]
pub struct ValidationResult {
    /// All validation issues found
    pub issues: Vec<ValidationIssue>,

    /// Time taken for validation in microseconds
    #[cfg(feature = "std")]
    pub validation_time_us: u64,

    /// Whether the document passed validation
    pub is_valid: bool,

    /// Number of warnings found
    pub warning_count: usize,

    /// Number of errors found
    pub error_count: usize,

    /// Validation timestamp for cache invalidation
    #[cfg(feature = "std")]
    pub timestamp: Instant,
}

impl ValidationResult {
    /// Create a new validation result
    pub fn new(issues: Vec<ValidationIssue>) -> Self {
        let warning_count = issues
            .iter()
            .filter(|i| i.severity == ValidationSeverity::Warning)
            .count();
        let error_count = issues.iter().filter(|i| i.is_error()).count();
        let is_valid = error_count == 0;

        Self {
            issues,
            #[cfg(feature = "std")]
            validation_time_us: 0,
            is_valid,
            warning_count,
            error_count,
            #[cfg(feature = "std")]
            timestamp: Instant::now(),
        }
    }

    /// Filter issues by severity
    pub fn issues_with_severity(&self, min_severity: ValidationSeverity) -> Vec<&ValidationIssue> {
        self.issues
            .iter()
            .filter(|i| i.severity >= min_severity)
            .collect()
    }

    /// Get summary statistics
    pub fn summary(&self) -> String {
        if self.is_valid {
            if self.warning_count > 0 {
                format!("{} warnings", self.warning_count)
            } else {
                "Valid".to_string()
            }
        } else {
            format!(
                "{} errors, {} warnings",
                self.error_count, self.warning_count
            )
        }
    }
}