windy 0.3.1

A Windows strings library that supports AString (ANSI string) and WString (Unicode string)
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

// Copyright takubokudori.
// This source code is licensed under the MIT or Apache-2.0 license.
use crate::{
    __lib::ptr::null_mut,
    AStr, WStr,
    raw::{
        ANSI_STRING, RtlInitAnsiString, RtlInitUnicodeString, UNICODE_STRING,
    },
};
use core::ops;

/// Represents [UNICODE_STRING](https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-_unicode_string).
#[derive(Debug, Clone)]
pub struct UnicodeString<'a> {
    us: UNICODE_STRING,
    s: &'a WStr,
}

impl<'a> UnicodeString<'a> {
    /// Creates UnicodeString.
    pub fn new(s: &'a WStr) -> Self {
        let mut us = UNICODE_STRING {
            Length: 0,
            MaximumLength: 0,
            Buffer: null_mut(),
        };
        unsafe {
            RtlInitUnicodeString(&mut us, s.as_ptr());
        }
        Self { us, s }
    }

    /// Returns &[`UNICODE_STRING`].
    pub fn as_raw(&self) -> &UNICODE_STRING { &self.us }

    /// Returns *const [`UNICODE_STRING`].
    pub fn as_ptr(&self) -> *const UNICODE_STRING { &self.us as _ }

    /// Returns *mut [`UNICODE_STRING`].
    pub fn as_mut_ptr(&mut self) -> *mut UNICODE_STRING { &mut self.us as _ }
}

impl<'a> ops::Deref for UnicodeString<'a> {
    type Target = WStr;

    fn deref(&self) -> &Self::Target { self.s }
}

impl PartialEq for UnicodeString<'_> {
    fn eq(&self, other: &Self) -> bool { self.s.eq(other.s) }
}

impl Eq for UnicodeString<'_> {}

/// Represents [ANSI_STRING](https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-string).
#[derive(Debug, Clone)]
pub struct AnsiString<'a> {
    us: ANSI_STRING,
    s: &'a AStr,
}

impl<'a> AnsiString<'a> {
    /// Creates AnsiString.
    pub fn new(s: &'a AStr) -> Self {
        let mut us = ANSI_STRING {
            Length: 0,
            MaximumLength: 0,
            Buffer: null_mut(),
        };
        unsafe {
            RtlInitAnsiString(&mut us, s.as_ptr());
        }
        Self { us, s }
    }

    /// Returns &[`ANSI_STRING`].
    pub fn as_raw(&self) -> &ANSI_STRING { &self.us }

    /// Returns *const [`ANSI_STRING`].
    pub fn as_ptr(&self) -> *const ANSI_STRING { &self.us as _ }

    /// Returns *mut [`ANSI_STRING`].
    pub fn as_mut_ptr(&mut self) -> *mut ANSI_STRING { &mut self.us as _ }
}

impl<'a> ops::Deref for AnsiString<'a> {
    type Target = AStr;

    fn deref(&self) -> &Self::Target { self.s }
}

impl PartialEq for AnsiString<'_> {
    fn eq(&self, other: &Self) -> bool { self.s.eq(other.s) }
}

impl Eq for AnsiString<'_> {}