/rust/registry/src/index.crates.io-1949cf8c6b5b557f/bitflags-2.4.0/src/external.rs

Source
//! Conditional trait implementations for external libraries.

/*
How do I support a new external library?

Let's say we want to add support for `my_library`.

First, we create a module under `external`, like `serde` with any specialized code.
Ideally, any utilities in here should just work off the `Flags` trait and maybe a
few other assumed bounds.

Next, re-export the library from the `__private` module here.

Next, define a macro like so:

```rust
#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(feature = "serde")]
macro_rules! __impl_external_bitflags_my_library {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {
        // Implementation goes here
    };
}

#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(not(feature = "my_library"))]
macro_rules! __impl_external_bitflags_my_library {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {};
}
```

Note that the macro is actually defined twice; once for when the `my_library` feature
is available, and once for when it's not. This is because the `__impl_external_bitflags_my_library`
macro is called in an end-user's library, not in `bitflags`. In an end-user's library we don't
know whether or not a particular feature of `bitflags` is enabled, so we unconditionally call
the macro, where the body of that macro depends on the feature flag.

Now, we add our macro call to the `__impl_external_bitflags` macro body:

```rust
__impl_external_bitflags_my_library! {
    $InternalBitFlags: $T, $PublicBitFlags {
        $(
            $(#[$inner $($args)*])*
            const $Flag;
        )*
    }
}
```
*/

pub(crate) mod __private {
    #[cfg(feature = "serde")]
    pub use serde;

    #[cfg(feature = "arbitrary")]
    pub use arbitrary;

    #[cfg(feature = "bytemuck")]
    pub use bytemuck;
}

/// Implements traits from external libraries for the internal bitflags type.
#[macro_export(local_inner_macros)]
#[doc(hidden)]
macro_rules! __impl_external_bitflags {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {
        // Any new library traits impls should be added here
        // Use `serde` as an example: generate code when the feature is available,
        // and a no-op when it isn't

        __impl_external_bitflags_serde! {
            $InternalBitFlags: $T, $PublicBitFlags {
                $(
                    $(#[$inner $($args)*])*
                    const $Flag;
                )*
            }
        }

        __impl_external_bitflags_arbitrary! {
            $InternalBitFlags: $T, $PublicBitFlags {
                $(
                    $(#[$inner $($args)*])*
                    const $Flag;
                )*
            }
        }

        __impl_external_bitflags_bytemuck! {
            $InternalBitFlags: $T, $PublicBitFlags {
                $(
                    $(#[$inner $($args)*])*
                    const $Flag;
                )*
            }
        }
    };
}

#[cfg(feature = "serde")]
pub mod serde;

/// Implement `Serialize` and `Deserialize` for the internal bitflags type.
#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(feature = "serde")]
macro_rules! __impl_external_bitflags_serde {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {
        impl $crate::__private::serde::Serialize for $InternalBitFlags {
            fn serialize<S: $crate::__private::serde::Serializer>(
                &self,
                serializer: S,
            ) -> $crate::__private::core::result::Result<S::Ok, S::Error> {
                $crate::serde::serialize(
                    &$PublicBitFlags::from_bits_retain(self.bits()),
                    serializer,
                )
            }
        }

        impl<'de> $crate::__private::serde::Deserialize<'de> for $InternalBitFlags {
            fn deserialize<D: $crate::__private::serde::Deserializer<'de>>(
                deserializer: D,
            ) -> $crate::__private::core::result::Result<Self, D::Error> {
                let flags: $PublicBitFlags = $crate::serde::deserialize(deserializer)?;

                Ok(flags.0)
            }
        }
    };
}

#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(not(feature = "serde"))]
macro_rules! __impl_external_bitflags_serde {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {};
}

#[cfg(feature = "arbitrary")]
pub mod arbitrary;

#[cfg(feature = "bytemuck")]
mod bytemuck;

/// Implement `Arbitrary` for the internal bitflags type.
#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(feature = "arbitrary")]
macro_rules! __impl_external_bitflags_arbitrary {
    (
            $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
                $(
                    $(#[$inner:ident $($args:tt)*])*
                    const $Flag:tt;
                )*
            }
    ) => {
        impl<'a> $crate::__private::arbitrary::Arbitrary<'a> for $InternalBitFlags {
            fn arbitrary(
                u: &mut $crate::__private::arbitrary::Unstructured<'a>,
            ) -> $crate::__private::arbitrary::Result<Self> {
                $crate::arbitrary::arbitrary::<$PublicBitFlags>(u).map(|flags| flags.0)
            }
        }
    };
}

#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(not(feature = "arbitrary"))]
macro_rules! __impl_external_bitflags_arbitrary {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {};
}

/// Implement `Pod` and `Zeroable` for the internal bitflags type.
#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(feature = "bytemuck")]
macro_rules! __impl_external_bitflags_bytemuck {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {
        // SAFETY: $InternalBitFlags is guaranteed to have the same ABI as $T,
        // and $T implements Pod
        unsafe impl $crate::__private::bytemuck::Pod for $InternalBitFlags where
            $T: $crate::__private::bytemuck::Pod
        {
        }

        // SAFETY: $InternalBitFlags is guaranteed to have the same ABI as $T,
        // and $T implements Zeroable
        unsafe impl $crate::__private::bytemuck::Zeroable for $InternalBitFlags where
            $T: $crate::__private::bytemuck::Zeroable
        {
        }
    };
}

#[macro_export(local_inner_macros)]
#[doc(hidden)]
#[cfg(not(feature = "bytemuck"))]
macro_rules! __impl_external_bitflags_bytemuck {
    (
        $InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:tt;
            )*
        }
    ) => {};
}

Coverage Report

Created: 2025-10-29 06:49

Line	Count	Source
1		//! Conditional trait implementations for external libraries.
2
3		/*
4		How do I support a new external library?
5
6		Let's say we want to add support for `my_library`.
7
8		First, we create a module under `external`, like `serde` with any specialized code.
9		Ideally, any utilities in here should just work off the `Flags` trait and maybe a
10		few other assumed bounds.
11
12		Next, re-export the library from the `__private` module here.
13
14		Next, define a macro like so:
15
16		```rust
17		#[macro_export(local_inner_macros)]
18		#[doc(hidden)]
19		#[cfg(feature = "serde")]
20		macro_rules! __impl_external_bitflags_my_library {
21		(
22		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
23		$(
24		$(#[$inner:ident $($args:tt)])
25		const $Flag:tt;
26		)*
27		}
28		) => {
29		// Implementation goes here
30		};
31		}
32
33		#[macro_export(local_inner_macros)]
34		#[doc(hidden)]
35		#[cfg(not(feature = "my_library"))]
36		macro_rules! __impl_external_bitflags_my_library {
37		(
38		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
39		$(
40		$(#[$inner:ident $($args:tt)])
41		const $Flag:tt;
42		)*
43		}
44		) => {};
45		}
46		```
47
48		Note that the macro is actually defined twice; once for when the `my_library` feature
49		is available, and once for when it's not. This is because the `__impl_external_bitflags_my_library`
50		macro is called in an end-user's library, not in `bitflags`. In an end-user's library we don't
51		know whether or not a particular feature of `bitflags` is enabled, so we unconditionally call
52		the macro, where the body of that macro depends on the feature flag.
53
54		Now, we add our macro call to the `__impl_external_bitflags` macro body:
55
56		```rust
57		__impl_external_bitflags_my_library! {
58		$InternalBitFlags: $T, $PublicBitFlags {
59		$(
60		$(#[$inner $($args)])
61		const $Flag;
62		)*
63		}
64		}
65		```
66		*/
67
68		pub(crate) mod __private {
69		#[cfg(feature = "serde")]
70		pub use serde;
71
72		#[cfg(feature = "arbitrary")]
73		pub use arbitrary;
74
75		#[cfg(feature = "bytemuck")]
76		pub use bytemuck;
77		}
78
79		/// Implements traits from external libraries for the internal bitflags type.
80		#[macro_export(local_inner_macros)]
81		#[doc(hidden)]
82		macro_rules! __impl_external_bitflags {
83		(
84		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
85		$(
86		$(#[$inner:ident $($args:tt)])
87		const $Flag:tt;
88		)*
89		}
90		) => {
91		// Any new library traits impls should be added here
92		// Use `serde` as an example: generate code when the feature is available,
93		// and a no-op when it isn't
94
95		__impl_external_bitflags_serde! {
96		$InternalBitFlags: $T, $PublicBitFlags {
97		$(
98		$(#[$inner $($args)])
99		const $Flag;
100		)*
101		}
102		}
103
104		__impl_external_bitflags_arbitrary! {
105		$InternalBitFlags: $T, $PublicBitFlags {
106		$(
107		$(#[$inner $($args)])
108		const $Flag;
109		)*
110		}
111		}
112
113		__impl_external_bitflags_bytemuck! {
114		$InternalBitFlags: $T, $PublicBitFlags {
115		$(
116		$(#[$inner $($args)])
117		const $Flag;
118		)*
119		}
120		}
121		};
122		}
123
124		#[cfg(feature = "serde")]
125		pub mod serde;
126
127		/// Implement `Serialize` and `Deserialize` for the internal bitflags type.
128		#[macro_export(local_inner_macros)]
129		#[doc(hidden)]
130		#[cfg(feature = "serde")]
131		macro_rules! __impl_external_bitflags_serde {
132		(
133		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
134		$(
135		$(#[$inner:ident $($args:tt)])
136		const $Flag:tt;
137		)*
138		}
139		) => {
140		impl $crate::__private::serde::Serialize for $InternalBitFlags {
141	0	fn serialize<S: $crate::__private::serde::Serializer>(
142	0	&self,
143	0	serializer: S,
144	0	) -> $crate::__private::core::result::Result<S::Ok, S::Error> {
145	0	$crate::serde::serialize(
146	0	&$PublicBitFlags::from_bits_retain(self.bits()),
147	0	serializer,
148		)
149	0	} Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::ser::Serialize>::serialize::<serde_json::ser::MapKeySerializer<&mut alloc::vec::Vec<u8>, serde_json::ser::PrettyFormatter>> Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::ser::Serialize>::serialize::<&mut serde_json::ser::Serializer<&mut alloc::vec::Vec<u8>, serde_json::ser::PrettyFormatter>> Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::ser::Serialize>::serialize::<&mut serde_json::ser::Serializer<&mut alloc::vec::Vec<u8>, serde_json::ser::PrettyFormatter>> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::unistd::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::wait::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::memfd::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::signal::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::socket::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::socket::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::socket::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::statvfs::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::signalfd::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::unistd::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::memfd::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <nix::sys::statvfs::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::cipher_ctx::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::cms::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::ocsp::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::pkcs7::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::x509::verify::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_> Unexecuted instantiation: <openssl::x509::verify::_::InternalBitFlags as serde::ser::Serialize>::serialize::<_>
150		}
151
152		impl<'de> $crate::__private::serde::Deserialize<'de> for $InternalBitFlags {
153	0	fn deserialize<D: $crate::__private::serde::Deserializer<'de>>(
154	0	deserializer: D,
155	0	) -> $crate::__private::core::result::Result<Self, D::Error> {
156	0	let flags: $PublicBitFlags = $crate::serde::deserialize(deserializer)?;
157
158	0	Ok(flags.0)
159	0	} Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <cras_common::types_internal::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::unistd::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::wait::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::memfd::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::signal::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::socket::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::socket::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::socket::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::statvfs::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::signalfd::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::fcntl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::unistd::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::stat::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::memfd::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <nix::sys::statvfs::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::cipher_ctx::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::cms::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::ssl::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::ocsp::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::pkcs7::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::x509::verify::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_> Unexecuted instantiation: <openssl::x509::verify::_::InternalBitFlags as serde::de::Deserialize>::deserialize::<_>
160		}
161		};
162		}
163
164		#[macro_export(local_inner_macros)]
165		#[doc(hidden)]
166		#[cfg(not(feature = "serde"))]
167		macro_rules! __impl_external_bitflags_serde {
168		(
169		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
170		$(
171		$(#[$inner:ident $($args:tt)])
172		const $Flag:tt;
173		)*
174		}
175		) => {};
176		}
177
178		#[cfg(feature = "arbitrary")]
179		pub mod arbitrary;
180
181		#[cfg(feature = "bytemuck")]
182		mod bytemuck;
183
184		/// Implement `Arbitrary` for the internal bitflags type.
185		#[macro_export(local_inner_macros)]
186		#[doc(hidden)]
187		#[cfg(feature = "arbitrary")]
188		macro_rules! __impl_external_bitflags_arbitrary {
189		(
190		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
191		$(
192		$(#[$inner:ident $($args:tt)])
193		const $Flag:tt;
194		)*
195		}
196		) => {
197		impl<'a> $crate::__private::arbitrary::Arbitrary<'a> for $InternalBitFlags {
198		fn arbitrary(
199		u: &mut $crate::__private::arbitrary::Unstructured<'a>,
200		) -> $crate::__private::arbitrary::Result<Self> {
201		$crate::arbitrary::arbitrary::<$PublicBitFlags>(u).map(\|flags\| flags.0)
202		}
203		}
204		};
205		}
206
207		#[macro_export(local_inner_macros)]
208		#[doc(hidden)]
209		#[cfg(not(feature = "arbitrary"))]
210		macro_rules! __impl_external_bitflags_arbitrary {
211		(
212		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
213		$(
214		$(#[$inner:ident $($args:tt)])
215		const $Flag:tt;
216		)*
217		}
218		) => {};
219		}
220
221		/// Implement `Pod` and `Zeroable` for the internal bitflags type.
222		#[macro_export(local_inner_macros)]
223		#[doc(hidden)]
224		#[cfg(feature = "bytemuck")]
225		macro_rules! __impl_external_bitflags_bytemuck {
226		(
227		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
228		$(
229		$(#[$inner:ident $($args:tt)])
230		const $Flag:tt;
231		)*
232		}
233		) => {
234		// SAFETY: $InternalBitFlags is guaranteed to have the same ABI as $T,
235		// and $T implements Pod
236		unsafe impl $crate::__private::bytemuck::Pod for $InternalBitFlags where
237		$T: $crate::__private::bytemuck::Pod
238		{
239		}
240
241		// SAFETY: $InternalBitFlags is guaranteed to have the same ABI as $T,
242		// and $T implements Zeroable
243		unsafe impl $crate::__private::bytemuck::Zeroable for $InternalBitFlags where
244		$T: $crate::__private::bytemuck::Zeroable
245		{
246		}
247		};
248		}
249
250		#[macro_export(local_inner_macros)]
251		#[doc(hidden)]
252		#[cfg(not(feature = "bytemuck"))]
253		macro_rules! __impl_external_bitflags_bytemuck {
254		(
255		$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
256		$(
257		$(#[$inner:ident $($args:tt)])
258		const $Flag:tt;
259		)*
260		}
261		) => {};
262		}