Extract common DropGuard struct and NumberExt trait

Both are used in multiple schemars versions so keeping them in utils.rs
is a better choice than duplicating them in each file.

Author: jonasbb

serde_with/src/schemars_0_8.rs

@@ -17,10 +17,6 @@ use ::schemars_0_8::{
     },
     JsonSchema,
 };
-use core::{
-    mem::ManuallyDrop,
-    ops::{Deref, DerefMut},
-};
 
 //===================================================================
 // Trait Definition
@@ -688,9 +684,9 @@ where
             };
 
             parents.push(name);
-            DropGuard::new(parents, |parents| drop(parents.pop()))
+            utils::DropGuard::new(parents, |parents| drop(parents.pop()))
         } else {
-            DropGuard::unguarded(parents)
+            utils::DropGuard::unguarded(parents)
         };
 
         if let Some(object) = &mut schema.object {
@@ -1290,52 +1286,3 @@ forward_duration_schema!(TimestampSecondsWithFrac);
 forward_duration_schema!(TimestampMilliSecondsWithFrac);
 forward_duration_schema!(TimestampMicroSecondsWithFrac);
 forward_duration_schema!(TimestampNanoSecondsWithFrac);
-
-//===================================================================
-// Extra internal helper structs
-
-struct DropGuard<T, F: FnOnce(T)> {
-    value: ManuallyDrop<T>,
-    guard: Option<F>,
-}
-
-impl<T, F: FnOnce(T)> DropGuard<T, F> {
-    pub fn new(value: T, guard: F) -> Self {
-        Self {
-            value: ManuallyDrop::new(value),
-            guard: Some(guard),
-        }
-    }
-
-    pub fn unguarded(value: T) -> Self {
-        Self {
-            value: ManuallyDrop::new(value),
-            guard: None,
-        }
-    }
-}
-
-impl<T, F: FnOnce(T)> Deref for DropGuard<T, F> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl<T, F: FnOnce(T)> DerefMut for DropGuard<T, F> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.value
-    }
-}
-
-impl<T, F: FnOnce(T)> Drop for DropGuard<T, F> {
-    fn drop(&mut self) {
-        // SAFETY: value is known to be initialized since we only ever remove it here.
-        let value = unsafe { ManuallyDrop::take(&mut self.value) };
-
-        if let Some(guard) = self.guard.take() {
-            guard(value);
-        }
-    }
-}

serde_with/src/schemars_0_9.rs

@@ -8,6 +8,7 @@
 use crate::{
     formats::{Flexible, Format, PreferMany, PreferOne, Separator, Strict},
     prelude::{Schema as WrapSchema, *},
+    utils::NumberExt as _,
 };
 use ::schemars_0_9::{json_schema, JsonSchema, Schema, SchemaGenerator};
 use alloc::{
@@ -17,10 +18,6 @@ use alloc::{
     rc::Rc,
     vec::Vec,
 };
-use core::{
-    mem::ManuallyDrop,
-    ops::{Deref, DerefMut},
-};
 use serde_json::Value;
 
 //===================================================================
@@ -690,9 +687,9 @@ where
             };
 
             parents.push(name);
-            DropGuard::new(parents, |parents| drop(parents.pop()))
+            utils::DropGuard::new(parents, |parents| drop(parents.pop()))
         } else {
-            DropGuard::unguarded(parents)
+            utils::DropGuard::unguarded(parents)
         };
 
         // We do comparisons here to avoid lifetime conflicts below
@@ -1286,77 +1283,3 @@ forward_duration_schema!(TimestampSecondsWithFrac);
 forward_duration_schema!(TimestampMilliSecondsWithFrac);
 forward_duration_schema!(TimestampMicroSecondsWithFrac);
 forward_duration_schema!(TimestampNanoSecondsWithFrac);
-
-//===================================================================
-// Extra internal helper structs
-
-struct DropGuard<T, F: FnOnce(T)> {
-    value: ManuallyDrop<T>,
-    guard: Option<F>,
-}
-
-impl<T, F: FnOnce(T)> DropGuard<T, F> {
-    pub fn new(value: T, guard: F) -> Self {
-        Self {
-            value: ManuallyDrop::new(value),
-            guard: Some(guard),
-        }
-    }
-
-    pub fn unguarded(value: T) -> Self {
-        Self {
-            value: ManuallyDrop::new(value),
-            guard: None,
-        }
-    }
-}
-
-impl<T, F: FnOnce(T)> Deref for DropGuard<T, F> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl<T, F: FnOnce(T)> DerefMut for DropGuard<T, F> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.value
-    }
-}
-
-impl<T, F: FnOnce(T)> Drop for DropGuard<T, F> {
-    fn drop(&mut self) {
-        // SAFETY: value is known to be initialized since we only ever remove it here.
-        let value = unsafe { ManuallyDrop::take(&mut self.value) };
-
-        if let Some(guard) = self.guard.take() {
-            guard(value);
-        }
-    }
-}
-
-trait NumberExt: Sized {
-    fn saturating_sub(&self, count: u64) -> Self;
-}
-
-impl NumberExt for serde_json::Number {
-    fn saturating_sub(&self, count: u64) -> Self {
-        if let Some(v) = self.as_u64() {
-            return v.saturating_sub(count).into();
-        }
-
-        if let Some(v) = self.as_i64() {
-            if count < i64::MAX as u64 {
-                return v.saturating_sub(count as _).into();
-            }
-        }
-
-        if let Some(v) = self.as_f64() {
-            return serde_json::Number::from_f64(v - (count as f64))
-                .expect("saturating_sub resulted in NaN");
-        }
-
-        unreachable!()
-    }
-}

serde_with/src/schemars_1.rs

@@ -8,6 +8,7 @@
 use crate::{
     formats::{Flexible, Format, PreferMany, PreferOne, Separator, Strict},
     prelude::{Schema as WrapSchema, *},
+    utils::NumberExt as _,
 };
 use ::schemars_1::{json_schema, JsonSchema, Schema, SchemaGenerator};
 use alloc::{
@@ -17,10 +18,6 @@ use alloc::{
     rc::Rc,
     vec::Vec,
 };
-use core::{
-    mem::ManuallyDrop,
-    ops::{Deref, DerefMut},
-};
 use serde_json::Value;
 
 //===================================================================
@@ -694,9 +691,9 @@ where
             };
 
             parents.push(name);
-            DropGuard::new(parents, |parents| drop(parents.pop()))
+            utils::DropGuard::new(parents, |parents| drop(parents.pop()))
         } else {
-            DropGuard::unguarded(parents)
+            utils::DropGuard::unguarded(parents)
         };
 
         // We do comparisons here to avoid lifetime conflicts below
@@ -1293,77 +1290,3 @@ forward_duration_schema!(TimestampSecondsWithFrac);
 forward_duration_schema!(TimestampMilliSecondsWithFrac);
 forward_duration_schema!(TimestampMicroSecondsWithFrac);
 forward_duration_schema!(TimestampNanoSecondsWithFrac);
-
-//===================================================================
-// Extra internal helper structs
-
-struct DropGuard<T, F: FnOnce(T)> {
-    value: ManuallyDrop<T>,
-    guard: Option<F>,
-}
-
-impl<T, F: FnOnce(T)> DropGuard<T, F> {
-    pub fn new(value: T, guard: F) -> Self {
-        Self {
-            value: ManuallyDrop::new(value),
-            guard: Some(guard),
-        }
-    }
-
-    pub fn unguarded(value: T) -> Self {
-        Self {
-            value: ManuallyDrop::new(value),
-            guard: None,
-        }
-    }
-}
-
-impl<T, F: FnOnce(T)> Deref for DropGuard<T, F> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl<T, F: FnOnce(T)> DerefMut for DropGuard<T, F> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.value
-    }
-}
-
-impl<T, F: FnOnce(T)> Drop for DropGuard<T, F> {
-    fn drop(&mut self) {
-        // SAFETY: value is known to be initialized since we only ever remove it here.
-        let value = unsafe { ManuallyDrop::take(&mut self.value) };
-
-        if let Some(guard) = self.guard.take() {
-            guard(value);
-        }
-    }
-}
-
-trait NumberExt: Sized {
-    fn saturating_sub(&self, count: u64) -> Self;
-}
-
-impl NumberExt for serde_json::Number {
-    fn saturating_sub(&self, count: u64) -> Self {
-        if let Some(v) = self.as_u64() {
-            return v.saturating_sub(count).into();
-        }
-
-        if let Some(v) = self.as_i64() {
-            if count < i64::MAX as u64 {
-                return v.saturating_sub(count as _).into();
-            }
-        }
-
-        if let Some(v) = self.as_f64() {
-            return serde_json::Number::from_f64(v - (count as f64))
-                .expect("saturating_sub resulted in NaN");
-        }
-
-        unreachable!()
-    }
-}

serde_with/src/utils.rs

@@ -240,3 +240,101 @@ pub(crate) fn get_unexpected_u128(value: u128, buf: &mut [u8; 58]) -> Unexpected
     fmt::Write::write_fmt(&mut writer, format_args!("integer `{value}` as u128")).unwrap();
     Unexpected::Other(writer.into_str())
 }
+
+#[cfg(any(
+    feature = "schemars_0_8",
+    feature = "schemars_0_9",
+    feature = "schemars_1"
+))]
+pub(crate) struct DropGuard<T, F: FnOnce(T)> {
+    value: core::mem::ManuallyDrop<T>,
+    guard: Option<F>,
+}
+
+#[cfg(any(
+    feature = "schemars_0_8",
+    feature = "schemars_0_9",
+    feature = "schemars_1"
+))]
+impl<T, F: FnOnce(T)> DropGuard<T, F> {
+    pub fn new(value: T, guard: F) -> Self {
+        Self {
+            value: core::mem::ManuallyDrop::new(value),
+            guard: Some(guard),
+        }
+    }
+
+    pub fn unguarded(value: T) -> Self {
+        Self {
+            value: core::mem::ManuallyDrop::new(value),
+            guard: None,
+        }
+    }
+}
+
+#[cfg(any(
+    feature = "schemars_0_8",
+    feature = "schemars_0_9",
+    feature = "schemars_1"
+))]
+impl<T, F: FnOnce(T)> core::ops::Deref for DropGuard<T, F> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+#[cfg(any(
+    feature = "schemars_0_8",
+    feature = "schemars_0_9",
+    feature = "schemars_1"
+))]
+impl<T, F: FnOnce(T)> core::ops::DerefMut for DropGuard<T, F> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.value
+    }
+}
+
+#[cfg(any(
+    feature = "schemars_0_8",
+    feature = "schemars_0_9",
+    feature = "schemars_1"
+))]
+impl<T, F: FnOnce(T)> Drop for DropGuard<T, F> {
+    fn drop(&mut self) {
+        // SAFETY: value is known to be initialized since we only ever remove it here.
+        let value = unsafe { core::mem::ManuallyDrop::take(&mut self.value) };
+
+        if let Some(guard) = self.guard.take() {
+            guard(value);
+        }
+    }
+}
+
+#[cfg(any(feature = "schemars_0_9", feature = "schemars_1"))]
+pub(crate) trait NumberExt: Sized {
+    fn saturating_sub(&self, count: u64) -> Self;
+}
+
+#[cfg(any(feature = "schemars_0_9", feature = "schemars_1"))]
+impl NumberExt for serde_json::Number {
+    fn saturating_sub(&self, count: u64) -> Self {
+        if let Some(v) = self.as_u64() {
+            return v.saturating_sub(count).into();
+        }
+
+        if let Some(v) = self.as_i64() {
+            if count < i64::MAX as u64 {
+                return v.saturating_sub(count as _).into();
+            }
+        }
+
+        if let Some(v) = self.as_f64() {
+            return serde_json::Number::from_f64(v - (count as f64))
+                .expect("saturating_sub resulted in NaN");
+        }
+
+        unreachable!()
+    }
+}