From de0d697b189881464668f4d6ade335e9f52e040b Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Mon, 3 Jan 2022 11:10:53 -0800 Subject: [PATCH] Add bitwise operators for flag enums (#1413) --- Cargo.toml | 1 + crates/libs/bindgen/src/enums.rs | 36 ++++ crates/libs/gen/src/enum.rs | 6 +- crates/libs/reader/src/tables/type_def.rs | 4 +- .../ApplicationModel/Appointments/mod.rs | 56 ++++++ .../ApplicationModel/Calls/Background/mod.rs | 28 +++ .../src/Windows/ApplicationModel/Calls/mod.rs | 56 ++++++ .../Windows/ApplicationModel/Contacts/mod.rs | 84 +++++++++ .../DataTransfer/DragDrop/Core/mod.rs | 28 +++ .../DataTransfer/DragDrop/mod.rs | 28 +++ .../ApplicationModel/DataTransfer/mod.rs | 28 +++ .../src/Windows/ApplicationModel/Email/mod.rs | 28 +++ .../ApplicationModel/Store/Preview/mod.rs | 28 +++ .../ApplicationModel/UserDataAccounts/mod.rs | 28 +++ .../ApplicationModel/UserDataTasks/mod.rs | 28 +++ .../src/Windows/ApplicationModel/mod.rs | 28 +++ .../libs/windows/src/Windows/Data/Text/mod.rs | 28 +++ .../Devices/Bluetooth/Advertisement/mod.rs | 28 +++ .../Bluetooth/GenericAttributeProfile/mod.rs | 28 +++ .../src/Windows/Devices/Bluetooth/mod.rs | 28 +++ .../src/Windows/Devices/Display/Core/mod.rs | 168 ++++++++++++++++++ .../src/Windows/Devices/Enumeration/mod.rs | 56 ++++++ .../Devices/Geolocation/Geofencing/mod.rs | 56 ++++++ .../windows/src/Windows/Devices/Lights/mod.rs | 28 +++ .../src/Windows/Devices/PointOfService/mod.rs | 140 +++++++++++++++ .../src/Windows/Devices/SmartCards/mod.rs | 56 ++++++ .../windows/src/Windows/Devices/Usb/mod.rs | 56 ++++++ .../src/Windows/Foundation/Diagnostics/mod.rs | 28 +++ .../src/Windows/Foundation/Metadata/mod.rs | 28 +++ .../Windows/Gaming/Input/ForceFeedback/mod.rs | 28 +++ .../windows/src/Windows/Gaming/Input/mod.rs | 168 ++++++++++++++++++ .../Graphics/DirectX/Direct3D11/mod.rs | 28 +++ .../src/Windows/Graphics/Display/mod.rs | 56 ++++++ .../Graphics/Printing/OptionDetails/mod.rs | 28 +++ .../src/Windows/Management/Deployment/mod.rs | 140 +++++++++++++++ .../windows/src/Windows/Media/Audio/mod.rs | 28 +++ .../windows/src/Windows/Media/Casting/mod.rs | 28 +++ .../src/Windows/Media/MediaProperties/mod.rs | 28 +++ .../src/Windows/Media/Protection/mod.rs | 28 +++ .../Windows/Networking/Connectivity/mod.rs | 84 +++++++++ .../Networking/NetworkOperators/mod.rs | 28 +++ .../src/Windows/Networking/Proximity/mod.rs | 28 +++ .../windows/src/Windows/Networking/Vpn/mod.rs | 28 +++ .../src/Windows/Networking/XboxLive/mod.rs | 28 +++ .../windows/src/Windows/Networking/mod.rs | 28 +++ .../src/Windows/Phone/ApplicationModel/mod.rs | 28 +++ .../src/Windows/Phone/Media/Devices/mod.rs | 28 +++ .../Phone/Notification/Management/mod.rs | 56 ++++++ .../Authentication/Identity/Provider/mod.rs | 28 +++ .../Authentication/Web/Provider/mod.rs | 28 +++ .../Security/Authentication/Web/mod.rs | 28 +++ .../Security/Cryptography/Certificates/mod.rs | 56 ++++++ .../src/Windows/Security/Isolation/mod.rs | 84 +++++++++ .../src/Windows/Services/Maps/Guidance/mod.rs | 56 ++++++ .../windows/src/Windows/Services/Maps/mod.rs | 56 ++++++ .../src/Windows/Storage/AccessCache/mod.rs | 28 +++ .../src/Windows/Storage/FileProperties/mod.rs | 56 ++++++ .../src/Windows/Storage/Provider/mod.rs | 112 ++++++++++++ .../src/Windows/Storage/Streams/mod.rs | 28 +++ .../libs/windows/src/Windows/Storage/mod.rs | 84 +++++++++ .../System/Diagnostics/TraceReporting/mod.rs | 28 +++ .../windows/src/Windows/System/Profile/mod.rs | 28 +++ .../src/Windows/System/Threading/mod.rs | 28 +++ crates/libs/windows/src/Windows/System/mod.rs | 28 +++ .../src/Windows/UI/ApplicationSettings/mod.rs | 28 +++ .../Windows/UI/Composition/Diagnostics/mod.rs | 28 +++ .../UI/Composition/Interactions/mod.rs | 28 +++ .../windows/src/Windows/UI/Composition/mod.rs | 28 +++ .../libs/windows/src/Windows/UI/Core/mod.rs | 84 +++++++++ .../Windows/UI/Input/Preview/Injection/mod.rs | 168 ++++++++++++++++++ .../src/Windows/UI/Input/Spatial/mod.rs | 28 +++ .../libs/windows/src/Windows/UI/Input/mod.rs | 28 +++ .../src/Windows/UI/Notifications/mod.rs | 28 +++ .../libs/windows/src/Windows/UI/Popups/mod.rs | 28 +++ .../windows/src/Windows/UI/StartScreen/mod.rs | 28 +++ .../libs/windows/src/Windows/UI/Text/mod.rs | 168 ++++++++++++++++++ .../src/Windows/UI/ViewManagement/mod.rs | 28 +++ .../src/Windows/UI/Xaml/Controls/mod.rs | 28 +++ .../windows/src/Windows/UI/Xaml/Input/mod.rs | 28 +++ .../src/Windows/UI/Xaml/Media/Imaging/mod.rs | 28 +++ .../libs/windows/src/Windows/UI/Xaml/mod.rs | 84 +++++++++ .../Win32/AI/MachineLearning/WinML/mod.rs | 168 ++++++++++++++++++ crates/tests/enums/Cargo.toml | 11 ++ crates/tests/enums/src/lib.rs | 1 + crates/tests/enums/tests/tests.rs | 20 +++ 85 files changed, 3937 insertions(+), 6 deletions(-) create mode 100644 crates/tests/enums/Cargo.toml create mode 100644 crates/tests/enums/src/lib.rs create mode 100644 crates/tests/enums/tests/tests.rs diff --git a/Cargo.toml b/Cargo.toml index b3159cf861..e5c40d2bd3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,7 @@ members = [ "crates/tests/win32/*", "crates/tests/core", "crates/tests/debug", + "crates/tests/enums", "crates/tests/sys", ] exclude = ["crates/tests/component"] diff --git a/crates/libs/bindgen/src/enums.rs b/crates/libs/bindgen/src/enums.rs index 98068a2cec..e3cb9a2991 100644 --- a/crates/libs/bindgen/src/enums.rs +++ b/crates/libs/bindgen/src/enums.rs @@ -93,6 +93,42 @@ pub fn gen(def: &TypeDef, gen: &Gen) -> TokenStream { } } }); + + if def.has_flags() { + tokens.combine("e! { + impl ::core::ops::BitOr for #ident { + type Output = Self; + + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } + } + impl ::core::ops::BitAnd for #ident { + type Output = Self; + + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } + } + impl ::core::ops::BitOrAssign for #ident { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } + } + impl ::core::ops::BitAndAssign for #ident { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } + } + impl ::core::ops::Not for #ident { + type Output = Self; + + fn not(self) -> Self { + Self(self.0.not()) + } + } + }); + } } if def.is_winrt() { diff --git a/crates/libs/gen/src/enum.rs b/crates/libs/gen/src/enum.rs index 38654592ec..6833ac5e7a 100644 --- a/crates/libs/gen/src/enum.rs +++ b/crates/libs/gen/src/enum.rs @@ -4,13 +4,9 @@ pub fn gen_enum(def: &TypeDef, gen: &Gen, include: TypeInclude) -> TokenStream { let name = gen_type_name(def, gen); let underlying_type = def.underlying_type(); - // WinRT enums don't have the flags attribute but are paritioned merely based - // on whether they are signed. - let bitwise = matches!(underlying_type, ElementType::U32); - // Win32 enums sadly don't use unsigned values uniformly so we need to rely // on the flags attribute. - let bitwise = if bitwise || def.has_flags() { + let bitwise = if def.has_flags() { quote! { impl ::core::ops::BitOr for #name { type Output = Self; diff --git a/crates/libs/reader/src/tables/type_def.rs b/crates/libs/reader/src/tables/type_def.rs index 0ec76f8485..58064005d1 100644 --- a/crates/libs/reader/src/tables/type_def.rs +++ b/crates/libs/reader/src/tables/type_def.rs @@ -494,7 +494,9 @@ impl TypeDef { } pub fn has_flags(&self) -> bool { - self.has_attribute("FlagsAttribute") + // Win32 enums use the Flags attribute. WinRT enums don't have the Flags attribute but are paritioned merely based + // on whether they are signed. + self.has_attribute("FlagsAttribute") || self.underlying_type() == ElementType::U32 } pub fn is_exclusive(&self) -> bool { diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs index b34db774e8..973765731b 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Appointments/mod.rs @@ -1338,6 +1338,34 @@ impl ::core::fmt::Debug for AppointmentDaysOfWeek { f.debug_tuple("AppointmentDaysOfWeek").field(&self.0).finish() } } +impl ::core::ops::BitOr for AppointmentDaysOfWeek { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AppointmentDaysOfWeek { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AppointmentDaysOfWeek { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AppointmentDaysOfWeek { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AppointmentDaysOfWeek { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AppointmentDaysOfWeek { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Appointments.AppointmentDaysOfWeek;u4)"); } @@ -3627,6 +3655,34 @@ impl ::core::fmt::Debug for FindAppointmentCalendarsOptions { f.debug_tuple("FindAppointmentCalendarsOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for FindAppointmentCalendarsOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for FindAppointmentCalendarsOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for FindAppointmentCalendarsOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for FindAppointmentCalendarsOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for FindAppointmentCalendarsOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for FindAppointmentCalendarsOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Appointments.FindAppointmentCalendarsOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Calls/Background/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Calls/Background/mod.rs index f8023f84d5..e36408616b 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Calls/Background/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Calls/Background/mod.rs @@ -753,6 +753,34 @@ impl ::core::fmt::Debug for PhoneLineProperties { f.debug_tuple("PhoneLineProperties").field(&self.0).finish() } } +impl ::core::ops::BitOr for PhoneLineProperties { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PhoneLineProperties { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PhoneLineProperties { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PhoneLineProperties { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PhoneLineProperties { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PhoneLineProperties { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Calls.Background.PhoneLineProperties;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs index cc1c8796bc..42a21fc2ce 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Calls/mod.rs @@ -2917,6 +2917,34 @@ impl ::core::fmt::Debug for PhoneCallHistoryEntryQueryDesiredMedia { f.debug_tuple("PhoneCallHistoryEntryQueryDesiredMedia").field(&self.0).finish() } } +impl ::core::ops::BitOr for PhoneCallHistoryEntryQueryDesiredMedia { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PhoneCallHistoryEntryQueryDesiredMedia { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PhoneCallHistoryEntryQueryDesiredMedia { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PhoneCallHistoryEntryQueryDesiredMedia { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PhoneCallHistoryEntryQueryDesiredMedia { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PhoneCallHistoryEntryQueryDesiredMedia { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Calls.PhoneCallHistoryEntryQueryDesiredMedia;u4)"); } @@ -6143,6 +6171,34 @@ impl ::core::fmt::Debug for VoipPhoneCallMedia { f.debug_tuple("VoipPhoneCallMedia").field(&self.0).finish() } } +impl ::core::ops::BitOr for VoipPhoneCallMedia { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for VoipPhoneCallMedia { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for VoipPhoneCallMedia { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for VoipPhoneCallMedia { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for VoipPhoneCallMedia { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for VoipPhoneCallMedia { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Calls.VoipPhoneCallMedia;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs index bfeb4f2b92..c2017943d6 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Contacts/mod.rs @@ -1183,6 +1183,34 @@ impl ::core::fmt::Debug for ContactAnnotationOperations { f.debug_tuple("ContactAnnotationOperations").field(&self.0).finish() } } +impl ::core::ops::BitOr for ContactAnnotationOperations { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ContactAnnotationOperations { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ContactAnnotationOperations { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ContactAnnotationOperations { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ContactAnnotationOperations { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ContactAnnotationOperations { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Contacts.ContactAnnotationOperations;u4)"); } @@ -6304,6 +6332,34 @@ impl ::core::fmt::Debug for ContactQueryDesiredFields { f.debug_tuple("ContactQueryDesiredFields").field(&self.0).finish() } } +impl ::core::ops::BitOr for ContactQueryDesiredFields { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ContactQueryDesiredFields { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ContactQueryDesiredFields { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ContactQueryDesiredFields { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ContactQueryDesiredFields { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ContactQueryDesiredFields { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Contacts.ContactQueryDesiredFields;u4)"); } @@ -6504,6 +6560,34 @@ impl ::core::fmt::Debug for ContactQuerySearchFields { f.debug_tuple("ContactQuerySearchFields").field(&self.0).finish() } } +impl ::core::ops::BitOr for ContactQuerySearchFields { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ContactQuerySearchFields { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ContactQuerySearchFields { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ContactQuerySearchFields { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ContactQuerySearchFields { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ContactQuerySearchFields { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Contacts.ContactQuerySearchFields;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs index e47dbcf14f..6b2d1fc4ff 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/Core/mod.rs @@ -385,6 +385,34 @@ impl ::core::fmt::Debug for CoreDragUIContentMode { f.debug_tuple("CoreDragUIContentMode").field(&self.0).finish() } } +impl ::core::ops::BitOr for CoreDragUIContentMode { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CoreDragUIContentMode { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CoreDragUIContentMode { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CoreDragUIContentMode { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CoreDragUIContentMode { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CoreDragUIContentMode { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragUIContentMode;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/mod.rs index 2408223f64..126a211f2d 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/DragDrop/mod.rs @@ -33,6 +33,34 @@ impl ::core::fmt::Debug for DragDropModifiers { f.debug_tuple("DragDropModifiers").field(&self.0).finish() } } +impl ::core::ops::BitOr for DragDropModifiers { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DragDropModifiers { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DragDropModifiers { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DragDropModifiers { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DragDropModifiers { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DragDropModifiers { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.DataTransfer.DragDrop.DragDropModifiers;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs index de49338da7..9498e3cb0c 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/DataTransfer/mod.rs @@ -827,6 +827,34 @@ impl ::core::fmt::Debug for DataPackageOperation { f.debug_tuple("DataPackageOperation").field(&self.0).finish() } } +impl ::core::ops::BitOr for DataPackageOperation { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DataPackageOperation { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DataPackageOperation { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DataPackageOperation { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DataPackageOperation { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DataPackageOperation { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.DataTransfer.DataPackageOperation;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs index 8d2db0022d..786f211190 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Email/mod.rs @@ -5476,6 +5476,34 @@ impl ::core::fmt::Debug for EmailQuerySearchFields { f.debug_tuple("EmailQuerySearchFields").field(&self.0).finish() } } +impl ::core::ops::BitOr for EmailQuerySearchFields { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for EmailQuerySearchFields { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for EmailQuerySearchFields { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for EmailQuerySearchFields { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for EmailQuerySearchFields { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for EmailQuerySearchFields { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Email.EmailQuerySearchFields;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/Store/Preview/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/Store/Preview/mod.rs index 799b378ed9..5e975e376d 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/Store/Preview/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/Store/Preview/mod.rs @@ -812,6 +812,34 @@ impl ::core::fmt::Debug for StoreLogOptions { f.debug_tuple("StoreLogOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for StoreLogOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for StoreLogOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for StoreLogOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for StoreLogOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for StoreLogOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for StoreLogOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.Store.Preview.StoreLogOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs index 7fb9b2af0b..94ff661b02 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataAccounts/mod.rs @@ -572,6 +572,34 @@ impl ::core::fmt::Debug for UserDataAccountContentKinds { f.debug_tuple("UserDataAccountContentKinds").field(&self.0).finish() } } +impl ::core::ops::BitOr for UserDataAccountContentKinds { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for UserDataAccountContentKinds { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for UserDataAccountContentKinds { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for UserDataAccountContentKinds { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for UserDataAccountContentKinds { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for UserDataAccountContentKinds { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.UserDataAccounts.UserDataAccountContentKinds;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs index d54ccd8fbd..46189f0125 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/UserDataTasks/mod.rs @@ -735,6 +735,34 @@ impl ::core::fmt::Debug for UserDataTaskDaysOfWeek { f.debug_tuple("UserDataTaskDaysOfWeek").field(&self.0).finish() } } +impl ::core::ops::BitOr for UserDataTaskDaysOfWeek { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for UserDataTaskDaysOfWeek { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for UserDataTaskDaysOfWeek { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for UserDataTaskDaysOfWeek { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for UserDataTaskDaysOfWeek { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for UserDataTaskDaysOfWeek { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.UserDataTasks.UserDataTaskDaysOfWeek;u4)"); } diff --git a/crates/libs/windows/src/Windows/ApplicationModel/mod.rs b/crates/libs/windows/src/Windows/ApplicationModel/mod.rs index 81f6544b20..4b8ab5bea9 100644 --- a/crates/libs/windows/src/Windows/ApplicationModel/mod.rs +++ b/crates/libs/windows/src/Windows/ApplicationModel/mod.rs @@ -81,6 +81,34 @@ impl ::core::fmt::Debug for AddResourcePackageOptions { f.debug_tuple("AddResourcePackageOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for AddResourcePackageOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AddResourcePackageOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AddResourcePackageOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AddResourcePackageOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AddResourcePackageOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AddResourcePackageOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.ApplicationModel.AddResourcePackageOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Data/Text/mod.rs b/crates/libs/windows/src/Windows/Data/Text/mod.rs index 10b15e4df0..d102cf088c 100644 --- a/crates/libs/windows/src/Windows/Data/Text/mod.rs +++ b/crates/libs/windows/src/Windows/Data/Text/mod.rs @@ -1332,6 +1332,34 @@ impl ::core::fmt::Debug for TextPredictionOptions { f.debug_tuple("TextPredictionOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for TextPredictionOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for TextPredictionOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for TextPredictionOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for TextPredictionOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for TextPredictionOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for TextPredictionOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Data.Text.TextPredictionOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/Advertisement/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/Advertisement/mod.rs index bdb5c4d3dc..99561f6c30 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/Advertisement/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/Advertisement/mod.rs @@ -706,6 +706,34 @@ impl ::core::fmt::Debug for BluetoothLEAdvertisementFlags { f.debug_tuple("BluetoothLEAdvertisementFlags").field(&self.0).finish() } } +impl ::core::ops::BitOr for BluetoothLEAdvertisementFlags { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for BluetoothLEAdvertisementFlags { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for BluetoothLEAdvertisementFlags { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for BluetoothLEAdvertisementFlags { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for BluetoothLEAdvertisementFlags { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for BluetoothLEAdvertisementFlags { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFlags;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs index 53a3f3e57a..f3761c6645 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs @@ -333,6 +333,34 @@ impl ::core::fmt::Debug for GattCharacteristicProperties { f.debug_tuple("GattCharacteristicProperties").field(&self.0).finish() } } +impl ::core::ops::BitOr for GattCharacteristicProperties { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for GattCharacteristicProperties { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for GattCharacteristicProperties { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for GattCharacteristicProperties { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for GattCharacteristicProperties { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for GattCharacteristicProperties { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicProperties;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs b/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs index 110f6510fb..2d042d9d2e 100644 --- a/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Bluetooth/mod.rs @@ -2613,6 +2613,34 @@ impl ::core::fmt::Debug for BluetoothServiceCapabilities { f.debug_tuple("BluetoothServiceCapabilities").field(&self.0).finish() } } +impl ::core::ops::BitOr for BluetoothServiceCapabilities { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for BluetoothServiceCapabilities { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for BluetoothServiceCapabilities { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for BluetoothServiceCapabilities { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for BluetoothServiceCapabilities { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for BluetoothServiceCapabilities { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Bluetooth.BluetoothServiceCapabilities;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs b/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs index 13a34b5b82..9001c69350 100644 --- a/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Display/Core/mod.rs @@ -183,6 +183,34 @@ impl ::core::fmt::Debug for DisplayBitsPerChannel { f.debug_tuple("DisplayBitsPerChannel").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayBitsPerChannel { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayBitsPerChannel { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayBitsPerChannel { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayBitsPerChannel { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayBitsPerChannel { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayBitsPerChannel { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Display.Core.DisplayBitsPerChannel;u4)"); } @@ -1003,6 +1031,34 @@ impl ::core::fmt::Debug for DisplayManagerOptions { f.debug_tuple("DisplayManagerOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayManagerOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayManagerOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayManagerOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayManagerOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayManagerOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayManagerOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Display.Core.DisplayManagerOptions;u4)"); } @@ -1423,6 +1479,34 @@ impl ::core::fmt::Debug for DisplayModeQueryOptions { f.debug_tuple("DisplayModeQueryOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayModeQueryOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayModeQueryOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayModeQueryOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayModeQueryOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayModeQueryOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayModeQueryOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Display.Core.DisplayModeQueryOptions;u4)"); } @@ -2142,6 +2226,34 @@ impl ::core::fmt::Debug for DisplayScanoutOptions { f.debug_tuple("DisplayScanoutOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayScanoutOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayScanoutOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayScanoutOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayScanoutOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayScanoutOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayScanoutOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Display.Core.DisplayScanoutOptions;u4)"); } @@ -2520,6 +2632,34 @@ impl ::core::fmt::Debug for DisplayStateApplyOptions { f.debug_tuple("DisplayStateApplyOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayStateApplyOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayStateApplyOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayStateApplyOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayStateApplyOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayStateApplyOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayStateApplyOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Display.Core.DisplayStateApplyOptions;u4)"); } @@ -2554,6 +2694,34 @@ impl ::core::fmt::Debug for DisplayStateFunctionalizeOptions { f.debug_tuple("DisplayStateFunctionalizeOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayStateFunctionalizeOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayStateFunctionalizeOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayStateFunctionalizeOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayStateFunctionalizeOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayStateFunctionalizeOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayStateFunctionalizeOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Display.Core.DisplayStateFunctionalizeOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs b/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs index c72add9776..aea1dc46c0 100644 --- a/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Enumeration/mod.rs @@ -1380,6 +1380,34 @@ impl ::core::fmt::Debug for DevicePairingKinds { f.debug_tuple("DevicePairingKinds").field(&self.0).finish() } } +impl ::core::ops::BitOr for DevicePairingKinds { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DevicePairingKinds { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DevicePairingKinds { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DevicePairingKinds { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DevicePairingKinds { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DevicePairingKinds { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Enumeration.DevicePairingKinds;u4)"); } @@ -2078,6 +2106,34 @@ impl ::core::fmt::Debug for DevicePickerDisplayStatusOptions { f.debug_tuple("DevicePickerDisplayStatusOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DevicePickerDisplayStatusOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DevicePickerDisplayStatusOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DevicePickerDisplayStatusOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DevicePickerDisplayStatusOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DevicePickerDisplayStatusOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DevicePickerDisplayStatusOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Enumeration.DevicePickerDisplayStatusOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Geolocation/Geofencing/mod.rs b/crates/libs/windows/src/Windows/Devices/Geolocation/Geofencing/mod.rs index 6f35c0381f..0a97e80f3a 100644 --- a/crates/libs/windows/src/Windows/Devices/Geolocation/Geofencing/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Geolocation/Geofencing/mod.rs @@ -414,6 +414,34 @@ impl ::core::fmt::Debug for GeofenceState { f.debug_tuple("GeofenceState").field(&self.0).finish() } } +impl ::core::ops::BitOr for GeofenceState { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for GeofenceState { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for GeofenceState { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for GeofenceState { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for GeofenceState { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for GeofenceState { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Geolocation.Geofencing.GeofenceState;u4)"); } @@ -674,6 +702,34 @@ impl ::core::fmt::Debug for MonitoredGeofenceStates { f.debug_tuple("MonitoredGeofenceStates").field(&self.0).finish() } } +impl ::core::ops::BitOr for MonitoredGeofenceStates { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MonitoredGeofenceStates { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MonitoredGeofenceStates { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MonitoredGeofenceStates { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MonitoredGeofenceStates { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for MonitoredGeofenceStates { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Geolocation.Geofencing.MonitoredGeofenceStates;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Lights/mod.rs b/crates/libs/windows/src/Windows/Devices/Lights/mod.rs index 70fecb1042..b6540fc1ee 100644 --- a/crates/libs/windows/src/Windows/Devices/Lights/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Lights/mod.rs @@ -981,6 +981,34 @@ impl ::core::fmt::Debug for LampPurposes { f.debug_tuple("LampPurposes").field(&self.0).finish() } } +impl ::core::ops::BitOr for LampPurposes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for LampPurposes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for LampPurposes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for LampPurposes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for LampPurposes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for LampPurposes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Lights.LampPurposes;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs b/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs index 57f0b3acd8..156c150e9c 100644 --- a/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/PointOfService/mod.rs @@ -13146,6 +13146,34 @@ impl ::core::fmt::Debug for PosConnectionTypes { f.debug_tuple("PosConnectionTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for PosConnectionTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PosConnectionTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PosConnectionTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PosConnectionTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PosConnectionTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PosConnectionTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.PointOfService.PosConnectionTypes;u4)"); } @@ -13649,6 +13677,34 @@ impl ::core::fmt::Debug for PosPrinterCartridgeSensors { f.debug_tuple("PosPrinterCartridgeSensors").field(&self.0).finish() } } +impl ::core::ops::BitOr for PosPrinterCartridgeSensors { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PosPrinterCartridgeSensors { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PosPrinterCartridgeSensors { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PosPrinterCartridgeSensors { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PosPrinterCartridgeSensors { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PosPrinterCartridgeSensors { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.PointOfService.PosPrinterCartridgeSensors;u4)"); } @@ -13725,6 +13781,34 @@ impl ::core::fmt::Debug for PosPrinterColorCapabilities { f.debug_tuple("PosPrinterColorCapabilities").field(&self.0).finish() } } +impl ::core::ops::BitOr for PosPrinterColorCapabilities { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PosPrinterColorCapabilities { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PosPrinterColorCapabilities { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PosPrinterColorCapabilities { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PosPrinterColorCapabilities { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PosPrinterColorCapabilities { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.PointOfService.PosPrinterColorCapabilities;u4)"); } @@ -14004,6 +14088,34 @@ impl ::core::fmt::Debug for PosPrinterMarkFeedCapabilities { f.debug_tuple("PosPrinterMarkFeedCapabilities").field(&self.0).finish() } } +impl ::core::ops::BitOr for PosPrinterMarkFeedCapabilities { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PosPrinterMarkFeedCapabilities { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PosPrinterMarkFeedCapabilities { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PosPrinterMarkFeedCapabilities { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PosPrinterMarkFeedCapabilities { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PosPrinterMarkFeedCapabilities { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.PointOfService.PosPrinterMarkFeedCapabilities;u4)"); } @@ -14463,6 +14575,34 @@ impl ::core::fmt::Debug for PosPrinterRuledLineCapabilities { f.debug_tuple("PosPrinterRuledLineCapabilities").field(&self.0).finish() } } +impl ::core::ops::BitOr for PosPrinterRuledLineCapabilities { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PosPrinterRuledLineCapabilities { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PosPrinterRuledLineCapabilities { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PosPrinterRuledLineCapabilities { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PosPrinterRuledLineCapabilities { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PosPrinterRuledLineCapabilities { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.PointOfService.PosPrinterRuledLineCapabilities;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs b/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs index 25c1fbcc09..d2352c23ec 100644 --- a/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/SmartCards/mod.rs @@ -3556,6 +3556,34 @@ impl ::core::fmt::Debug for SmartCardCryptogramPlacementOptions { f.debug_tuple("SmartCardCryptogramPlacementOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for SmartCardCryptogramPlacementOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for SmartCardCryptogramPlacementOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for SmartCardCryptogramPlacementOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for SmartCardCryptogramPlacementOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for SmartCardCryptogramPlacementOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for SmartCardCryptogramPlacementOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.SmartCards.SmartCardCryptogramPlacementOptions;u4)"); } @@ -3822,6 +3850,34 @@ impl ::core::fmt::Debug for SmartCardCryptogramStorageKeyCapabilities { f.debug_tuple("SmartCardCryptogramStorageKeyCapabilities").field(&self.0).finish() } } +impl ::core::ops::BitOr for SmartCardCryptogramStorageKeyCapabilities { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for SmartCardCryptogramStorageKeyCapabilities { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for SmartCardCryptogramStorageKeyCapabilities { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for SmartCardCryptogramStorageKeyCapabilities { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for SmartCardCryptogramStorageKeyCapabilities { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for SmartCardCryptogramStorageKeyCapabilities { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyCapabilities;u4)"); } diff --git a/crates/libs/windows/src/Windows/Devices/Usb/mod.rs b/crates/libs/windows/src/Windows/Devices/Usb/mod.rs index 6f7bccd3a9..c3d747372c 100644 --- a/crates/libs/windows/src/Windows/Devices/Usb/mod.rs +++ b/crates/libs/windows/src/Windows/Devices/Usb/mod.rs @@ -3319,6 +3319,34 @@ impl ::core::fmt::Debug for UsbReadOptions { f.debug_tuple("UsbReadOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for UsbReadOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for UsbReadOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for UsbReadOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for UsbReadOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for UsbReadOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for UsbReadOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Usb.UsbReadOptions;u4)"); } @@ -3544,6 +3572,34 @@ impl ::core::fmt::Debug for UsbWriteOptions { f.debug_tuple("UsbWriteOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for UsbWriteOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for UsbWriteOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for UsbWriteOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for UsbWriteOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for UsbWriteOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for UsbWriteOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Devices.Usb.UsbWriteOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs b/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs index f6d6ecfc90..fc421fc25d 100644 --- a/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs +++ b/crates/libs/windows/src/Windows/Foundation/Diagnostics/mod.rs @@ -319,6 +319,34 @@ impl ::core::fmt::Debug for ErrorOptions { f.debug_tuple("ErrorOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for ErrorOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ErrorOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ErrorOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ErrorOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ErrorOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ErrorOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Foundation.Diagnostics.ErrorOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Foundation/Metadata/mod.rs b/crates/libs/windows/src/Windows/Foundation/Metadata/mod.rs index 98a992e841..b3fafdba3f 100644 --- a/crates/libs/windows/src/Windows/Foundation/Metadata/mod.rs +++ b/crates/libs/windows/src/Windows/Foundation/Metadata/mod.rs @@ -119,6 +119,34 @@ impl ::core::fmt::Debug for AttributeTargets { f.debug_tuple("AttributeTargets").field(&self.0).finish() } } +impl ::core::ops::BitOr for AttributeTargets { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AttributeTargets { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AttributeTargets { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AttributeTargets { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AttributeTargets { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AttributeTargets { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Foundation.Metadata.AttributeTargets;u4)"); } diff --git a/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs b/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs index 8aea0d26ce..56a8c80efd 100644 --- a/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Input/ForceFeedback/mod.rs @@ -360,6 +360,34 @@ impl ::core::fmt::Debug for ForceFeedbackEffectAxes { f.debug_tuple("ForceFeedbackEffectAxes").field(&self.0).finish() } } +impl ::core::ops::BitOr for ForceFeedbackEffectAxes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ForceFeedbackEffectAxes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ForceFeedbackEffectAxes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ForceFeedbackEffectAxes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ForceFeedbackEffectAxes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ForceFeedbackEffectAxes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Gaming.Input.ForceFeedback.ForceFeedbackEffectAxes;u4)"); } diff --git a/crates/libs/windows/src/Windows/Gaming/Input/mod.rs b/crates/libs/windows/src/Windows/Gaming/Input/mod.rs index 4d69dc90d7..ec0decd3ee 100644 --- a/crates/libs/windows/src/Windows/Gaming/Input/mod.rs +++ b/crates/libs/windows/src/Windows/Gaming/Input/mod.rs @@ -306,6 +306,34 @@ impl ::core::fmt::Debug for ArcadeStickButtons { f.debug_tuple("ArcadeStickButtons").field(&self.0).finish() } } +impl ::core::ops::BitOr for ArcadeStickButtons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ArcadeStickButtons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ArcadeStickButtons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ArcadeStickButtons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ArcadeStickButtons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ArcadeStickButtons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Gaming.Input.ArcadeStickButtons;u4)"); } @@ -643,6 +671,34 @@ impl ::core::fmt::Debug for FlightStickButtons { f.debug_tuple("FlightStickButtons").field(&self.0).finish() } } +impl ::core::ops::BitOr for FlightStickButtons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for FlightStickButtons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for FlightStickButtons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for FlightStickButtons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for FlightStickButtons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for FlightStickButtons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Gaming.Input.FlightStickButtons;u4)"); } @@ -1185,6 +1241,34 @@ impl ::core::fmt::Debug for GamepadButtons { f.debug_tuple("GamepadButtons").field(&self.0).finish() } } +impl ::core::ops::BitOr for GamepadButtons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for GamepadButtons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for GamepadButtons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for GamepadButtons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for GamepadButtons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for GamepadButtons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Gaming.Input.GamepadButtons;u4)"); } @@ -2110,6 +2194,34 @@ impl ::core::fmt::Debug for OptionalUINavigationButtons { f.debug_tuple("OptionalUINavigationButtons").field(&self.0).finish() } } +impl ::core::ops::BitOr for OptionalUINavigationButtons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for OptionalUINavigationButtons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for OptionalUINavigationButtons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for OptionalUINavigationButtons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for OptionalUINavigationButtons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for OptionalUINavigationButtons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Gaming.Input.OptionalUINavigationButtons;u4)"); } @@ -2476,6 +2588,34 @@ impl ::core::fmt::Debug for RacingWheelButtons { f.debug_tuple("RacingWheelButtons").field(&self.0).finish() } } +impl ::core::ops::BitOr for RacingWheelButtons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for RacingWheelButtons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for RacingWheelButtons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for RacingWheelButtons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for RacingWheelButtons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for RacingWheelButtons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Gaming.Input.RacingWheelButtons;u4)"); } @@ -2899,6 +3039,34 @@ impl ::core::fmt::Debug for RequiredUINavigationButtons { f.debug_tuple("RequiredUINavigationButtons").field(&self.0).finish() } } +impl ::core::ops::BitOr for RequiredUINavigationButtons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for RequiredUINavigationButtons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for RequiredUINavigationButtons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for RequiredUINavigationButtons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for RequiredUINavigationButtons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for RequiredUINavigationButtons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Gaming.Input.RequiredUINavigationButtons;u4)"); } diff --git a/crates/libs/windows/src/Windows/Graphics/DirectX/Direct3D11/mod.rs b/crates/libs/windows/src/Windows/Graphics/DirectX/Direct3D11/mod.rs index 11a30de7ec..1f87aedfcb 100644 --- a/crates/libs/windows/src/Windows/Graphics/DirectX/Direct3D11/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/DirectX/Direct3D11/mod.rs @@ -34,6 +34,34 @@ impl ::core::fmt::Debug for Direct3DBindings { f.debug_tuple("Direct3DBindings").field(&self.0).finish() } } +impl ::core::ops::BitOr for Direct3DBindings { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for Direct3DBindings { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for Direct3DBindings { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for Direct3DBindings { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for Direct3DBindings { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for Direct3DBindings { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Graphics.DirectX.Direct3D11.Direct3DBindings;u4)"); } diff --git a/crates/libs/windows/src/Windows/Graphics/Display/mod.rs b/crates/libs/windows/src/Windows/Graphics/Display/mod.rs index ff891de987..3768a1c925 100644 --- a/crates/libs/windows/src/Windows/Graphics/Display/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Display/mod.rs @@ -632,6 +632,34 @@ impl ::core::fmt::Debug for DisplayBrightnessOverrideOptions { f.debug_tuple("DisplayBrightnessOverrideOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayBrightnessOverrideOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayBrightnessOverrideOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayBrightnessOverrideOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayBrightnessOverrideOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayBrightnessOverrideOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayBrightnessOverrideOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Graphics.Display.DisplayBrightnessOverrideOptions;u4)"); } @@ -1428,6 +1456,34 @@ impl ::core::fmt::Debug for DisplayOrientations { f.debug_tuple("DisplayOrientations").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisplayOrientations { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisplayOrientations { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisplayOrientations { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisplayOrientations { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisplayOrientations { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisplayOrientations { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Graphics.Display.DisplayOrientations;u4)"); } diff --git a/crates/libs/windows/src/Windows/Graphics/Printing/OptionDetails/mod.rs b/crates/libs/windows/src/Windows/Graphics/Printing/OptionDetails/mod.rs index f68288d535..c4dbe0f2e6 100644 --- a/crates/libs/windows/src/Windows/Graphics/Printing/OptionDetails/mod.rs +++ b/crates/libs/windows/src/Windows/Graphics/Printing/OptionDetails/mod.rs @@ -4039,6 +4039,34 @@ impl ::core::fmt::Debug for PrintOptionStates { f.debug_tuple("PrintOptionStates").field(&self.0).finish() } } +impl ::core::ops::BitOr for PrintOptionStates { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PrintOptionStates { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PrintOptionStates { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PrintOptionStates { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PrintOptionStates { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PrintOptionStates { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Graphics.Printing.OptionDetails.PrintOptionStates;u4)"); } diff --git a/crates/libs/windows/src/Windows/Management/Deployment/mod.rs b/crates/libs/windows/src/Windows/Management/Deployment/mod.rs index f6067f8e55..0e47f5c519 100644 --- a/crates/libs/windows/src/Windows/Management/Deployment/mod.rs +++ b/crates/libs/windows/src/Windows/Management/Deployment/mod.rs @@ -31,6 +31,34 @@ impl ::core::fmt::Debug for AddPackageByAppInstallerOptions { f.debug_tuple("AddPackageByAppInstallerOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for AddPackageByAppInstallerOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AddPackageByAppInstallerOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AddPackageByAppInstallerOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AddPackageByAppInstallerOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AddPackageByAppInstallerOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AddPackageByAppInstallerOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Management.Deployment.AddPackageByAppInstallerOptions;u4)"); } @@ -1123,6 +1151,34 @@ impl ::core::fmt::Debug for DeploymentOptions { f.debug_tuple("DeploymentOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for DeploymentOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DeploymentOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DeploymentOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DeploymentOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DeploymentOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DeploymentOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Management.Deployment.DeploymentOptions;u4)"); } @@ -3314,6 +3370,34 @@ impl ::core::fmt::Debug for PackageStatus { f.debug_tuple("PackageStatus").field(&self.0).finish() } } +impl ::core::ops::BitOr for PackageStatus { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PackageStatus { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PackageStatus { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PackageStatus { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PackageStatus { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PackageStatus { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Management.Deployment.PackageStatus;u4)"); } @@ -3386,6 +3470,34 @@ impl ::core::fmt::Debug for PackageTypes { f.debug_tuple("PackageTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for PackageTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PackageTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PackageTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PackageTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PackageTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PackageTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Management.Deployment.PackageTypes;u4)"); } @@ -4012,6 +4124,34 @@ impl ::core::fmt::Debug for RemovalOptions { f.debug_tuple("RemovalOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for RemovalOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for RemovalOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for RemovalOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for RemovalOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for RemovalOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for RemovalOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Management.Deployment.RemovalOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Media/Audio/mod.rs b/crates/libs/windows/src/Windows/Media/Audio/mod.rs index d163d8abef..e97ce019cd 100644 --- a/crates/libs/windows/src/Windows/Media/Audio/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Audio/mod.rs @@ -3363,6 +3363,34 @@ impl ::core::fmt::Debug for AudioNodeEmitterSettings { f.debug_tuple("AudioNodeEmitterSettings").field(&self.0).finish() } } +impl ::core::ops::BitOr for AudioNodeEmitterSettings { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AudioNodeEmitterSettings { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AudioNodeEmitterSettings { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AudioNodeEmitterSettings { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AudioNodeEmitterSettings { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AudioNodeEmitterSettings { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Media.Audio.AudioNodeEmitterSettings;u4)"); } diff --git a/crates/libs/windows/src/Windows/Media/Casting/mod.rs b/crates/libs/windows/src/Windows/Media/Casting/mod.rs index d42d6ca17d..f071bd3190 100644 --- a/crates/libs/windows/src/Windows/Media/Casting/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Casting/mod.rs @@ -870,6 +870,34 @@ impl ::core::fmt::Debug for CastingPlaybackTypes { f.debug_tuple("CastingPlaybackTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for CastingPlaybackTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CastingPlaybackTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CastingPlaybackTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CastingPlaybackTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CastingPlaybackTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CastingPlaybackTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Media.Casting.CastingPlaybackTypes;u4)"); } diff --git a/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs b/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs index e0a50f5f48..aded14343b 100644 --- a/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs +++ b/crates/libs/windows/src/Windows/Media/MediaProperties/mod.rs @@ -2344,6 +2344,34 @@ impl ::core::fmt::Debug for MediaMirroringOptions { f.debug_tuple("MediaMirroringOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for MediaMirroringOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MediaMirroringOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MediaMirroringOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MediaMirroringOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MediaMirroringOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for MediaMirroringOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Media.MediaProperties.MediaMirroringOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Media/Protection/mod.rs b/crates/libs/windows/src/Windows/Media/Protection/mod.rs index 0e972d8f9c..0971364835 100644 --- a/crates/libs/windows/src/Windows/Media/Protection/mod.rs +++ b/crates/libs/windows/src/Windows/Media/Protection/mod.rs @@ -1563,6 +1563,34 @@ impl ::core::fmt::Debug for RevocationAndRenewalReasons { f.debug_tuple("RevocationAndRenewalReasons").field(&self.0).finish() } } +impl ::core::ops::BitOr for RevocationAndRenewalReasons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for RevocationAndRenewalReasons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for RevocationAndRenewalReasons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for RevocationAndRenewalReasons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for RevocationAndRenewalReasons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for RevocationAndRenewalReasons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Media.Protection.RevocationAndRenewalReasons;u4)"); } diff --git a/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs b/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs index cd93248d73..a41bf8c1b3 100644 --- a/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Connectivity/mod.rs @@ -3443,6 +3443,34 @@ impl ::core::fmt::Debug for NetworkTypes { f.debug_tuple("NetworkTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for NetworkTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for NetworkTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for NetworkTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for NetworkTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for NetworkTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for NetworkTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.Connectivity.NetworkTypes;u4)"); } @@ -3799,6 +3827,34 @@ impl ::core::fmt::Debug for RoamingStates { f.debug_tuple("RoamingStates").field(&self.0).finish() } } +impl ::core::ops::BitOr for RoamingStates { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for RoamingStates { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for RoamingStates { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for RoamingStates { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for RoamingStates { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for RoamingStates { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.Connectivity.RoamingStates;u4)"); } @@ -4191,6 +4247,34 @@ impl ::core::fmt::Debug for WwanDataClass { f.debug_tuple("WwanDataClass").field(&self.0).finish() } } +impl ::core::ops::BitOr for WwanDataClass { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for WwanDataClass { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for WwanDataClass { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for WwanDataClass { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for WwanDataClass { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for WwanDataClass { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.Connectivity.WwanDataClass;u4)"); } diff --git a/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs b/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs index af2753c428..c0cfd3cc63 100644 --- a/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/NetworkOperators/mod.rs @@ -41,6 +41,34 @@ impl ::core::fmt::Debug for DataClasses { f.debug_tuple("DataClasses").field(&self.0).finish() } } +impl ::core::ops::BitOr for DataClasses { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DataClasses { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DataClasses { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DataClasses { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DataClasses { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DataClasses { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.NetworkOperators.DataClasses;u4)"); } diff --git a/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs b/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs index 1e7f7fd12b..2b01bfce3d 100644 --- a/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Proximity/mod.rs @@ -694,6 +694,34 @@ impl ::core::fmt::Debug for PeerDiscoveryTypes { f.debug_tuple("PeerDiscoveryTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for PeerDiscoveryTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PeerDiscoveryTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PeerDiscoveryTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PeerDiscoveryTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PeerDiscoveryTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PeerDiscoveryTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.Proximity.PeerDiscoveryTypes;u4)"); } diff --git a/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs b/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs index e570b4aaeb..c29ddfd3d2 100644 --- a/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/Vpn/mod.rs @@ -3070,6 +3070,34 @@ impl ::core::fmt::Debug for VpnChannelRequestCredentialsOptions { f.debug_tuple("VpnChannelRequestCredentialsOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for VpnChannelRequestCredentialsOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for VpnChannelRequestCredentialsOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for VpnChannelRequestCredentialsOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for VpnChannelRequestCredentialsOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for VpnChannelRequestCredentialsOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for VpnChannelRequestCredentialsOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.Vpn.VpnChannelRequestCredentialsOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs b/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs index a6b18fe97a..e7894b9c9b 100644 --- a/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/XboxLive/mod.rs @@ -721,6 +721,34 @@ impl ::core::fmt::Debug for XboxLiveEndpointPairCreationBehaviors { f.debug_tuple("XboxLiveEndpointPairCreationBehaviors").field(&self.0).finish() } } +impl ::core::ops::BitOr for XboxLiveEndpointPairCreationBehaviors { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for XboxLiveEndpointPairCreationBehaviors { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for XboxLiveEndpointPairCreationBehaviors { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for XboxLiveEndpointPairCreationBehaviors { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for XboxLiveEndpointPairCreationBehaviors { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for XboxLiveEndpointPairCreationBehaviors { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.XboxLive.XboxLiveEndpointPairCreationBehaviors;u4)"); } diff --git a/crates/libs/windows/src/Windows/Networking/mod.rs b/crates/libs/windows/src/Windows/Networking/mod.rs index 6bca5fa0b3..af64becb89 100644 --- a/crates/libs/windows/src/Windows/Networking/mod.rs +++ b/crates/libs/windows/src/Windows/Networking/mod.rs @@ -395,6 +395,34 @@ impl ::core::fmt::Debug for HostNameSortOptions { f.debug_tuple("HostNameSortOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for HostNameSortOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for HostNameSortOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for HostNameSortOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for HostNameSortOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for HostNameSortOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for HostNameSortOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Networking.HostNameSortOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Phone/ApplicationModel/mod.rs b/crates/libs/windows/src/Windows/Phone/ApplicationModel/mod.rs index 44f4fcdb56..93953d1d49 100644 --- a/crates/libs/windows/src/Windows/Phone/ApplicationModel/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/ApplicationModel/mod.rs @@ -45,6 +45,34 @@ impl ::core::fmt::Debug for ApplicationProfileModes { f.debug_tuple("ApplicationProfileModes").field(&self.0).finish() } } +impl ::core::ops::BitOr for ApplicationProfileModes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ApplicationProfileModes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ApplicationProfileModes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ApplicationProfileModes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ApplicationProfileModes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ApplicationProfileModes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Phone.ApplicationModel.ApplicationProfileModes;u4)"); } diff --git a/crates/libs/windows/src/Windows/Phone/Media/Devices/mod.rs b/crates/libs/windows/src/Windows/Phone/Media/Devices/mod.rs index 86067008b0..a5ed9b3bab 100644 --- a/crates/libs/windows/src/Windows/Phone/Media/Devices/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/Media/Devices/mod.rs @@ -188,6 +188,34 @@ impl ::core::fmt::Debug for AvailableAudioRoutingEndpoints { f.debug_tuple("AvailableAudioRoutingEndpoints").field(&self.0).finish() } } +impl ::core::ops::BitOr for AvailableAudioRoutingEndpoints { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AvailableAudioRoutingEndpoints { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AvailableAudioRoutingEndpoints { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AvailableAudioRoutingEndpoints { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AvailableAudioRoutingEndpoints { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AvailableAudioRoutingEndpoints { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Phone.Media.Devices.AvailableAudioRoutingEndpoints;u4)"); } diff --git a/crates/libs/windows/src/Windows/Phone/Notification/Management/mod.rs b/crates/libs/windows/src/Windows/Phone/Notification/Management/mod.rs index b53ab334b8..e3aef0851e 100644 --- a/crates/libs/windows/src/Windows/Phone/Notification/Management/mod.rs +++ b/crates/libs/windows/src/Windows/Phone/Notification/Management/mod.rs @@ -389,6 +389,34 @@ impl ::core::fmt::Debug for AccessoryNotificationType { f.debug_tuple("AccessoryNotificationType").field(&self.0).finish() } } +impl ::core::ops::BitOr for AccessoryNotificationType { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AccessoryNotificationType { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AccessoryNotificationType { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AccessoryNotificationType { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AccessoryNotificationType { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AccessoryNotificationType { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Phone.Notification.Management.AccessoryNotificationType;u4)"); } @@ -3485,6 +3513,34 @@ impl ::core::fmt::Debug for PlaybackCapability { f.debug_tuple("PlaybackCapability").field(&self.0).finish() } } +impl ::core::ops::BitOr for PlaybackCapability { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PlaybackCapability { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PlaybackCapability { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PlaybackCapability { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PlaybackCapability { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PlaybackCapability { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Phone.Notification.Management.PlaybackCapability;u4)"); } diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Identity/Provider/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Identity/Provider/mod.rs index 58010e7d8e..c3d1299007 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Identity/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Identity/Provider/mod.rs @@ -1060,6 +1060,34 @@ impl ::core::fmt::Debug for SecondaryAuthenticationFactorDeviceCapabilities { f.debug_tuple("SecondaryAuthenticationFactorDeviceCapabilities").field(&self.0).finish() } } +impl ::core::ops::BitOr for SecondaryAuthenticationFactorDeviceCapabilities { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for SecondaryAuthenticationFactorDeviceCapabilities { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for SecondaryAuthenticationFactorDeviceCapabilities { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for SecondaryAuthenticationFactorDeviceCapabilities { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for SecondaryAuthenticationFactorDeviceCapabilities { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} #[cfg(feature = "deprecated")] unsafe impl ::windows::core::RuntimeType for SecondaryAuthenticationFactorDeviceCapabilities { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorDeviceCapabilities;u4)"); diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs index 3ca6b33b9f..32c761de21 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/Provider/mod.rs @@ -2938,6 +2938,34 @@ impl ::core::fmt::Debug for WebAccountSelectionOptions { f.debug_tuple("WebAccountSelectionOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for WebAccountSelectionOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for WebAccountSelectionOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for WebAccountSelectionOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for WebAccountSelectionOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for WebAccountSelectionOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for WebAccountSelectionOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Authentication.Web.Provider.WebAccountSelectionOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs b/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs index 8a3ba82d0b..99640315fa 100644 --- a/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Authentication/Web/mod.rs @@ -209,6 +209,34 @@ impl ::core::fmt::Debug for WebAuthenticationOptions { f.debug_tuple("WebAuthenticationOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for WebAuthenticationOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for WebAuthenticationOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for WebAuthenticationOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for WebAuthenticationOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for WebAuthenticationOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for WebAuthenticationOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Authentication.Web.WebAuthenticationOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs b/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs index eb7da6acb2..059479c0a9 100644 --- a/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Cryptography/Certificates/mod.rs @@ -2269,6 +2269,34 @@ impl ::core::fmt::Debug for EnrollKeyUsages { f.debug_tuple("EnrollKeyUsages").field(&self.0).finish() } } +impl ::core::ops::BitOr for EnrollKeyUsages { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for EnrollKeyUsages { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for EnrollKeyUsages { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for EnrollKeyUsages { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for EnrollKeyUsages { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for EnrollKeyUsages { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Cryptography.Certificates.EnrollKeyUsages;u4)"); } @@ -3330,6 +3358,34 @@ impl ::core::fmt::Debug for InstallOptions { f.debug_tuple("InstallOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for InstallOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InstallOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InstallOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InstallOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InstallOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InstallOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Cryptography.Certificates.InstallOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Security/Isolation/mod.rs b/crates/libs/windows/src/Windows/Security/Isolation/mod.rs index 36af69be29..a8c02c5269 100644 --- a/crates/libs/windows/src/Windows/Security/Isolation/mod.rs +++ b/crates/libs/windows/src/Windows/Security/Isolation/mod.rs @@ -935,6 +935,34 @@ impl ::core::fmt::Debug for IsolatedWindowsEnvironmentAllowedClipboardFormats { f.debug_tuple("IsolatedWindowsEnvironmentAllowedClipboardFormats").field(&self.0).finish() } } +impl ::core::ops::BitOr for IsolatedWindowsEnvironmentAllowedClipboardFormats { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for IsolatedWindowsEnvironmentAllowedClipboardFormats { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for IsolatedWindowsEnvironmentAllowedClipboardFormats { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for IsolatedWindowsEnvironmentAllowedClipboardFormats { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for IsolatedWindowsEnvironmentAllowedClipboardFormats { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for IsolatedWindowsEnvironmentAllowedClipboardFormats { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Isolation.IsolatedWindowsEnvironmentAllowedClipboardFormats;u4)"); } @@ -971,6 +999,34 @@ impl ::core::fmt::Debug for IsolatedWindowsEnvironmentAvailablePrinters { f.debug_tuple("IsolatedWindowsEnvironmentAvailablePrinters").field(&self.0).finish() } } +impl ::core::ops::BitOr for IsolatedWindowsEnvironmentAvailablePrinters { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for IsolatedWindowsEnvironmentAvailablePrinters { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for IsolatedWindowsEnvironmentAvailablePrinters { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for IsolatedWindowsEnvironmentAvailablePrinters { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for IsolatedWindowsEnvironmentAvailablePrinters { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for IsolatedWindowsEnvironmentAvailablePrinters { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Isolation.IsolatedWindowsEnvironmentAvailablePrinters;u4)"); } @@ -1005,6 +1061,34 @@ impl ::core::fmt::Debug for IsolatedWindowsEnvironmentClipboardCopyPasteDirectio f.debug_tuple("IsolatedWindowsEnvironmentClipboardCopyPasteDirections").field(&self.0).finish() } } +impl ::core::ops::BitOr for IsolatedWindowsEnvironmentClipboardCopyPasteDirections { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for IsolatedWindowsEnvironmentClipboardCopyPasteDirections { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for IsolatedWindowsEnvironmentClipboardCopyPasteDirections { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for IsolatedWindowsEnvironmentClipboardCopyPasteDirections { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for IsolatedWindowsEnvironmentClipboardCopyPasteDirections { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for IsolatedWindowsEnvironmentClipboardCopyPasteDirections { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Security.Isolation.IsolatedWindowsEnvironmentClipboardCopyPasteDirections;u4)"); } diff --git a/crates/libs/windows/src/Windows/Services/Maps/Guidance/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/Guidance/mod.rs index dd996c36e2..d35e30c492 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/Guidance/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/Guidance/mod.rs @@ -200,6 +200,34 @@ impl ::core::fmt::Debug for GuidanceAudioNotifications { f.debug_tuple("GuidanceAudioNotifications").field(&self.0).finish() } } +impl ::core::ops::BitOr for GuidanceAudioNotifications { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for GuidanceAudioNotifications { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for GuidanceAudioNotifications { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for GuidanceAudioNotifications { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for GuidanceAudioNotifications { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for GuidanceAudioNotifications { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Services.Maps.Guidance.GuidanceAudioNotifications;u4)"); } @@ -331,6 +359,34 @@ impl ::core::fmt::Debug for GuidanceLaneMarkers { f.debug_tuple("GuidanceLaneMarkers").field(&self.0).finish() } } +impl ::core::ops::BitOr for GuidanceLaneMarkers { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for GuidanceLaneMarkers { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for GuidanceLaneMarkers { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for GuidanceLaneMarkers { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for GuidanceLaneMarkers { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for GuidanceLaneMarkers { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Services.Maps.Guidance.GuidanceLaneMarkers;u4)"); } diff --git a/crates/libs/windows/src/Windows/Services/Maps/mod.rs b/crates/libs/windows/src/Windows/Services/Maps/mod.rs index fe133299ac..20cf53871f 100644 --- a/crates/libs/windows/src/Windows/Services/Maps/mod.rs +++ b/crates/libs/windows/src/Windows/Services/Maps/mod.rs @@ -1598,6 +1598,34 @@ impl ::core::fmt::Debug for MapManeuverNotices { f.debug_tuple("MapManeuverNotices").field(&self.0).finish() } } +impl ::core::ops::BitOr for MapManeuverNotices { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MapManeuverNotices { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MapManeuverNotices { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MapManeuverNotices { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MapManeuverNotices { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for MapManeuverNotices { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Services.Maps.MapManeuverNotices;u4)"); } @@ -2596,6 +2624,34 @@ impl ::core::fmt::Debug for MapRouteRestrictions { f.debug_tuple("MapRouteRestrictions").field(&self.0).finish() } } +impl ::core::ops::BitOr for MapRouteRestrictions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MapRouteRestrictions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MapRouteRestrictions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MapRouteRestrictions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MapRouteRestrictions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for MapRouteRestrictions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Services.Maps.MapRouteRestrictions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs b/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs index c8307bde54..b0ff5dc4f0 100644 --- a/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/AccessCache/mod.rs @@ -29,6 +29,34 @@ impl ::core::fmt::Debug for AccessCacheOptions { f.debug_tuple("AccessCacheOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for AccessCacheOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for AccessCacheOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for AccessCacheOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for AccessCacheOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for AccessCacheOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for AccessCacheOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.AccessCache.AccessCacheOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs b/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs index 879f32d582..1b46f33967 100644 --- a/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/FileProperties/mod.rs @@ -1322,6 +1322,34 @@ impl ::core::fmt::Debug for PropertyPrefetchOptions { f.debug_tuple("PropertyPrefetchOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for PropertyPrefetchOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PropertyPrefetchOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PropertyPrefetchOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PropertyPrefetchOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PropertyPrefetchOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PropertyPrefetchOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.FileProperties.PropertyPrefetchOptions;u4)"); } @@ -1943,6 +1971,34 @@ impl ::core::fmt::Debug for ThumbnailOptions { f.debug_tuple("ThumbnailOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for ThumbnailOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ThumbnailOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ThumbnailOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ThumbnailOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ThumbnailOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ThumbnailOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.FileProperties.ThumbnailOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Storage/Provider/mod.rs b/crates/libs/windows/src/Windows/Storage/Provider/mod.rs index e51cb4e0d2..93a9e4aa34 100644 --- a/crates/libs/windows/src/Windows/Storage/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Provider/mod.rs @@ -28,6 +28,34 @@ impl ::core::fmt::Debug for CachedFileOptions { f.debug_tuple("CachedFileOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for CachedFileOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CachedFileOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CachedFileOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CachedFileOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CachedFileOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CachedFileOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.Provider.CachedFileOptions;u4)"); } @@ -2202,6 +2230,34 @@ impl ::core::fmt::Debug for StorageProviderHardlinkPolicy { f.debug_tuple("StorageProviderHardlinkPolicy").field(&self.0).finish() } } +impl ::core::ops::BitOr for StorageProviderHardlinkPolicy { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for StorageProviderHardlinkPolicy { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for StorageProviderHardlinkPolicy { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for StorageProviderHardlinkPolicy { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for StorageProviderHardlinkPolicy { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for StorageProviderHardlinkPolicy { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.Provider.StorageProviderHardlinkPolicy;u4)"); } @@ -2273,6 +2329,34 @@ impl ::core::fmt::Debug for StorageProviderHydrationPolicyModifier { f.debug_tuple("StorageProviderHydrationPolicyModifier").field(&self.0).finish() } } +impl ::core::ops::BitOr for StorageProviderHydrationPolicyModifier { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for StorageProviderHydrationPolicyModifier { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for StorageProviderHydrationPolicyModifier { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for StorageProviderHydrationPolicyModifier { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for StorageProviderHydrationPolicyModifier { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for StorageProviderHydrationPolicyModifier { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.Provider.StorageProviderHydrationPolicyModifier;u4)"); } @@ -2316,6 +2400,34 @@ impl ::core::fmt::Debug for StorageProviderInSyncPolicy { f.debug_tuple("StorageProviderInSyncPolicy").field(&self.0).finish() } } +impl ::core::ops::BitOr for StorageProviderInSyncPolicy { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for StorageProviderInSyncPolicy { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for StorageProviderInSyncPolicy { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for StorageProviderInSyncPolicy { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for StorageProviderInSyncPolicy { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for StorageProviderInSyncPolicy { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.Provider.StorageProviderInSyncPolicy;u4)"); } diff --git a/crates/libs/windows/src/Windows/Storage/Streams/mod.rs b/crates/libs/windows/src/Windows/Storage/Streams/mod.rs index 1898b0384e..a6b786e27d 100644 --- a/crates/libs/windows/src/Windows/Storage/Streams/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/Streams/mod.rs @@ -4291,6 +4291,34 @@ impl ::core::fmt::Debug for InputStreamOptions { f.debug_tuple("InputStreamOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for InputStreamOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InputStreamOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InputStreamOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InputStreamOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InputStreamOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InputStreamOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.Streams.InputStreamOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/Storage/mod.rs b/crates/libs/windows/src/Windows/Storage/mod.rs index dc3dc8f0c9..8093096c2a 100644 --- a/crates/libs/windows/src/Windows/Storage/mod.rs +++ b/crates/libs/windows/src/Windows/Storage/mod.rs @@ -1539,6 +1539,34 @@ impl ::core::fmt::Debug for FileAttributes { f.debug_tuple("FileAttributes").field(&self.0).finish() } } +impl ::core::ops::BitOr for FileAttributes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for FileAttributes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for FileAttributes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for FileAttributes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for FileAttributes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for FileAttributes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.FileAttributes;u4)"); } @@ -6979,6 +7007,34 @@ impl ::core::fmt::Debug for StorageItemTypes { f.debug_tuple("StorageItemTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for StorageItemTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for StorageItemTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for StorageItemTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for StorageItemTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for StorageItemTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for StorageItemTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.StorageItemTypes;u4)"); } @@ -7710,6 +7766,34 @@ impl ::core::fmt::Debug for StorageOpenOptions { f.debug_tuple("StorageOpenOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for StorageOpenOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for StorageOpenOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for StorageOpenOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for StorageOpenOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for StorageOpenOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for StorageOpenOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.Storage.StorageOpenOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/System/Diagnostics/TraceReporting/mod.rs b/crates/libs/windows/src/Windows/System/Diagnostics/TraceReporting/mod.rs index 1c50dc8844..fb286a20eb 100644 --- a/crates/libs/windows/src/Windows/System/Diagnostics/TraceReporting/mod.rs +++ b/crates/libs/windows/src/Windows/System/Diagnostics/TraceReporting/mod.rs @@ -235,6 +235,34 @@ impl ::core::fmt::Debug for PlatformDiagnosticEventBufferLatencies { f.debug_tuple("PlatformDiagnosticEventBufferLatencies").field(&self.0).finish() } } +impl ::core::ops::BitOr for PlatformDiagnosticEventBufferLatencies { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PlatformDiagnosticEventBufferLatencies { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PlatformDiagnosticEventBufferLatencies { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PlatformDiagnosticEventBufferLatencies { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PlatformDiagnosticEventBufferLatencies { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PlatformDiagnosticEventBufferLatencies { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.System.Diagnostics.TraceReporting.PlatformDiagnosticEventBufferLatencies;u4)"); } diff --git a/crates/libs/windows/src/Windows/System/Profile/mod.rs b/crates/libs/windows/src/Windows/System/Profile/mod.rs index b7e0117523..f75ea39bc0 100644 --- a/crates/libs/windows/src/Windows/System/Profile/mod.rs +++ b/crates/libs/windows/src/Windows/System/Profile/mod.rs @@ -1304,6 +1304,34 @@ impl ::core::fmt::Debug for UnsupportedAppRequirementReasons { f.debug_tuple("UnsupportedAppRequirementReasons").field(&self.0).finish() } } +impl ::core::ops::BitOr for UnsupportedAppRequirementReasons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for UnsupportedAppRequirementReasons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for UnsupportedAppRequirementReasons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for UnsupportedAppRequirementReasons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for UnsupportedAppRequirementReasons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for UnsupportedAppRequirementReasons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.System.Profile.UnsupportedAppRequirementReasons;u4)"); } diff --git a/crates/libs/windows/src/Windows/System/Threading/mod.rs b/crates/libs/windows/src/Windows/System/Threading/mod.rs index 70b35cd1ee..598507e902 100644 --- a/crates/libs/windows/src/Windows/System/Threading/mod.rs +++ b/crates/libs/windows/src/Windows/System/Threading/mod.rs @@ -510,6 +510,34 @@ impl ::core::fmt::Debug for WorkItemOptions { f.debug_tuple("WorkItemOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for WorkItemOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for WorkItemOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for WorkItemOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for WorkItemOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for WorkItemOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for WorkItemOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.System.Threading.WorkItemOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/System/mod.rs b/crates/libs/windows/src/Windows/System/mod.rs index 74c19134c9..46b22a973e 100644 --- a/crates/libs/windows/src/Windows/System/mod.rs +++ b/crates/libs/windows/src/Windows/System/mod.rs @@ -8030,6 +8030,34 @@ impl ::core::fmt::Debug for VirtualKeyModifiers { f.debug_tuple("VirtualKeyModifiers").field(&self.0).finish() } } +impl ::core::ops::BitOr for VirtualKeyModifiers { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for VirtualKeyModifiers { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for VirtualKeyModifiers { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for VirtualKeyModifiers { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for VirtualKeyModifiers { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for VirtualKeyModifiers { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.System.VirtualKeyModifiers;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs b/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs index c9615cfbc1..cc0b005daa 100644 --- a/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ApplicationSettings/mod.rs @@ -1540,6 +1540,34 @@ impl ::core::fmt::Debug for SupportedWebAccountActions { f.debug_tuple("SupportedWebAccountActions").field(&self.0).finish() } } +impl ::core::ops::BitOr for SupportedWebAccountActions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for SupportedWebAccountActions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for SupportedWebAccountActions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for SupportedWebAccountActions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for SupportedWebAccountActions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for SupportedWebAccountActions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.ApplicationSettings.SupportedWebAccountActions;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Composition/Diagnostics/mod.rs b/crates/libs/windows/src/Windows/UI/Composition/Diagnostics/mod.rs index c6b462eb79..c92e0caf06 100644 --- a/crates/libs/windows/src/Windows/UI/Composition/Diagnostics/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Composition/Diagnostics/mod.rs @@ -126,6 +126,34 @@ impl ::core::fmt::Debug for CompositionDebugOverdrawContentKinds { f.debug_tuple("CompositionDebugOverdrawContentKinds").field(&self.0).finish() } } +impl ::core::ops::BitOr for CompositionDebugOverdrawContentKinds { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CompositionDebugOverdrawContentKinds { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CompositionDebugOverdrawContentKinds { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CompositionDebugOverdrawContentKinds { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CompositionDebugOverdrawContentKinds { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CompositionDebugOverdrawContentKinds { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Composition.Diagnostics.CompositionDebugOverdrawContentKinds;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Composition/Interactions/mod.rs b/crates/libs/windows/src/Windows/UI/Composition/Interactions/mod.rs index 8246b7820c..2716ff4b47 100644 --- a/crates/libs/windows/src/Windows/UI/Composition/Interactions/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Composition/Interactions/mod.rs @@ -1663,6 +1663,34 @@ impl ::core::fmt::Debug for InteractionBindingAxisModes { f.debug_tuple("InteractionBindingAxisModes").field(&self.0).finish() } } +impl ::core::ops::BitOr for InteractionBindingAxisModes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InteractionBindingAxisModes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InteractionBindingAxisModes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InteractionBindingAxisModes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InteractionBindingAxisModes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InteractionBindingAxisModes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Composition.Interactions.InteractionBindingAxisModes;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Composition/mod.rs b/crates/libs/windows/src/Windows/UI/Composition/mod.rs index c463a7de5f..e3ad4f52b1 100644 --- a/crates/libs/windows/src/Windows/UI/Composition/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Composition/mod.rs @@ -5812,6 +5812,34 @@ impl ::core::fmt::Debug for CompositionBatchTypes { f.debug_tuple("CompositionBatchTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for CompositionBatchTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CompositionBatchTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CompositionBatchTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CompositionBatchTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CompositionBatchTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CompositionBatchTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Composition.CompositionBatchTypes;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Core/mod.rs b/crates/libs/windows/src/Windows/UI/Core/mod.rs index 9a1b422751..ed0569ca29 100644 --- a/crates/libs/windows/src/Windows/UI/Core/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Core/mod.rs @@ -1625,6 +1625,34 @@ impl ::core::fmt::Debug for CoreIndependentInputFilters { f.debug_tuple("CoreIndependentInputFilters").field(&self.0).finish() } } +impl ::core::ops::BitOr for CoreIndependentInputFilters { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CoreIndependentInputFilters { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CoreIndependentInputFilters { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CoreIndependentInputFilters { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CoreIndependentInputFilters { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CoreIndependentInputFilters { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Core.CoreIndependentInputFilters;u4)"); } @@ -2226,6 +2254,34 @@ impl ::core::fmt::Debug for CoreInputDeviceTypes { f.debug_tuple("CoreInputDeviceTypes").field(&self.0).finish() } } +impl ::core::ops::BitOr for CoreInputDeviceTypes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CoreInputDeviceTypes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CoreInputDeviceTypes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CoreInputDeviceTypes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CoreInputDeviceTypes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CoreInputDeviceTypes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Core.CoreInputDeviceTypes;u4)"); } @@ -2416,6 +2472,34 @@ impl ::core::fmt::Debug for CoreVirtualKeyStates { f.debug_tuple("CoreVirtualKeyStates").field(&self.0).finish() } } +impl ::core::ops::BitOr for CoreVirtualKeyStates { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for CoreVirtualKeyStates { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for CoreVirtualKeyStates { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for CoreVirtualKeyStates { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for CoreVirtualKeyStates { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for CoreVirtualKeyStates { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Core.CoreVirtualKeyStates;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Input/Preview/Injection/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Preview/Injection/mod.rs index 504ba0f934..865b9c35f1 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Preview/Injection/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Preview/Injection/mod.rs @@ -500,6 +500,34 @@ impl ::core::fmt::Debug for InjectedInputKeyOptions { f.debug_tuple("InjectedInputKeyOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for InjectedInputKeyOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InjectedInputKeyOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InjectedInputKeyOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InjectedInputKeyOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InjectedInputKeyOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InjectedInputKeyOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.Preview.Injection.InjectedInputKeyOptions;u4)"); } @@ -806,6 +834,34 @@ impl ::core::fmt::Debug for InjectedInputMouseOptions { f.debug_tuple("InjectedInputMouseOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for InjectedInputMouseOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InjectedInputMouseOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InjectedInputMouseOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InjectedInputMouseOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InjectedInputMouseOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InjectedInputMouseOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.Preview.Injection.InjectedInputMouseOptions;u4)"); } @@ -841,6 +897,34 @@ impl ::core::fmt::Debug for InjectedInputPenButtons { f.debug_tuple("InjectedInputPenButtons").field(&self.0).finish() } } +impl ::core::ops::BitOr for InjectedInputPenButtons { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InjectedInputPenButtons { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InjectedInputPenButtons { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InjectedInputPenButtons { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InjectedInputPenButtons { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InjectedInputPenButtons { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.Preview.Injection.InjectedInputPenButtons;u4)"); } @@ -1046,6 +1130,34 @@ impl ::core::fmt::Debug for InjectedInputPenParameters { f.debug_tuple("InjectedInputPenParameters").field(&self.0).finish() } } +impl ::core::ops::BitOr for InjectedInputPenParameters { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InjectedInputPenParameters { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InjectedInputPenParameters { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InjectedInputPenParameters { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InjectedInputPenParameters { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InjectedInputPenParameters { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.Preview.Injection.InjectedInputPenParameters;u4)"); } @@ -1167,6 +1279,34 @@ impl ::core::fmt::Debug for InjectedInputPointerOptions { f.debug_tuple("InjectedInputPointerOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for InjectedInputPointerOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InjectedInputPointerOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InjectedInputPointerOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InjectedInputPointerOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InjectedInputPointerOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InjectedInputPointerOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.Preview.Injection.InjectedInputPointerOptions;u4)"); } @@ -1418,6 +1558,34 @@ impl ::core::fmt::Debug for InjectedInputTouchParameters { f.debug_tuple("InjectedInputTouchParameters").field(&self.0).finish() } } +impl ::core::ops::BitOr for InjectedInputTouchParameters { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for InjectedInputTouchParameters { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for InjectedInputTouchParameters { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for InjectedInputTouchParameters { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for InjectedInputTouchParameters { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for InjectedInputTouchParameters { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.Preview.Injection.InjectedInputTouchParameters;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs b/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs index cd413948f3..69fb9d33dc 100644 --- a/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/Spatial/mod.rs @@ -1353,6 +1353,34 @@ impl ::core::fmt::Debug for SpatialGestureSettings { f.debug_tuple("SpatialGestureSettings").field(&self.0).finish() } } +impl ::core::ops::BitOr for SpatialGestureSettings { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for SpatialGestureSettings { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for SpatialGestureSettings { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for SpatialGestureSettings { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for SpatialGestureSettings { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for SpatialGestureSettings { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.Spatial.SpatialGestureSettings;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Input/mod.rs b/crates/libs/windows/src/Windows/UI/Input/mod.rs index 3026624726..7b8f9e5907 100644 --- a/crates/libs/windows/src/Windows/UI/Input/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Input/mod.rs @@ -1331,6 +1331,34 @@ impl ::core::fmt::Debug for GestureSettings { f.debug_tuple("GestureSettings").field(&self.0).finish() } } +impl ::core::ops::BitOr for GestureSettings { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for GestureSettings { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for GestureSettings { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for GestureSettings { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for GestureSettings { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for GestureSettings { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Input.GestureSettings;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Notifications/mod.rs b/crates/libs/windows/src/Windows/UI/Notifications/mod.rs index dd78f0313e..d15c648d90 100644 --- a/crates/libs/windows/src/Windows/UI/Notifications/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Notifications/mod.rs @@ -2676,6 +2676,34 @@ impl ::core::fmt::Debug for NotificationKinds { f.debug_tuple("NotificationKinds").field(&self.0).finish() } } +impl ::core::ops::BitOr for NotificationKinds { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for NotificationKinds { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for NotificationKinds { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for NotificationKinds { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for NotificationKinds { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for NotificationKinds { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Notifications.NotificationKinds;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Popups/mod.rs b/crates/libs/windows/src/Windows/UI/Popups/mod.rs index 7048cd5205..f3384a319c 100644 --- a/crates/libs/windows/src/Windows/UI/Popups/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Popups/mod.rs @@ -417,6 +417,34 @@ impl ::core::fmt::Debug for MessageDialogOptions { f.debug_tuple("MessageDialogOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for MessageDialogOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MessageDialogOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MessageDialogOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MessageDialogOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MessageDialogOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for MessageDialogOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Popups.MessageDialogOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs b/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs index dc2c4d0c4b..03b9fbbf75 100644 --- a/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs +++ b/crates/libs/windows/src/Windows/UI/StartScreen/mod.rs @@ -1962,6 +1962,34 @@ impl ::core::fmt::Debug for TileOptions { f.debug_tuple("TileOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for TileOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for TileOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for TileOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for TileOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for TileOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for TileOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.StartScreen.TileOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Text/mod.rs b/crates/libs/windows/src/Windows/UI/Text/mod.rs index a294644703..f1e81f8ea5 100644 --- a/crates/libs/windows/src/Windows/UI/Text/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Text/mod.rs @@ -209,6 +209,34 @@ impl ::core::fmt::Debug for FindOptions { f.debug_tuple("FindOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for FindOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for FindOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for FindOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for FindOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for FindOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for FindOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Text.FindOptions;u4)"); } @@ -3264,6 +3292,34 @@ impl ::core::fmt::Debug for PointOptions { f.debug_tuple("PointOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for PointOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for PointOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for PointOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for PointOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for PointOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for PointOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Text.PointOptions;u4)"); } @@ -4139,6 +4195,34 @@ impl ::core::fmt::Debug for SelectionOptions { f.debug_tuple("SelectionOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for SelectionOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for SelectionOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for SelectionOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for SelectionOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for SelectionOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for SelectionOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Text.SelectionOptions;u4)"); } @@ -4350,6 +4434,34 @@ impl ::core::fmt::Debug for TextDecorations { f.debug_tuple("TextDecorations").field(&self.0).finish() } } +impl ::core::ops::BitOr for TextDecorations { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for TextDecorations { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for TextDecorations { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for TextDecorations { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for TextDecorations { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for TextDecorations { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Text.TextDecorations;u4)"); } @@ -4390,6 +4502,34 @@ impl ::core::fmt::Debug for TextGetOptions { f.debug_tuple("TextGetOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for TextGetOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for TextGetOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for TextGetOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for TextGetOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for TextGetOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for TextGetOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Text.TextGetOptions;u4)"); } @@ -4587,6 +4727,34 @@ impl ::core::fmt::Debug for TextSetOptions { f.debug_tuple("TextSetOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for TextSetOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for TextSetOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for TextSetOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for TextSetOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for TextSetOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for TextSetOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Text.TextSetOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs b/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs index 77a4a9e237..228346aec2 100644 --- a/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs +++ b/crates/libs/windows/src/Windows/UI/ViewManagement/mod.rs @@ -1140,6 +1140,34 @@ impl ::core::fmt::Debug for ApplicationViewSwitchingOptions { f.debug_tuple("ApplicationViewSwitchingOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for ApplicationViewSwitchingOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ApplicationViewSwitchingOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ApplicationViewSwitchingOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ApplicationViewSwitchingOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ApplicationViewSwitchingOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ApplicationViewSwitchingOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.ViewManagement.ApplicationViewSwitchingOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Xaml/Controls/mod.rs b/crates/libs/windows/src/Windows/UI/Xaml/Controls/mod.rs index 23ca6519db..f7fdb93395 100644 --- a/crates/libs/windows/src/Windows/UI/Xaml/Controls/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Xaml/Controls/mod.rs @@ -18180,6 +18180,34 @@ impl ::core::fmt::Debug for DisabledFormattingAccelerators { f.debug_tuple("DisabledFormattingAccelerators").field(&self.0).finish() } } +impl ::core::ops::BitOr for DisabledFormattingAccelerators { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for DisabledFormattingAccelerators { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for DisabledFormattingAccelerators { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for DisabledFormattingAccelerators { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for DisabledFormattingAccelerators { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for DisabledFormattingAccelerators { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Xaml.Controls.DisabledFormattingAccelerators;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Xaml/Input/mod.rs b/crates/libs/windows/src/Windows/UI/Xaml/Input/mod.rs index aeed13afc1..65554a836a 100644 --- a/crates/libs/windows/src/Windows/UI/Xaml/Input/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Xaml/Input/mod.rs @@ -5902,6 +5902,34 @@ impl ::core::fmt::Debug for ManipulationModes { f.debug_tuple("ManipulationModes").field(&self.0).finish() } } +impl ::core::ops::BitOr for ManipulationModes { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ManipulationModes { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ManipulationModes { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ManipulationModes { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ManipulationModes { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ManipulationModes { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Xaml.Input.ManipulationModes;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Xaml/Media/Imaging/mod.rs b/crates/libs/windows/src/Windows/UI/Xaml/Media/Imaging/mod.rs index a4c8c2a3bc..e0f85c5832 100644 --- a/crates/libs/windows/src/Windows/UI/Xaml/Media/Imaging/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Xaml/Media/Imaging/mod.rs @@ -26,6 +26,34 @@ impl ::core::fmt::Debug for BitmapCreateOptions { f.debug_tuple("BitmapCreateOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for BitmapCreateOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for BitmapCreateOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for BitmapCreateOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for BitmapCreateOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for BitmapCreateOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for BitmapCreateOptions { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Xaml.Media.Imaging.BitmapCreateOptions;u4)"); } diff --git a/crates/libs/windows/src/Windows/UI/Xaml/mod.rs b/crates/libs/windows/src/Windows/UI/Xaml/mod.rs index 2032f4fe0f..4b98dea11e 100644 --- a/crates/libs/windows/src/Windows/UI/Xaml/mod.rs +++ b/crates/libs/windows/src/Windows/UI/Xaml/mod.rs @@ -488,6 +488,34 @@ impl ::core::fmt::Debug for ApplicationHighContrastAdjustment { f.debug_tuple("ApplicationHighContrastAdjustment").field(&self.0).finish() } } +impl ::core::ops::BitOr for ApplicationHighContrastAdjustment { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ApplicationHighContrastAdjustment { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ApplicationHighContrastAdjustment { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ApplicationHighContrastAdjustment { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ApplicationHighContrastAdjustment { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ApplicationHighContrastAdjustment { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Xaml.ApplicationHighContrastAdjustment;u4)"); } @@ -5206,6 +5234,34 @@ impl ::core::fmt::Debug for ElementHighContrastAdjustment { f.debug_tuple("ElementHighContrastAdjustment").field(&self.0).finish() } } +impl ::core::ops::BitOr for ElementHighContrastAdjustment { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for ElementHighContrastAdjustment { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for ElementHighContrastAdjustment { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for ElementHighContrastAdjustment { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for ElementHighContrastAdjustment { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for ElementHighContrastAdjustment { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Xaml.ElementHighContrastAdjustment;u4)"); } @@ -18753,6 +18809,34 @@ impl ::core::fmt::Debug for Vector3TransitionComponents { f.debug_tuple("Vector3TransitionComponents").field(&self.0).finish() } } +impl ::core::ops::BitOr for Vector3TransitionComponents { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for Vector3TransitionComponents { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for Vector3TransitionComponents { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for Vector3TransitionComponents { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for Vector3TransitionComponents { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} unsafe impl ::windows::core::RuntimeType for Vector3TransitionComponents { const SIGNATURE: ::windows::core::ConstBuffer = ::windows::core::ConstBuffer::from_slice(b"enum(Windows.UI.Xaml.Vector3TransitionComponents;u4)"); } diff --git a/crates/libs/windows/src/Windows/Win32/AI/MachineLearning/WinML/mod.rs b/crates/libs/windows/src/Windows/Win32/AI/MachineLearning/WinML/mod.rs index a061638300..26638b4888 100644 --- a/crates/libs/windows/src/Windows/Win32/AI/MachineLearning/WinML/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/AI/MachineLearning/WinML/mod.rs @@ -1468,6 +1468,34 @@ impl ::core::fmt::Debug for MLOperatorAttributeType { f.debug_tuple("MLOperatorAttributeType").field(&self.0).finish() } } +impl ::core::ops::BitOr for MLOperatorAttributeType { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MLOperatorAttributeType { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MLOperatorAttributeType { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MLOperatorAttributeType { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MLOperatorAttributeType { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} #[repr(C)] #[doc = "*Required features: 'Win32_AI_MachineLearning_WinML'*"] pub struct MLOperatorEdgeDescription { @@ -1547,6 +1575,34 @@ impl ::core::fmt::Debug for MLOperatorEdgeType { f.debug_tuple("MLOperatorEdgeType").field(&self.0).finish() } } +impl ::core::ops::BitOr for MLOperatorEdgeType { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MLOperatorEdgeType { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MLOperatorEdgeType { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MLOperatorEdgeType { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MLOperatorEdgeType { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} #[repr(C)] #[doc = "*Required features: 'Win32_AI_MachineLearning_WinML', 'Win32_Foundation'*"] #[cfg(feature = "Win32_Foundation")] @@ -1615,6 +1671,34 @@ impl ::core::fmt::Debug for MLOperatorExecutionType { f.debug_tuple("MLOperatorExecutionType").field(&self.0).finish() } } +impl ::core::ops::BitOr for MLOperatorExecutionType { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MLOperatorExecutionType { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MLOperatorExecutionType { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MLOperatorExecutionType { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MLOperatorExecutionType { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} #[repr(C)] #[doc = "*Required features: 'Win32_AI_MachineLearning_WinML', 'Win32_Foundation'*"] #[cfg(feature = "Win32_Foundation")] @@ -1700,6 +1784,34 @@ impl ::core::fmt::Debug for MLOperatorKernelOptions { f.debug_tuple("MLOperatorKernelOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for MLOperatorKernelOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MLOperatorKernelOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MLOperatorKernelOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MLOperatorKernelOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MLOperatorKernelOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} #[doc = "*Required features: 'Win32_AI_MachineLearning_WinML'*"] #[repr(transparent)] pub struct MLOperatorParameterOptions(pub u32); @@ -1728,6 +1840,34 @@ impl ::core::fmt::Debug for MLOperatorParameterOptions { f.debug_tuple("MLOperatorParameterOptions").field(&self.0).finish() } } +impl ::core::ops::BitOr for MLOperatorParameterOptions { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MLOperatorParameterOptions { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MLOperatorParameterOptions { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MLOperatorParameterOptions { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MLOperatorParameterOptions { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} #[repr(C)] #[doc = "*Required features: 'Win32_AI_MachineLearning_WinML', 'Win32_Foundation'*"] #[cfg(feature = "Win32_Foundation")] @@ -1965,6 +2105,34 @@ impl ::core::fmt::Debug for MLOperatorTensorDataType { f.debug_tuple("MLOperatorTensorDataType").field(&self.0).finish() } } +impl ::core::ops::BitOr for MLOperatorTensorDataType { + type Output = Self; + fn bitor(self, other: Self) -> Self { + Self(self.0 | other.0) + } +} +impl ::core::ops::BitAnd for MLOperatorTensorDataType { + type Output = Self; + fn bitand(self, other: Self) -> Self { + Self(self.0 & other.0) + } +} +impl ::core::ops::BitOrAssign for MLOperatorTensorDataType { + fn bitor_assign(&mut self, other: Self) { + self.0.bitor_assign(other.0) + } +} +impl ::core::ops::BitAndAssign for MLOperatorTensorDataType { + fn bitand_assign(&mut self, other: Self) { + self.0.bitand_assign(other.0) + } +} +impl ::core::ops::Not for MLOperatorTensorDataType { + type Output = Self; + fn not(self) -> Self { + Self(self.0.not()) + } +} #[repr(C)] #[doc = "*Required features: 'Win32_AI_MachineLearning_WinML', 'Win32_Foundation', 'Win32_Graphics_Direct3D12'*"] #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] diff --git a/crates/tests/enums/Cargo.toml b/crates/tests/enums/Cargo.toml new file mode 100644 index 0000000000..f8a9588885 --- /dev/null +++ b/crates/tests/enums/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "test_enums" +version = "0.0.0" +authors = ["Microsoft"] +edition = "2018" + +[dependencies.windows] +path = "../../libs/windows" +features = [ + "Storage_Streams", +] diff --git a/crates/tests/enums/src/lib.rs b/crates/tests/enums/src/lib.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/crates/tests/enums/src/lib.rs @@ -0,0 +1 @@ + diff --git a/crates/tests/enums/tests/tests.rs b/crates/tests/enums/tests/tests.rs new file mode 100644 index 0000000000..8b8bd01c1f --- /dev/null +++ b/crates/tests/enums/tests/tests.rs @@ -0,0 +1,20 @@ +use windows::Storage::Streams::*; + +#[test] +fn nested() { + let options = InputStreamOptions::Partial | InputStreamOptions::ReadAhead; + assert!(options.0 == 3); + + let options = InputStreamOptions::Partial & InputStreamOptions::ReadAhead; + assert!(options.0 == 0); + + let options = (InputStreamOptions::Partial | InputStreamOptions::ReadAhead) & InputStreamOptions::ReadAhead; + assert!(options.0 == 2); + + let mut options = InputStreamOptions::Partial; + options |= InputStreamOptions::ReadAhead; + assert!(options.0 == 3); + + options &= InputStreamOptions::ReadAhead; + assert!(options.0 == 2); +}