ocr 0.1.2

A pure Rust CLI OCR tool for printed text extraction
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

//! Dependency Injection and IoC Container
//!
//! Provides a simple dependency injection container for managing service lifetimes
//! and dependencies, supporting the Dependency Inversion Principle.

use std::sync::Arc;
use anyhow::Result;

use crate::domain::{
    text_recognition::TextRecognitionService,
    language_processing::LanguageProcessingService,
    image_processing::ImageProcessingService,
    output_formatting::OutputFormattingService,
    config::ConfigurationService,
};

/// Service container for dependency injection
pub struct ServiceContainer {
    text_recognition: Option<Arc<TextRecognitionService>>,
    language_processing: Option<Arc<LanguageProcessingService>>,
    image_processing: Option<Arc<ImageProcessingService>>,
    output_formatting: Option<Arc<OutputFormattingService>>,
    config: Option<Arc<ConfigurationService>>,
}

impl ServiceContainer {
    pub fn new() -> Self {
        Self {
            text_recognition: None,
            language_processing: None,
            image_processing: None,
            output_formatting: None,
            config: None,
        }
    }

    /// Get or create the text recognition service
    pub fn text_recognition(&mut self) -> Result<Arc<TextRecognitionService>> {
        if let Some(service) = &self.text_recognition {
            return Ok(service.clone());
        }

        let builder = crate::domain::text_recognition::TextRecognitionBuilder::new();
        
        let service = Arc::new(builder.build()?);
        self.text_recognition = Some(service.clone());
        Ok(service)
    }

    /// Get or create the language processing service
    pub fn language_processing(&mut self) -> Arc<LanguageProcessingService> {
        if let Some(service) = &self.language_processing {
            return service.clone();
        }

        let service = Arc::new(LanguageProcessingService::new());
        self.language_processing = Some(service.clone());
        service
    }

    /// Get or create the image processing service
    pub fn image_processing(&mut self) -> Arc<ImageProcessingService> {
        if let Some(service) = &self.image_processing {
            return service.clone();
        }

        let service = Arc::new(ImageProcessingService::new());
        self.image_processing = Some(service.clone());
        service
    }

    /// Get or create the output formatting service
    pub fn output_formatting(&mut self) -> Arc<OutputFormattingService> {
        if let Some(service) = &self.output_formatting {
            return service.clone();
        }

        let service = Arc::new(OutputFormattingService::new());
        self.output_formatting = Some(service.clone());
        service
    }

    /// Get or create the configuration service
    pub fn config(&mut self) -> Arc<ConfigurationService> {
        if let Some(service) = &self.config {
            return service.clone();
        }

        let service = Arc::new(ConfigurationService::new());
        self.config = Some(service.clone());
        service
    }

    /// Set a custom text recognition service
    pub fn set_text_recognition(&mut self, service: Arc<TextRecognitionService>) {
        self.text_recognition = Some(service);
    }

    /// Set a custom language processing service
    pub fn set_language_processing(&mut self, service: Arc<LanguageProcessingService>) {
        self.language_processing = Some(service);
    }

    /// Set a custom image processing service
    pub fn set_image_processing(&mut self, service: Arc<ImageProcessingService>) {
        self.image_processing = Some(service);
    }

    /// Set a custom output formatting service
    pub fn set_output_formatting(&mut self, service: Arc<OutputFormattingService>) {
        self.output_formatting = Some(service);
    }

    /// Set a custom configuration service
    pub fn set_config(&mut self, service: Arc<ConfigurationService>) {
        self.config = Some(service);
    }
}

impl Default for ServiceContainer {
    fn default() -> Self {
        Self::new()
    }
}

/// Global service container (using thread-local for single-threaded scenarios)
thread_local! {
    static GLOBAL_CONTAINER: std::cell::RefCell<ServiceContainer> = std::cell::RefCell::new(ServiceContainer::new());
}

/// Get the global service container
pub fn global_container() -> &'static std::cell::RefCell<ServiceContainer> {
    &GLOBAL_CONTAINER
}

/// Reset the global service container (useful for testing)
pub fn reset_global_container() {
    GLOBAL_CONTAINER.with(|container| {
        *container.borrow_mut() = ServiceContainer::new();
    });
}