refactor: split cargo workspace

crates/jay-config/src/macros.rs

@@ -0,0 +1,113 @@
+macro_rules! try_get {
+    () => {{
+        unsafe {
+            let client = crate::_private::client::CLIENT.with(|client| client.get());
+            if client.is_null() {
+                None
+            } else {
+                Some(&*client)
+            }
+        }
+    }};
+}
+
+macro_rules! get {
+    () => {{ get!(Default::default()) }};
+    ($def:expr) => {{
+        let client = unsafe {
+            let client = crate::_private::client::CLIENT.with(|client| client.get());
+            if client.is_null() {
+                return $def;
+            }
+            &*client
+        };
+        client
+    }};
+}
+
+macro_rules! bitflags {
+    (
+        $(#[$attr1:meta])*
+        $vis1:vis struct $name:ident($vis2:vis $rep:ty) {
+            $(
+                $(#[$attr2:meta])*
+                $vis3:vis const $var:ident = $val:expr,
+            )*
+        }
+    ) => {
+        $(#[$attr1])*
+        $vis1 struct $name($vis2 $rep);
+
+        $(
+            $(#[$attr2])*
+            $vis3 const $var: $name = $name($val);
+        )*
+
+        impl std::ops::BitOr for $name {
+            type Output = Self;
+
+            fn bitor(self, rhs: Self) -> Self::Output {
+                Self(self.0 | rhs.0)
+            }
+        }
+
+        impl std::ops::BitAnd for $name {
+            type Output = Self;
+
+            fn bitand(self, rhs: Self) -> Self::Output {
+                Self(self.0 & rhs.0)
+            }
+        }
+
+        impl std::ops::BitOrAssign for $name {
+            fn bitor_assign(&mut self, rhs: Self) {
+                self.0 |= rhs.0;
+            }
+        }
+
+        impl std::ops::BitAndAssign for $name {
+            fn bitand_assign(&mut self, rhs: Self) {
+                self.0 &= rhs.0;
+            }
+        }
+
+        impl std::ops::BitXorAssign for $name {
+            fn bitxor_assign(&mut self, rhs: Self) {
+                self.0 ^= rhs.0;
+            }
+        }
+
+        impl std::ops::Not for $name {
+            type Output = Self;
+
+            fn not(self) -> Self::Output {
+                Self(!self.0)
+            }
+        }
+
+        impl std::fmt::Debug for $name {
+            #[allow(clippy::allow_attributes, clippy::bad_bit_mask, unused_mut)]
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                let mut any = false;
+                let mut v = self.0;
+                $(
+                    if $val != 0 && v & $val == $val {
+                        if any {
+                            write!(f, "|")?;
+                        }
+                        any = true;
+                        write!(f, "{}", stringify!($var))?;
+                        v &= !$val;
+                    }
+                )*
+                if !any || v != 0 {
+                    if any {
+                        write!(f, "|")?;
+                    }
+                    write!(f, "0x{:x}", v)?;
+                }
+                Ok(())
+            }
+        }
+    }
+}