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

use crate::decl::*;
use crate::prelude::*;

pub(in crate::dshow) struct IenumfiltersIter<'a, I>
where
	I: dshow_IEnumFilters,
{
	enum_filters: &'a I,
}

impl<'a, I> Iterator for IenumfiltersIter<'a, I>
where
	I: dshow_IEnumFilters,
{
	type Item = HrResult<IBaseFilter>;

	fn next(&mut self) -> Option<Self::Item> {
		match self.enum_filters.Next() {
			Err(err) => Some(Err(err)),
			Ok(maybe_item) => maybe_item.map(|item| Ok(item)),
		}
	}
}

impl<'a, I> IenumfiltersIter<'a, I>
where
	I: dshow_IEnumFilters,
{
	#[must_use]
	pub(in crate::dshow) const fn new(enum_filters: &'a I) -> Self {
		Self { enum_filters }
	}
}

pub(in crate::dshow) struct IenummediatypesIter<'a, I>
where
	I: dshow_IEnumMediaTypes,
{
	enum_mt: &'a I,
	amt: AM_MEDIA_TYPE<'a>,
}

impl<'a, I> Iterator for IenummediatypesIter<'a, I>
where
	I: dshow_IEnumMediaTypes,
{
	type Item = HrResult<&'a AM_MEDIA_TYPE<'a>>;

	fn next(&mut self) -> Option<Self::Item> {
		match self.enum_mt.Next(&mut self.amt) {
			Err(err) => Some(Err(err)),
			Ok(success) => {
				if success {
					// Returning a reference cannot be done until GATs
					// stabilization, so we simply cheat the borrow checker.
					let ptr = &self.amt as *const AM_MEDIA_TYPE;
					Some(Ok(unsafe { &*ptr }))
				} else {
					None
				}
			},
		}
	}
}

impl<'a, I> IenummediatypesIter<'a, I>
where
	I: dshow_IEnumMediaTypes,
{
	#[must_use]
	pub(in crate::dshow) fn new(enum_mt: &'a I) -> Self {
		Self { enum_mt, amt: AM_MEDIA_TYPE::default() }
	}
}

pub(in crate::dshow) struct IenumpinsIter<'a, I>
where
	I: dshow_IEnumPins,
{
	enum_pins: &'a I,
}

impl<'a, I> Iterator for IenumpinsIter<'a, I>
where
	I: dshow_IEnumPins,
{
	type Item = HrResult<IPin>;

	fn next(&mut self) -> Option<Self::Item> {
		match self.enum_pins.Next() {
			Err(err) => Some(Err(err)),
			Ok(maybe_item) => maybe_item.map(|item| Ok(item)),
		}
	}
}

impl<'a, I> IenumpinsIter<'a, I>
where
	I: dshow_IEnumPins,
{
	#[must_use]
	pub(in crate::dshow) const fn new(enum_pins: &'a I) -> Self {
		Self { enum_pins }
	}
}