windows-core 0.100.0

Core type support for COM and Windows
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(windows)]
include!("windows.rs");

use alloc::boxed::Box;

mod agile;
#[cfg_attr(not(windows), allow(dead_code))]
mod bindings;
mod can_into;
mod delegate_box;
mod ref_count;
mod sha1;
mod weak_ref_count;

pub use crate::r#type::{
    AbiType, CloneType, CopyType, InterfaceType, Type, TypeKind, ref_as_default,
};
pub use agile::*;
pub use bindings::*;
pub use can_into::*;
pub use delegate_box::*;
pub use ref_count::*;
pub use sha1::*;
pub use weak_ref_count::*;

/// Returns an opaque, process-specific encoding of a pointer suitable for use
/// as a delegate token. On Windows this calls `EncodePointer` so tokens cannot
/// be forged from raw pointer values; on non-Windows targets the raw pointer
/// value is returned as-is because there is no equivalent OS primitive and the
/// token is already opaque to callers and only meaningful within this process.
///
/// The pointer is treated as an opaque value and is never dereferenced.
#[inline]
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub fn encode_pointer(ptr: *const core::ffi::c_void) -> i64 {
    #[cfg(windows)]
    unsafe {
        EncodePointer(ptr) as i64
    }
    #[cfg(not(windows))]
    {
        ptr as i64
    }
}

#[doc(hidden)]
#[macro_export]
macro_rules! interface_hierarchy {
    ($child:ident, $parent:ty) => {
        impl ::windows_core::imp::CanInto<$parent> for $child {}
        impl ::core::convert::From<&$child> for &$parent {
            fn from(value: &$child) -> Self {
                unsafe { ::core::mem::transmute(value) }
            }
        }
        impl ::core::convert::From<$child> for $parent {
            fn from(value: $child) -> Self {
                unsafe { ::core::mem::transmute(value) }
            }
        }
    };
    ($child:ident, $first:ty, $($rest:ty),+) => {
        $crate::imp::interface_hierarchy!($child, $first);
        $crate::imp::interface_hierarchy!($child, $($rest),+);
    };
}

#[doc(hidden)]
pub use interface_hierarchy;

#[doc(hidden)]
#[macro_export]
macro_rules! required_hierarchy {
    ($child:ident, $parent:ty) => {
        impl ::windows_core::imp::CanInto<$parent> for $child { const QUERY: bool = true; }
    };
    ($child:ident, $first:ty, $($rest:ty),+) => {
        $crate::imp::required_hierarchy!($child, $first);
        $crate::imp::required_hierarchy!($child, $($rest),+);
    };
}

#[doc(hidden)]
pub use required_hierarchy;

#[doc(hidden)]
#[macro_export]
macro_rules! define_interface {
    ($name:ident, $vtbl:ident, $iid:literal) => {
        #[repr(transparent)]
        #[derive(::core::cmp::PartialEq, ::core::cmp::Eq, ::core::clone::Clone)]
        pub struct $name(::windows_core::IUnknown);
        unsafe impl ::windows_core::Interface for $name {
            type Vtable = $vtbl;
            const IID: ::windows_core::GUID = ::windows_core::GUID::from_u128($iid);
        }
        impl ::core::fmt::Debug for $name {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> core::fmt::Result {
                f.debug_tuple(stringify!($name))
                    .field(&::windows_core::Interface::as_raw(self))
                    .finish()
            }
        }
    };
    ($name:ident, $vtbl:ident) => {
        #[repr(transparent)]
        #[derive(::core::cmp::PartialEq, ::core::cmp::Eq, ::core::clone::Clone)]
        pub struct $name(::core::ptr::NonNull<::core::ffi::c_void>);
        unsafe impl ::windows_core::Interface for $name {
            type Vtable = $vtbl;
            const IID: ::windows_core::GUID = ::windows_core::GUID::zeroed();
            const UNKNOWN: bool = false;
        }
        impl ::core::fmt::Debug for $name {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> core::fmt::Result {
                f.debug_tuple(stringify!($name)).field(&self.0).finish()
            }
        }
    };
}

#[doc(hidden)]
pub use define_interface;

// These helpers let generated code use `windows_core::imp::box_new` etc. without
// depending on `Box` being in scope at the call site.

#[inline(always)]
#[doc(hidden)]
pub fn box_new<T>(value: T) -> Box<T> {
    Box::new(value)
}

#[inline(always)]
#[doc(hidden)]
pub unsafe fn box_from_raw<T>(raw: *mut T) -> Box<T> {
    unsafe { Box::from_raw(raw) }
}

#[inline(always)]
#[doc(hidden)]
pub fn box_into_raw<T>(b: Box<T>) -> *mut T {
    Box::into_raw(b)
}