vtcode_commons/
unicode.rs

1//! Unicode monitoring and validation utilities
2
3use once_cell::sync::Lazy;
4use std::collections::HashMap;
5use std::sync::Mutex;
6use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
7use std::time::Instant;
8
9/// Global unicode monitoring statistics
10#[derive(Debug, Default)]
11pub struct UnicodeMonitor {
12    // Processing statistics
13    pub total_bytes_processed: AtomicU64,
14    pub total_unicode_bytes: AtomicU64,
15    pub total_sequences: AtomicU64,
16    pub total_errors: AtomicU64,
17
18    // Error tracking
19    pub error_types: Mutex<HashMap<String, usize>>,
20    pub last_error: Mutex<Option<String>>,
21
22    // Performance metrics
23    pub processing_time_ns: AtomicU64,
24    pub max_buffer_size: AtomicUsize,
25
26    // Session tracking
27    pub active_sessions: AtomicUsize,
28    pub total_sessions: AtomicUsize,
29    pub unicode_sessions: AtomicUsize,
30}
31
32impl UnicodeMonitor {
33    /// Create a new unicode monitor
34    pub fn new() -> Self {
35        Self {
36            total_bytes_processed: AtomicU64::new(0),
37            total_unicode_bytes: AtomicU64::new(0),
38            total_sequences: AtomicU64::new(0),
39            total_errors: AtomicU64::new(0),
40            error_types: Mutex::new(HashMap::new()),
41            last_error: Mutex::new(None),
42            processing_time_ns: AtomicU64::new(0),
43            max_buffer_size: AtomicUsize::new(0),
44            active_sessions: AtomicUsize::new(0),
45            total_sessions: AtomicUsize::new(0),
46            unicode_sessions: AtomicUsize::new(0),
47        }
48    }
49
50    /// Record unicode processing statistics
51    pub fn record_processing(&self, bytes: usize, unicode_bytes: usize, contains_unicode: bool) {
52        self.total_bytes_processed
53            .fetch_add(bytes as u64, Ordering::Relaxed);
54        self.total_unicode_bytes
55            .fetch_add(unicode_bytes as u64, Ordering::Relaxed);
56        self.total_sequences.fetch_add(1, Ordering::Relaxed);
57
58        if contains_unicode {
59            self.unicode_sessions.fetch_add(1, Ordering::Relaxed);
60        }
61    }
62
63    /// Record a unicode error
64    pub fn record_error(&self, error_type: &str, details: &str) {
65        self.total_errors.fetch_add(1, Ordering::Relaxed);
66
67        let mut errors = self.error_types.lock().unwrap();
68        *errors.entry(error_type.to_string()).or_insert(0) += 1;
69
70        let mut last = self.last_error.lock().unwrap();
71        *last = Some(format!("{}: {}", error_type, details));
72    }
73
74    /// Record processing time in nanoseconds
75    pub fn record_processing_time(&self, nanoseconds: u64) {
76        self.processing_time_ns
77            .fetch_add(nanoseconds, Ordering::Relaxed);
78    }
79
80    /// Record maximum buffer size encountered
81    pub fn record_max_buffer_size(&self, size: usize) {
82        self.max_buffer_size.fetch_max(size, Ordering::Relaxed);
83    }
84
85    /// Start a new unicode processing session
86    pub fn start_session(&self) {
87        self.active_sessions.fetch_add(1, Ordering::Relaxed);
88        self.total_sessions.fetch_add(1, Ordering::Relaxed);
89    }
90
91    /// End a unicode processing session
92    pub fn end_session(&self) {
93        self.active_sessions.fetch_sub(1, Ordering::Relaxed);
94    }
95}
96
97/// Unicode validation context for tracking processing of individual buffers
98pub struct UnicodeValidationContext {
99    pub start_time: Instant,
100    pub unicode_detected: bool,
101    pub errors: Vec<String>,
102}
103
104impl UnicodeValidationContext {
105    /// Create a new validation context
106    pub fn new(_buffer_size: usize) -> Self {
107        Self {
108            start_time: Instant::now(),
109            unicode_detected: false,
110            errors: Vec::new(),
111        }
112    }
113
114    /// Record that unicode was detected in this buffer
115    pub fn record_unicode_detected(&mut self) {
116        self.unicode_detected = true;
117    }
118
119    /// Record an error that occurred during processing
120    pub fn record_error(&mut self, error: String) {
121        self.errors.push(error);
122    }
123
124    /// Complete the validation and record statistics
125    pub fn complete(self, _processed_bytes: usize) {
126        // Implementation can be expanded to update global statistics
127    }
128}
129
130/// Global unicode monitor instance
131pub static UNICODE_MONITOR: Lazy<UnicodeMonitor> = Lazy::new(UnicodeMonitor::new);
vtcode_commons/unicode.rs

vtcode_commons/
unicode.rs
