use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
pub struct EmptyParams {}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
pub struct EmptyResponse {}
struct EmptyObjectVisitor;
impl<'de> serde::de::Visitor<'de> for EmptyObjectVisitor {
type Value = ();
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("JSON 对象")
}
fn visit_map<M: serde::de::MapAccess<'de>>(self, mut map: M) -> Result<(), M::Error> {
while map
.next_entry::<serde::de::IgnoredAny, serde::de::IgnoredAny>()?
.is_some()
{}
Ok(())
}
}
impl<'de> Deserialize<'de> for EmptyParams {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
deserializer
.deserialize_map(EmptyObjectVisitor)
.map(|()| Self {})
}
}
impl<'de> Deserialize<'de> for EmptyResponse {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
deserializer
.deserialize_map(EmptyObjectVisitor)
.map(|()| Self {})
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum Nullable<T> {
Null,
Value(T),
}
impl<T: Serialize> Serialize for Nullable<T> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Null => serializer.serialize_none(),
Self::Value(v) => v.serialize(serializer),
}
}
}
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Nullable<T> {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
Option::<T>::deserialize(deserializer).map(|value| match value {
Some(v) => Self::Value(v),
None => Self::Null,
})
}
}
pub fn presence<'de, D: Deserializer<'de>, T: Deserialize<'de>>(
deserializer: D,
) -> Result<Option<T>, D::Error> {
T::deserialize(deserializer).map(Some)
}
pub fn required<'de, D: Deserializer<'de>, T: Deserialize<'de>>(
deserializer: D,
) -> Result<T, D::Error> {
T::deserialize(deserializer)
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct FiniteF64(f64);
impl FiniteF64 {
pub fn get(self) -> f64 {
self.0
}
}
impl TryFrom<f64> for FiniteF64 {
type Error = crate::Error;
fn try_from(value: f64) -> Result<Self, Self::Error> {
if value.is_finite() {
Ok(Self(value))
} else {
Err(crate::Error::new(crate::ErrorKind::InvalidArgument))
}
}
}
impl Serialize for FiniteF64 {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
if self.0.is_finite() {
serializer.serialize_f64(self.0)
} else {
Err(serde::ser::Error::custom("协议 number 必须有限"))
}
}
}
impl<'de> Deserialize<'de> for FiniteF64 {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = f64::deserialize(deserializer)?;
Self::try_from(value).map_err(|_| serde::de::Error::custom("协议 number 必须有限"))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Deserialize)]
struct Shape {
#[serde(default, deserialize_with = "presence")]
optional: Option<String>,
#[serde(default, deserialize_with = "presence")]
any: Option<serde_json::Value>,
#[serde(deserialize_with = "required")]
nullable: Nullable<String>,
}
#[test]
fn presence_is_not_null() {
assert!(serde_json::from_str::<Shape>(r#"{"nullable":null,"optional":null}"#).is_err());
assert!(serde_json::from_str::<Shape>("{}").is_err());
let value: Shape = serde_json::from_str(r#"{"nullable":null,"any":null}"#).unwrap();
assert_eq!(value.optional, None);
assert_eq!(value.any, Some(serde_json::Value::Null));
assert_eq!(value.nullable, Nullable::Null);
}
#[test]
fn empty_objects_and_finite_numbers() {
assert_eq!(serde_json::to_string(&EmptyParams {}).unwrap(), "{}");
assert!(serde_json::from_str::<EmptyResponse>(r#"{"future":1}"#).is_ok());
for invalid in ["null", "[]", "1"] {
assert!(serde_json::from_str::<EmptyResponse>(invalid).is_err());
}
for invalid in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
assert!(FiniteF64::try_from(invalid).is_err());
}
assert!(serde_json::from_str::<FiniteF64>("1e400").is_err());
}
}