From 9835e2ae736235810b4ea1c162ca5e65c547e770 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sat, 18 May 2024 04:49:50 +0200
Subject: Merging upstream version 1.71.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 vendor/bitflags/examples/fmt.rs   | 49 +++++++++++++++++++++++++++++++++++++++
 vendor/bitflags/examples/serde.rs | 36 ++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+)
 create mode 100644 vendor/bitflags/examples/fmt.rs
 create mode 100644 vendor/bitflags/examples/serde.rs

(limited to 'vendor/bitflags/examples')

diff --git a/vendor/bitflags/examples/fmt.rs b/vendor/bitflags/examples/fmt.rs
new file mode 100644
index 000000000..3bb9b8c48
--- /dev/null
+++ b/vendor/bitflags/examples/fmt.rs
@@ -0,0 +1,49 @@
+//! An example of implementing Rust's standard formatting and parsing traits for flags types.
+
+use core::{fmt, str};
+
+fn main() -> Result<(), bitflags::parser::ParseError> {
+    bitflags::bitflags! {
+        // You can `#[derive]` the `Debug` trait, but implementing it manually
+        // can produce output like `A | B` instead of `Flags(A | B)`.
+        // #[derive(Debug)]
+        #[derive(PartialEq, Eq)]
+        pub struct Flags: u32 {
+            const A = 1;
+            const B = 2;
+            const C = 4;
+            const D = 8;
+        }
+    }
+
+    impl fmt::Debug for Flags {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            fmt::Debug::fmt(&self.0, f)
+        }
+    }
+
+    impl fmt::Display for Flags {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            fmt::Display::fmt(&self.0, f)
+        }
+    }
+
+    impl str::FromStr for Flags {
+        type Err = bitflags::parser::ParseError;
+
+        fn from_str(flags: &str) -> Result<Self, Self::Err> {
+            Ok(Self(flags.parse()?))
+        }
+    }
+
+    let flags = Flags::A | Flags::B;
+
+    println!("{}", flags);
+
+    let formatted = flags.to_string();
+    let parsed: Flags = formatted.parse()?;
+
+    assert_eq!(flags, parsed);
+
+    Ok(())
+}
diff --git a/vendor/bitflags/examples/serde.rs b/vendor/bitflags/examples/serde.rs
new file mode 100644
index 000000000..22eae2db6
--- /dev/null
+++ b/vendor/bitflags/examples/serde.rs
@@ -0,0 +1,36 @@
+//! An example of implementing `serde::Serialize` and `serde::Deserialize`.
+//! The `#[serde(transparent)]` attribute is recommended to serialize directly
+//! to the underlying bits type without wrapping it in a `serde` newtype.
+
+#[cfg(feature = "serde")]
+fn main() {
+    use serde_derive::*;
+
+    bitflags::bitflags! {
+        #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+        #[serde(transparent)]
+        pub struct Flags: u32 {
+            const A = 1;
+            const B = 2;
+            const C = 4;
+            const D = 8;
+        }
+    }
+
+    let flags = Flags::A | Flags::B;
+
+    let serialized = serde_json::to_string(&flags).unwrap();
+
+    println!("{:?} -> {}", flags, serialized);
+
+    assert_eq!(serialized, r#""A | B""#);
+
+    let deserialized: Flags = serde_json::from_str(&serialized).unwrap();
+
+    println!("{} -> {:?}", serialized, flags);
+
+    assert_eq!(deserialized, flags);
+}
+
+#[cfg(not(feature = "serde"))]
+fn main() {}
-- 
cgit v1.2.3