winsafe 0.0.27

Windows API and GUI in safe, idiomatic Rust.
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

use crate::advapi::ffi;
use crate::co;
use crate::decl::*;
use crate::kernel::privs::*;

pub(in crate::advapi) struct HkeyKeyIter<'a> {
	hkey: &'a HKEY,
	double_idx: DoubleIterIndex,
	name_buffer: WString,
}

impl<'a> Iterator for HkeyKeyIter<'a> {
	type Item = SysResult<String>;

	fn next(&mut self) -> Option<Self::Item> {
		self.grab(true)
	}
}
impl<'a> DoubleEndedIterator for HkeyKeyIter<'a> {
	fn next_back(&mut self) -> Option<Self::Item> {
		self.grab(false)
	}
}

impl<'a> HkeyKeyIter<'a> {
	#[must_use]
	pub(in crate::advapi) fn new(hkey: &'a HKEY) -> SysResult<Self> {
		let mut num_keys = 0u32;
		let mut max_key_name_len = 0u32;
		hkey.RegQueryInfoKey(
			None,
			Some(&mut num_keys),
			Some(&mut max_key_name_len),
			None,
			None,
			None,
			None,
			None,
			None,
		)?;

		Ok(Self {
			hkey,
			double_idx: DoubleIterIndex::new(num_keys),
			name_buffer: WString::new_alloc_buf(max_key_name_len as usize + 1),
		})
	}

	fn grab(&mut self, is_front: bool) -> Option<SysResult<String>> {
		self.double_idx.grab(is_front, |cur_idx| {
			let mut len_buffer = self.name_buffer.buf_len() as u32;
			match unsafe {
				co::ERROR::from_raw(ffi::RegEnumKeyExW(
					self.hkey.ptr(),
					cur_idx,
					self.name_buffer.as_mut_ptr(),
					&mut len_buffer,
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null_mut(),
				) as _)
			} {
				co::ERROR::SUCCESS => DoubleIter::Yield(Ok(self.name_buffer.to_string())),
				e => DoubleIter::YieldLast(Err(e)),
			}
		})
	}
}

pub(in crate::advapi) struct HkeyValueIter<'a> {
	hkey: &'a HKEY,
	double_idx: DoubleIterIndex,
	name_buffer: WString,
}

impl<'a> Iterator for HkeyValueIter<'a> {
	type Item = SysResult<(String, co::REG)>;

	fn next(&mut self) -> Option<Self::Item> {
		self.grab(true)
	}
}
impl<'a> DoubleEndedIterator for HkeyValueIter<'a> {
	fn next_back(&mut self) -> Option<Self::Item> {
		self.grab(false)
	}
}

impl<'a> HkeyValueIter<'a> {
	#[must_use]
	pub(in crate::advapi) fn new(hkey: &'a HKEY) -> SysResult<Self> {
		let mut num_vals = 0u32;
		let mut max_val_name_len = 0u32;
		hkey.RegQueryInfoKey(
			None,
			None,
			None,
			None,
			Some(&mut num_vals),
			Some(&mut max_val_name_len),
			None,
			None,
			None,
		)?;

		Ok(Self {
			hkey,
			double_idx: DoubleIterIndex::new(num_vals),
			name_buffer: WString::new_alloc_buf(max_val_name_len as usize + 1),
		})
	}

	fn grab(&mut self, is_front: bool) -> Option<SysResult<(String, co::REG)>> {
		self.double_idx.grab(is_front, |cur_idx| {
			let mut raw_data_type = 0u32;
			let mut len_buffer = self.name_buffer.buf_len() as u32;
			match unsafe {
				co::ERROR::from_raw(ffi::RegEnumValueW(
					self.hkey.ptr(),
					cur_idx,
					self.name_buffer.as_mut_ptr(),
					&mut len_buffer,
					std::ptr::null_mut(),
					&mut raw_data_type,
					std::ptr::null_mut(),
					std::ptr::null_mut(),
				) as _)
			} {
				co::ERROR::SUCCESS => {
					DoubleIter::Yield(Ok((self.name_buffer.to_string(), unsafe {
						co::REG::from_raw(raw_data_type)
					})))
				},
				e => DoubleIter::YieldLast(Err(e)),
			}
		})
	}
}