crosswin 0.4.0

Async-friendly Windows primitives for Rust with process management, memory monitoring, and system operations.
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
142
143
144

#[cfg(feature = "win32")]
use windows::Win32::Foundation::{CloseHandle, HANDLE};

/// A raw Windows handle value
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RawHandle(pub isize);

impl RawHandle {
    /// Check if the handle is valid (not null or INVALID_HANDLE_VALUE)
    pub fn is_valid(&self) -> bool {
        self.0 != 0 && self.0 != -1
    }

    /// Get the handle as a Windows HANDLE type
    #[cfg(feature = "win32")]
    pub fn as_windows_handle(&self) -> HANDLE {
        HANDLE(self.0)
    }
}

/// A RAII wrapper for Windows handles that automatically closes on drop
#[derive(Debug)]
pub struct Handle {
    raw: RawHandle,
}

impl Handle {
    /// Create a new handle from a raw isize value
    /// 
    /// # Safety
    /// The caller must ensure that the handle is valid and owned.
    /// The handle will be closed when this wrapper is dropped.
    pub unsafe fn from_raw(raw: isize) -> Self {
        Handle {
            raw: RawHandle(raw),
        }
    }

    /// Create a handle from a Windows HANDLE
    #[cfg(feature = "win32")]
    pub unsafe fn from_windows_handle(handle: HANDLE) -> Self {
        Handle {
            raw: RawHandle(handle.0),
        }
    }

    /// Get the raw handle value
    pub fn raw(&self) -> RawHandle {
        self.raw
    }

    /// Check if the handle is valid
    pub fn is_valid(&self) -> bool {
        self.raw.is_valid()
    }

    /// Convert to a Windows HANDLE
    #[cfg(feature = "win32")]
    pub fn as_windows_handle(&self) -> HANDLE {
        self.raw.as_windows_handle()
    }

    /// Take ownership of the handle, preventing automatic closure
    /// Returns the raw handle value
    pub fn into_raw(self) -> isize {
        let raw = self.raw.0;
        std::mem::forget(self); // Prevent Drop from running
        raw
    }
}

impl Drop for Handle {
    fn drop(&mut self) {
        #[cfg(feature = "win32")]
        {
            if self.is_valid() {
                unsafe {
                    let _ = CloseHandle(self.as_windows_handle());
                }
            }
        }
    }
}

// Note: Handle is not Clone to prevent double-close bugs
// (negative trait bounds are not yet stable, so we simply don't implement Clone)

/// Type-safe wrapper for process handles
#[derive(Debug)]
pub struct ProcessHandle(Handle);

impl ProcessHandle {
    /// Create a new process handle
    /// 
    /// # Safety
    /// The caller must ensure that the handle is a valid process handle
    pub unsafe fn from_raw(raw: isize) -> Self {
        ProcessHandle(Handle::from_raw(raw))
    }

    #[cfg(feature = "win32")]
    pub unsafe fn from_windows_handle(handle: HANDLE) -> Self {
        ProcessHandle(Handle::from_windows_handle(handle))
    }

    /// Get the underlying handle
    pub fn as_handle(&self) -> &Handle {
        &self.0
    }

    /// Convert to raw handle value
    pub fn into_raw(self) -> isize {
        self.0.into_raw()
    }
}

/// Type-safe wrapper for thread handles
#[derive(Debug)]
pub struct ThreadHandle(Handle);

impl ThreadHandle {
    /// Create a new thread handle
    /// 
    /// # Safety
    /// The caller must ensure that the handle is a valid thread handle
    pub unsafe fn from_raw(raw: isize) -> Self {
        ThreadHandle(Handle::from_raw(raw))
    }

    #[cfg(feature = "win32")]
    pub unsafe fn from_windows_handle(handle: HANDLE) -> Self {
        ThreadHandle(Handle::from_windows_handle(handle))
    }

    /// Get the underlying handle
    pub fn as_handle(&self) -> &Handle {
        &self.0
    }

    /// Convert to raw handle value
    pub fn into_raw(self) -> isize {
        self.0.into_raw()
    }
}