dx-serializer 0.1.0

A token-efficient serialization format for LLM context windows with high-performance binary encoding
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

//! Platform-specific async I/O module
//!
//! This module provides a unified async I/O interface that uses the best
//! available platform-specific API:
//! - Linux: io_uring (kernel 5.1+)
//! - macOS: kqueue
//! - Windows: IOCP (I/O Completion Ports)
//! - Fallback: Standard blocking I/O
//!
//! ## Usage
//!
//! ```rust,ignore
//! use serializer::io::{create_async_io, AsyncFileIO};
//!
//! let io = create_async_io();
//! let data = io.read_sync(Path::new("config.dx"))?;
//! ```

/// Platform detection result
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Platform {
    /// Linux with io_uring support
    LinuxIoUring,
    /// macOS with kqueue
    MacOsKqueue,
    /// Windows with IOCP
    WindowsIocp,
    /// Fallback blocking I/O
    Blocking,
}

impl Platform {
    /// Detect the current platform and best available I/O backend
    #[allow(clippy::needless_return)] // Returns are clearer for platform-specific code
    pub fn detect() -> Self {
        // TODO: Implement platform-specific detection when modules are available
        // For now, always return Blocking as the fallback
        Platform::Blocking
        
        // #[cfg(target_os = "linux")]
        // {
        //     if uring::IoUringIO::is_available() {
        //         return Platform::LinuxIoUring;
        //     }
        //     return Platform::Blocking;
        // }

        // #[cfg(target_os = "macos")]
        // {
        //     return Platform::MacOsKqueue;
        // }

        // #[cfg(target_os = "windows")]
        // {
        //     return Platform::WindowsIocp;
        // }

        // #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
        // {
        //     return Platform::Blocking;
        // }
    }

    /// Get a human-readable name for the platform
    pub fn name(&self) -> &'static str {
        match self {
            Platform::LinuxIoUring => "Linux io_uring",
            Platform::MacOsKqueue => "macOS kqueue",
            Platform::WindowsIocp => "Windows IOCP",
            Platform::Blocking => "Blocking I/O",
        }
    }
}

// TODO: Implement create_async_io when AsyncFileIO trait and platform modules are available
// /// Create the best available async I/O backend for the current platform
// ///
// /// This function auto-detects the platform and returns an appropriate
// /// implementation of `AsyncFileIO`.
// ///
// /// # Returns
// ///
// /// A boxed trait object implementing `AsyncFileIO` using the best
// /// available platform-specific API.
// pub fn create_async_io() -> Box<dyn AsyncFileIO> {
//     match Platform::detect() {
//         #[cfg(target_os = "linux")]
//         Platform::LinuxIoUring => match uring::IoUringIO::new() {
//             Ok(io) => Box::new(io),
//             Err(_) => Box::new(blocking::BlockingIO),
//         },

//         #[cfg(target_os = "macos")]
//         Platform::MacOsKqueue => Box::new(kqueue::KqueueIO::new()),

//         #[cfg(target_os = "windows")]
//         Platform::WindowsIocp => match iocp::IocpIO::new() {
//             Ok(io) => Box::new(io),
//             Err(_) => Box::new(blocking::BlockingIO),
//         },

//         _ => Box::new(blocking::BlockingIO),
//     }
// }

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_platform_detection() {
        let platform = Platform::detect();
        println!("Detected platform: {}", platform.name());

        // Should always return a valid platform
        assert!(!platform.name().is_empty());
    }

    // TODO: Re-enable when create_async_io is implemented
    // #[test]
    // fn test_create_async_io() {
    //     let io = create_async_io();
    //     println!("Using I/O backend: {}", io.backend_name());

    //     // Should always return a valid backend
    //     assert!(!io.backend_name().is_empty());
    // }
}