exif_oxide/processor_registry/
mod.rs

1//! Enhanced Processor Architecture for exif-oxide
2//!
3//! This module implements the sophisticated processor dispatch system designed to handle
4//! ExifTool's 121+ ProcessBinaryData variants with trait-based architecture.
5//!
6//! ## Architecture Overview
7//!
8//! - **BinaryDataProcessor trait**: Core abstraction for all processors
9//! - **ProcessorRegistry**: Central registry with capability-based selection
10//! - **ProcessorContext**: Rich context passing with metadata
11//! - **DispatchRule trait**: Sophisticated conditional dispatch logic
12//! - **ProcessorCapability**: Assessment system (Perfect/Good/Fallback/Incompatible)
13//!
14//! ## Migration Strategy
15//!
16//! This system is built alongside the existing enum-based processor system to avoid
17//! breaking changes. The migration follows these phases:
18//!
19//! 1. **Phase 1**: Build trait system (this module)
20//! 2. **Phase 2**: Create compatibility bridge
21//! 3. **Phase 3**: Convert existing processors
22//! 4. **Phase 4**: Integration testing
23//! 5. **Phase 5**: Remove deprecated enum system
24//!
25//! ## ExifTool Reference
26//!
27//! Based on ExifTool's PROCESS_PROC dispatch system and conditional SubDirectory
28//! processing patterns found throughout Canon.pm, Nikon.pm, and other manufacturer modules.
29
30pub mod capability;
31pub mod conditions;
32pub mod context;
33pub mod dispatch;
34pub mod processors;
35pub mod registry;
36pub mod traits;
37
38// Re-export core types for convenience
39pub use capability::ProcessorCapability;
40pub use conditions::ConditionEvaluator;
41pub use context::ProcessorContext;
42pub use dispatch::DispatchRule;
43pub use processors::*;
44pub use registry::ProcessorRegistry;
45pub use traits::{
46    BinaryDataProcessor, ProcessorKey, ProcessorMetadata, ProcessorResult, SharedProcessor,
47};
48
49// Import dispatch rules for the global registry
50use dispatch::*;
51
52// Global processor registry instance
53use std::sync::LazyLock;
54
55/// Global processor registry - initialized with all available processors
56/// This provides the main entry point for processor dispatch throughout the application
57static PROCESSOR_REGISTRY: LazyLock<ProcessorRegistry> = LazyLock::new(|| {
58    let mut registry = ProcessorRegistry::new();
59
60    // Register standard processors
61    registry.register_standard_processors();
62
63    // Register Canon processors
64    registry.register_processor(
65        ProcessorKey::new("Canon".to_string(), "SerialData".to_string()),
66        CanonSerialDataProcessor,
67    );
68
69    registry.register_processor(
70        ProcessorKey::new("Canon".to_string(), "CameraSettings".to_string()),
71        CanonCameraSettingsProcessor,
72    );
73
74    registry.register_processor(
75        ProcessorKey::with_variant(
76            "Canon".to_string(),
77            "SerialData".to_string(),
78            "MkII".to_string(),
79        ),
80        CanonSerialDataMkIIProcessor,
81    );
82
83    // Register Nikon processors
84    registry.register_processor(
85        ProcessorKey::new("Nikon".to_string(), "EncryptedData".to_string()),
86        NikonEncryptedDataProcessor,
87    );
88
89    registry.register_processor(
90        ProcessorKey::new("Nikon".to_string(), "AFInfo".to_string()),
91        NikonAFInfoProcessor,
92    );
93
94    registry.register_processor(
95        ProcessorKey::new("Nikon".to_string(), "LensData".to_string()),
96        NikonLensDataProcessor,
97    );
98
99    // Add dispatch rules for sophisticated processor selection
100    registry.add_dispatch_rule(CanonDispatchRule);
101    registry.add_dispatch_rule(NikonDispatchRule);
102    registry.add_dispatch_rule(FormatDispatchRule);
103    registry.add_dispatch_rule(TableDispatchRule);
104
105    registry
106});
107
108/// Get access to the global processor registry
109/// This is the main function that ExifReader and other components use to access processors
110pub fn get_global_registry() -> &'static ProcessorRegistry {
111    &PROCESSOR_REGISTRY
112}