use serde::{de, Deserialize, Deserializer, Serializer};
use serde_json::Value;
use std::fmt::Display;
use std::str::FromStr;
pub fn default_page_num() -> u32 {
1
}
pub fn default_page_size() -> u32 {
10
}
pub fn deserialize_number_or_string<'de, D>(deserializer: D) -> Result<String, D::Error>
where
D: Deserializer<'de>,
{
use serde::de::{self, Visitor};
struct StringOrNumberVisitor;
impl<'de> Visitor<'de> for StringOrNumberVisitor {
type Value = String;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a string, number, or boolean")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(value.to_string())
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(value.to_string())
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(value.to_string())
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(if value { "1" } else { "0" }.to_string())
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok("0".to_string())
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok("0".to_string())
}
}
deserializer.deserialize_any(StringOrNumberVisitor)
}
pub fn deserialize_opt_number_or_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
where
D: Deserializer<'de>,
{
use serde::de::{self, Visitor};
struct OptStringOrNumberVisitor;
impl<'de> Visitor<'de> for OptStringOrNumberVisitor {
type Value = Option<String>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a string, number, boolean, or null")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
if value.is_empty() {
Ok(None)
} else {
Ok(Some(value.to_string()))
}
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(value.to_string()))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(value.to_string()))
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(if value { "1" } else { "0" }.to_string()))
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
}
deserializer.deserialize_any(OptStringOrNumberVisitor)
}
pub fn serialize_opt_string<S>(value: &Option<String>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.serialize_str(v),
None => serializer.serialize_none(),
}
}
pub(crate) fn value_to_number<T>(value: Value) -> Result<T, String>
where
T: FromStr + TryFrom<u64> + TryFrom<i64>,
<T as FromStr>::Err: Display,
<T as TryFrom<u64>>::Error: Display,
<T as TryFrom<i64>>::Error: Display,
{
match value {
Value::String(s) => {
s.parse::<T>().map_err(|e| format!("无效的字符串 '{s}': {e}"))
}
Value::Number(num) => {
if let Some(n) = num.as_u64() {
T::try_from(n).map_err(|e| format!("数字 {n} 超出目标范围: {e}"))
} else if let Some(n) = num.as_i64() {
T::try_from(n).map_err(|e| format!("数字 {n} 超出目标范围: {e}"))
} else {
Err(format!("无效的数字 {num}"))
}
}
_ => Err("期望一个字符串或数字".to_string()),
}
}
struct NumVisitor<T>(std::marker::PhantomData<T>);
impl<'de, T> de::Visitor<'de> for NumVisitor<T>
where
T: FromStr + TryFrom<u64> + TryFrom<i64>,
<T as FromStr>::Err: Display,
<T as TryFrom<u64>>::Error: Display,
<T as TryFrom<i64>>::Error: Display,
{
type Value = T;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("an integer or a numeric string")
}
fn visit_str<E>(self, v: &str) -> Result<T, E>
where
E: de::Error,
{
v.parse::<T>()
.map_err(|e| E::custom(format!("无效的字符串 '{v}': {e}")))
}
fn visit_u64<E>(self, v: u64) -> Result<T, E>
where
E: de::Error,
{
T::try_from(v).map_err(|e| E::custom(format!("数字 {v} 超出目标范围: {e}")))
}
fn visit_i64<E>(self, v: i64) -> Result<T, E>
where
E: de::Error,
{
T::try_from(v).map_err(|e| E::custom(format!("数字 {v} 超出目标范围: {e}")))
}
fn visit_f64<E>(self, v: f64) -> Result<T, E>
where
E: de::Error,
{
Err(E::custom(format!("无效的数字 {v}")))
}
fn visit_bool<E>(self, _v: bool) -> Result<T, E>
where
E: de::Error,
{
Err(E::custom("期望一个字符串或数字"))
}
fn visit_unit<E>(self) -> Result<T, E>
where
E: de::Error,
{
Err(E::custom("期望一个字符串或数字"))
}
}
macro_rules! impl_string_or_number_to_num {
($ty:ty, $deser:ident, $opt_deser:ident) => {
pub fn $deser<'de, D>(deserializer: D) -> Result<$ty, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_any(NumVisitor::<$ty>(std::marker::PhantomData))
}
pub fn $opt_deser<'de, D>(deserializer: D) -> Result<Option<$ty>, D::Error>
where
D: Deserializer<'de>,
{
struct OptNumVisitor;
impl<'de> de::Visitor<'de> for OptNumVisitor {
type Value = Option<$ty>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("an integer, a numeric string, or null")
}
fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>
where
D2: Deserializer<'de>,
{
deserializer
.deserialize_any(NumVisitor::<$ty>(std::marker::PhantomData))
.map(Some)
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
}
deserializer.deserialize_option(OptNumVisitor)
}
};
($ty:ty, $deser:ident) => {
pub fn $deser<'de, D>(deserializer: D) -> Result<$ty, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_any(NumVisitor::<$ty>(std::marker::PhantomData))
}
};
}
impl_string_or_number_to_num!(
i8,
deserialize_string_or_number_to_i8,
deserialize_opt_string_or_number_to_i8
);
impl_string_or_number_to_num!(
u8,
deserialize_string_or_number_to_u8,
deserialize_opt_string_or_number_to_u8
);
impl_string_or_number_to_num!(
i16,
deserialize_string_or_number_to_i16,
deserialize_opt_string_or_number_to_i16
);
impl_string_or_number_to_num!(
u16,
deserialize_string_or_number_to_u16,
deserialize_opt_string_or_number_to_u16
);
impl_string_or_number_to_num!(
i32,
deserialize_string_or_number_to_i32,
deserialize_opt_string_or_number_to_i32
);
impl_string_or_number_to_num!(
u32,
deserialize_string_or_number_to_u32,
deserialize_opt_string_or_number_to_u32
);
impl_string_or_number_to_num!(
i64,
deserialize_string_or_number_to_i64,
deserialize_opt_string_or_number_to_i64
);
impl_string_or_number_to_num!(u64, deserialize_string_or_number_to_u64);
macro_rules! impl_num_as_string {
($ty:ty, $ser:ident, $opt_ser:ident) => {
pub fn $ser<S>(value: &$ty, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(value)
}
pub fn $opt_ser<S>(value: &Option<$ty>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.collect_str(v),
None => serializer.serialize_none(),
}
}
};
}
impl_num_as_string!(i8, serialize_i8_as_string, serialize_opt_i8_as_string);
impl_num_as_string!(u8, serialize_u8_as_string, serialize_opt_u8_as_string);
impl_num_as_string!(i16, serialize_i16_as_string, serialize_opt_i16_as_string);
impl_num_as_string!(u16, serialize_u16_as_string, serialize_opt_u16_as_string);
impl_num_as_string!(i32, serialize_i32_as_string, serialize_opt_i32_as_string);
impl_num_as_string!(u32, serialize_u32_as_string, serialize_opt_u32_as_string);
impl_num_as_string!(i64, serialize_i64_as_string, serialize_opt_i64_as_string);
impl_num_as_string!(u64, serialize_u64_as_string, serialize_opt_u64_as_string);
macro_rules! impl_num_vec_as_string {
($ty:ty, $vec_ser:ident) => {
pub fn $vec_ser<S>(value: &Vec<$ty>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
use serde::ser::SerializeSeq;
let mut seq = serializer.serialize_seq(Some(value.len()))?;
for element in value {
seq.serialize_element(&element.to_string())?;
}
seq.end()
}
};
}
impl_num_vec_as_string!(i8, serialize_vec_i8_as_string);
impl_num_vec_as_string!(u8, serialize_vec_u8_as_string);
impl_num_vec_as_string!(i16, serialize_vec_i16_as_string);
impl_num_vec_as_string!(u16, serialize_vec_u16_as_string);
impl_num_vec_as_string!(i32, serialize_vec_i32_as_string);
impl_num_vec_as_string!(u32, serialize_vec_u32_as_string);
impl_num_vec_as_string!(i64, serialize_vec_i64_as_string);
impl_num_vec_as_string!(u64, serialize_vec_u64_as_string);
pub fn deserialize_opt_string_or_number_to_u64<'de, D>(
deserializer: D,
) -> Result<Option<u64>, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_option(OptU64Visitor)
}
struct OptU64Visitor;
impl<'de> serde::de::Visitor<'de> for OptU64Visitor {
type Value = Option<u64>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a u64 number, string, null, or missing field")
}
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_any(U64OptionValueVisitor)
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(None)
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(None)
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(Some(value))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value >= 0 {
Ok(Some(value as u64))
} else {
Err(serde::de::Error::custom(format!(
"负数不能转换为 u64: {}",
value
)))
}
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value.is_empty() {
Ok(None)
} else {
Ok(value.parse::<u64>().map(Some).unwrap_or(None))
}
}
}
struct U64OptionValueVisitor;
impl<'de> serde::de::Visitor<'de> for U64OptionValueVisitor {
type Value = Option<u64>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a u64 number or string")
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(Some(value))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value >= 0 {
Ok(Some(value as u64))
} else {
Err(serde::de::Error::custom(format!(
"负数不能转换为 u64: {}",
value
)))
}
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value.is_empty() {
Ok(None)
} else {
Ok(value.parse::<u64>().map(Some).unwrap_or(None))
}
}
}
macro_rules! impl_vec_string_or_number_to_num {
($ty:ty, $deser:ident, $opt_deser:ident) => {
pub fn $deser<'de, D>(deserializer: D) -> Result<Vec<$ty>, D::Error>
where
D: Deserializer<'de>,
{
let values: Vec<Value> = Vec::deserialize(deserializer)?;
values
.into_iter()
.map(|v| value_to_number::<$ty>(v).map_err(de::Error::custom))
.collect()
}
pub fn $opt_deser<'de, D>(deserializer: D) -> Result<Option<Vec<$ty>>, D::Error>
where
D: Deserializer<'de>,
{
let opt_value: Option<Vec<Value>> = Option::deserialize(deserializer)?;
match opt_value {
None => Ok(None),
Some(values) => {
let result: Result<Vec<$ty>, _> = values
.into_iter()
.map(|v| match v {
Value::Null => Ok(Default::default()), other => value_to_number::<$ty>(other).map_err(de::Error::custom),
})
.collect();
result.map(Some)
}
}
}
};
}
impl_vec_string_or_number_to_num!(
i64,
deserialize_vec_string_or_number_to_i64,
deserialize_opt_vec_string_or_number_to_i64
);
impl_vec_string_or_number_to_num!(
u64,
deserialize_vec_string_or_number_to_u64,
deserialize_opt_vec_string_or_number_to_u64
);
pub fn deserialize_string_to_naive_datetime<'de, D>(
deserializer: D,
) -> Result<chrono::NaiveDateTime, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%dT%H:%M:%S") {
return Ok(dt);
}
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S") {
return Ok(dt);
}
if let Ok(date) = chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d") {
return Ok(date.and_hms_opt(0, 0, 0).unwrap());
}
Err(de::Error::custom(format!(
"无效的日期时间格式: '{}'. 支持的格式: '2026-04-09T00:00:00' 或 '2026-04-09 00:00:00'",
s
)))
}
pub fn deserialize_opt_string_to_naive_datetime<'de, D>(
deserializer: D,
) -> Result<Option<chrono::NaiveDateTime>, D::Error>
where
D: Deserializer<'de>,
{
let opt_s: Option<String> = Option::deserialize(deserializer)?;
match opt_s {
None => Ok(None),
Some(s) => {
if s.is_empty() {
return Ok(None);
}
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%dT%H:%M:%S") {
return Ok(Some(dt));
}
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S") {
return Ok(Some(dt));
}
if let Ok(date) = chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d") {
return Ok(Some(date.and_hms_opt(0, 0, 0).unwrap()));
}
Err(de::Error::custom(format!(
"无效的日期时间格式: '{}'. 支持的格式: '2026-04-09T00:00:00' 或 '2026-04-09 00:00:00'",
s
)))
}
}
}
struct F64Visitor;
impl<'de> de::Visitor<'de> for F64Visitor {
type Value = f64;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a number or a numeric string")
}
fn visit_f64<E>(self, v: f64) -> Result<f64, E>
where
E: de::Error,
{
Ok(v)
}
fn visit_i64<E>(self, v: i64) -> Result<f64, E>
where
E: de::Error,
{
Ok(v as f64)
}
fn visit_u64<E>(self, v: u64) -> Result<f64, E>
where
E: de::Error,
{
Ok(v as f64)
}
fn visit_str<E>(self, v: &str) -> Result<f64, E>
where
E: de::Error,
{
v.parse::<f64>()
.map_err(|e| E::custom(format!("无效的浮点字符串 '{v}': {e}")))
}
fn visit_bool<E>(self, _v: bool) -> Result<f64, E>
where
E: de::Error,
{
Err(E::custom("期望一个字符串或数字"))
}
fn visit_unit<E>(self) -> Result<f64, E>
where
E: de::Error,
{
Err(E::custom("期望一个字符串或数字"))
}
}
pub fn deserialize_string_or_number_to_f64<'de, D>(
deserializer: D,
) -> Result<f64, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_any(F64Visitor)
}
pub fn deserialize_opt_string_or_number_to_f64<'de, D>(
deserializer: D,
) -> Result<Option<f64>, D::Error>
where
D: Deserializer<'de>,
{
struct OptF64Visitor;
impl<'de> de::Visitor<'de> for OptF64Visitor {
type Value = Option<f64>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a number, a numeric string, or null")
}
fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>
where
D2: Deserializer<'de>,
{
deserializer.deserialize_any(OptF64Inner)
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
}
struct OptF64Inner;
impl<'de> de::Visitor<'de> for OptF64Inner {
type Value = Option<f64>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a number, a numeric string, or null")
}
fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(v))
}
fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(v as f64))
}
fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(v as f64))
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
if v.is_empty() {
return Ok(None);
}
v.parse::<f64>()
.map(Some)
.map_err(|e| E::custom(format!("无效的浮点字符串 '{v}': {e}")))
}
fn visit_bool<E>(self, _v: bool) -> Result<Self::Value, E>
where
E: de::Error,
{
Err(E::custom("期望一个字符串、数字或 null"))
}
}
deserializer.deserialize_option(OptF64Visitor)
}
const BOOL_ERR: &str = "无法解析为 bool,支持: true/false, 1/0, yes/no";
fn parse_bool_str(s: &str) -> Option<bool> {
if s.eq_ignore_ascii_case("true") || s == "1" || s.eq_ignore_ascii_case("yes") {
Some(true)
} else if s.eq_ignore_ascii_case("false") || s == "0" || s.eq_ignore_ascii_case("no") {
Some(false)
} else {
None
}
}
struct BoolVisitor;
impl<'de> de::Visitor<'de> for BoolVisitor {
type Value = bool;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a boolean, 0/1, or a boolean string")
}
fn visit_bool<E>(self, v: bool) -> Result<bool, E>
where
E: de::Error,
{
Ok(v)
}
fn visit_u64<E>(self, v: u64) -> Result<bool, E>
where
E: de::Error,
{
match v {
1 => Ok(true),
0 => Ok(false),
_ => Err(E::custom(BOOL_ERR)),
}
}
fn visit_i64<E>(self, v: i64) -> Result<bool, E>
where
E: de::Error,
{
match v {
1 => Ok(true),
0 => Ok(false),
_ => Err(E::custom(BOOL_ERR)),
}
}
fn visit_str<E>(self, v: &str) -> Result<bool, E>
where
E: de::Error,
{
parse_bool_str(v).ok_or_else(|| E::custom(BOOL_ERR))
}
}
pub fn deserialize_string_or_number_to_bool<'de, D>(
deserializer: D,
) -> Result<bool, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_any(BoolVisitor)
}
pub fn deserialize_opt_string_or_number_to_bool<'de, D>(
deserializer: D,
) -> Result<Option<bool>, D::Error>
where
D: Deserializer<'de>,
{
struct OptBoolVisitor;
impl<'de> de::Visitor<'de> for OptBoolVisitor {
type Value = Option<bool>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a boolean, 0/1, a boolean string, or null")
}
fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>
where
D2: Deserializer<'de>,
{
deserializer.deserialize_any(BoolVisitor).map(Some)
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
}
deserializer.deserialize_option(OptBoolVisitor)
}
pub fn deserialize_comma_separated_string<'de, D>(
deserializer: D,
) -> Result<Vec<String>, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Ok(parse_comma_separated(&s))
}
pub fn deserialize_opt_comma_separated_string<'de, D>(
deserializer: D,
) -> Result<Option<Vec<String>>, D::Error>
where
D: Deserializer<'de>,
{
let opt_s: Option<String> = Option::deserialize(deserializer)?;
match opt_s {
None => Ok(None),
Some(s) if s.trim().is_empty() => Ok(None),
Some(s) => Ok(Some(parse_comma_separated(&s))),
}
}
fn parse_comma_separated(s: &str) -> Vec<String> {
s.split(',')
.map(|item| item.trim().to_string())
.filter(|item| !item.is_empty())
.collect()
}
pub fn serialize_vec_string_as_comma_separated<S>(
value: &[String],
serializer: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&value.join(","))
}
pub fn serialize_opt_vec_string_as_comma_separated<S>(
value: &Option<Vec<String>>,
serializer: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.serialize_str(&v.join(",")),
None => serializer.serialize_none(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde::Deserialize;
#[derive(Deserialize)]
struct TestF64 {
#[serde(deserialize_with = "deserialize_string_or_number_to_f64")]
value: f64,
}
#[derive(Deserialize)]
struct TestOptF64 {
#[serde(
default,
deserialize_with = "deserialize_opt_string_or_number_to_f64"
)]
value: Option<f64>,
}
#[derive(Deserialize)]
struct TestBool {
#[serde(deserialize_with = "deserialize_string_or_number_to_bool")]
value: bool,
}
#[derive(Deserialize)]
struct TestOptBool {
#[serde(
default,
deserialize_with = "deserialize_opt_string_or_number_to_bool"
)]
value: Option<bool>,
}
#[derive(Deserialize)]
struct TestCommaSeparated {
#[serde(deserialize_with = "deserialize_comma_separated_string")]
value: Vec<String>,
}
#[derive(Deserialize)]
struct TestOptCommaSeparated {
#[serde(
default,
deserialize_with = "deserialize_opt_comma_separated_string"
)]
value: Option<Vec<String>>,
}
#[test]
fn test_f64_from_number() {
let json = r#"{"value": 3.25}"#;
let result: TestF64 = serde_json::from_str(json).unwrap();
assert!((result.value - 3.25).abs() < f64::EPSILON);
}
#[test]
fn test_f64_from_string() {
let json = r#"{"value": "3.25"}"#;
let result: TestF64 = serde_json::from_str(json).unwrap();
assert!((result.value - 3.25).abs() < f64::EPSILON);
}
#[test]
fn test_opt_f64_none() {
let json = r#"{}"#;
let result: TestOptF64 = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_opt_f64_some() {
let json = r#"{"value": "2.75"}"#;
let result: TestOptF64 = serde_json::from_str(json).unwrap();
assert!((result.value.unwrap() - 2.75).abs() < f64::EPSILON);
}
#[test]
fn test_bool_from_true() {
let json = r#"{"value": true}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_string_true() {
let json = r#"{"value": "true"}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_number_1() {
let json = r#"{"value": 1}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_string_yes() {
let json = r#"{"value": "yes"}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_string_false() {
let json = r#"{"value": "false"}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(!result.value);
}
#[test]
fn test_bool_from_number_0() {
let json = r#"{"value": 0}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(!result.value);
}
#[test]
fn test_opt_bool_none() {
let json = r#"{}"#;
let result: TestOptBool = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_comma_separated() {
let json = r#"{"value": "a,b,c"}"#;
let result: TestCommaSeparated = serde_json::from_str(json).unwrap();
assert_eq!(result.value, vec!["a", "b", "c"]);
}
#[test]
fn test_comma_separated_with_spaces() {
let json = r#"{"value": "a, b , c"}"#;
let result: TestCommaSeparated = serde_json::from_str(json).unwrap();
assert_eq!(result.value, vec!["a", "b", "c"]);
}
#[test]
fn test_opt_comma_separated_none() {
let json = r#"{}"#;
let result: TestOptCommaSeparated = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_opt_comma_separated_empty() {
let json = r#"{"value": ""}"#;
let result: TestOptCommaSeparated = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_opt_comma_separated_some() {
let json = r#"{"value": "x,y,z"}"#;
let result: TestOptCommaSeparated = serde_json::from_str(json).unwrap();
assert_eq!(result.value.unwrap(), vec!["x", "y", "z"]);
}
}
#[cfg(test)]
mod extra_tests {
use super::*;
use serde::{Deserialize, Serialize};
#[derive(Deserialize)]
struct NS {
#[serde(deserialize_with = "deserialize_number_or_string")]
v: String,
}
#[derive(Deserialize)]
struct Ons {
#[serde(default, deserialize_with = "deserialize_opt_number_or_string")]
v: Option<String>,
}
#[test]
fn number_or_string_all_forms() {
let get = |j: &str| serde_json::from_str::<NS>(j).unwrap().v;
assert_eq!(get(r#"{"v":"42"}"#), "42");
assert_eq!(get(r#"{"v":7}"#), "7");
assert_eq!(get(r#"{"v":-3}"#), "-3");
assert_eq!(get(r#"{"v":true}"#), "1");
assert_eq!(get(r#"{"v":false}"#), "0");
assert_eq!(get(r#"{"v":null}"#), "0"); }
#[test]
fn opt_number_or_string_all_forms() {
let get = |j: &str| serde_json::from_str::<Ons>(j).unwrap().v;
assert_eq!(get(r#"{"v":""}"#), None);
assert_eq!(get(r#"{"v":"x"}"#), Some("x".into()));
assert_eq!(get(r#"{"v":5}"#), Some("5".into()));
assert_eq!(get(r#"{"v":-5}"#), Some("-5".into()));
assert_eq!(get(r#"{"v":true}"#), Some("1".into()));
assert_eq!(get(r#"{"v":null}"#), None);
assert_eq!(get(r#"{}"#), None); }
#[derive(Serialize)]
struct OptStr {
#[serde(serialize_with = "serialize_opt_string")]
a: Option<String>,
#[serde(serialize_with = "serialize_opt_string")]
b: Option<String>,
}
#[test]
fn serialize_opt_string_both_branches() {
let j = serde_json::to_string(&OptStr {
a: Some("s".into()),
b: None,
})
.unwrap();
assert_eq!(j, r#"{"a":"s","b":null}"#);
}
#[derive(Deserialize)]
struct Ints {
#[serde(deserialize_with = "deserialize_string_or_number_to_i8")]
a: i8,
#[serde(deserialize_with = "deserialize_string_or_number_to_u8")]
b: u8,
#[serde(deserialize_with = "deserialize_string_or_number_to_i16")]
c: i16,
#[serde(deserialize_with = "deserialize_string_or_number_to_u16")]
d: u16,
#[serde(deserialize_with = "deserialize_string_or_number_to_i32")]
e: i32,
#[serde(deserialize_with = "deserialize_string_or_number_to_u32")]
f: u32,
#[serde(deserialize_with = "deserialize_string_or_number_to_i64")]
g: i64,
#[serde(deserialize_with = "deserialize_string_or_number_to_u64")]
h: u64,
}
#[test]
fn ints_from_numbers_and_strings() {
let v: Ints = serde_json::from_str(
r#"{"a":"-8","b":"8","c":"-16","d":"16","e":"-32","f":"32","g":"-64","h":"64"}"#,
)
.unwrap();
assert_eq!((v.a, v.b, v.c, v.d, v.e, v.f, v.g, v.h), (-8, 8, -16, 16, -32, 32, -64, 64));
let v: Ints = serde_json::from_str(r#"{"a":-1,"b":2,"c":-3,"d":4,"e":-5,"f":6,"g":-7,"h":8}"#).unwrap();
assert_eq!((v.a, v.b, v.c, v.d, v.e, v.f, v.g, v.h), (-1, 2, -3, 4, -5, 6, -7, 8));
}
#[derive(Deserialize)]
struct U8Only {
#[allow(dead_code)]
#[serde(deserialize_with = "deserialize_string_or_number_to_u8")]
v: u8,
}
#[test]
fn int_reject_invalid_inputs() {
assert!(serde_json::from_str::<U8Only>(r#"{"v":"abc"}"#).is_err()); assert!(serde_json::from_str::<U8Only>(r#"{"v":300}"#).is_err()); assert!(serde_json::from_str::<U8Only>(r#"{"v":-1}"#).is_err()); assert!(serde_json::from_str::<U8Only>(r#"{"v":1.5}"#).is_err()); assert!(serde_json::from_str::<U8Only>(r#"{"v":true}"#).is_err()); assert!(serde_json::from_str::<U8Only>(r#"{"v":null}"#).is_err()); }
#[derive(Deserialize)]
struct OptInts {
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_i8")]
a: Option<i8>,
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_u8")]
b: Option<u8>,
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_i16")]
c: Option<i16>,
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_u16")]
d: Option<u16>,
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_i32")]
e: Option<i32>,
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_u32")]
f: Option<u32>,
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_i64")]
g: Option<i64>,
}
#[test]
fn opt_ints_null_and_values() {
let v: OptInts =
serde_json::from_str(r#"{"a":null,"b":null,"c":null,"d":null,"e":null,"f":null,"g":null}"#)
.unwrap();
assert_eq!(
(v.a, v.b, v.c, v.d, v.e, v.f, v.g),
(None, None, None, None, None, None, None)
);
let v: OptInts =
serde_json::from_str(r#"{"a":"1","b":2,"c":"3","d":4,"e":"5","f":6,"g":"7"}"#).unwrap();
assert_eq!(
(v.a, v.b, v.c, v.d, v.e, v.f, v.g),
(Some(1), Some(2), Some(3), Some(4), Some(5), Some(6), Some(7))
);
let v: OptInts = serde_json::from_str(r#"{}"#).unwrap(); assert_eq!(v.a, None);
}
#[derive(Deserialize)]
struct OptU64 {
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_u64")]
v: Option<u64>,
}
#[test]
fn opt_u64_special_cases() {
assert_eq!(serde_json::from_str::<OptU64>(r#"{"v":"123"}"#).unwrap().v, Some(123));
assert_eq!(serde_json::from_str::<OptU64>(r#"{"v":"tmp-abc"}"#).unwrap().v, None);
assert_eq!(serde_json::from_str::<OptU64>(r#"{"v":""}"#).unwrap().v, None);
assert_eq!(serde_json::from_str::<OptU64>(r#"{"v":42}"#).unwrap().v, Some(42));
assert_eq!(serde_json::from_str::<OptU64>(r#"{"v":null}"#).unwrap().v, None);
assert_eq!(serde_json::from_str::<OptU64>(r#"{}"#).unwrap().v, None);
assert!(serde_json::from_str::<OptU64>(r#"{"v":-5}"#).is_err()); }
#[derive(Serialize)]
struct SerAll {
#[serde(serialize_with = "serialize_i8_as_string")]
a: i8,
#[serde(serialize_with = "serialize_u8_as_string")]
b: u8,
#[serde(serialize_with = "serialize_i16_as_string")]
c: i16,
#[serde(serialize_with = "serialize_u16_as_string")]
d: u16,
#[serde(serialize_with = "serialize_i32_as_string")]
e: i32,
#[serde(serialize_with = "serialize_u32_as_string")]
f: u32,
#[serde(serialize_with = "serialize_i64_as_string")]
g: i64,
#[serde(serialize_with = "serialize_u64_as_string")]
h: u64,
#[serde(serialize_with = "serialize_opt_i8_as_string")]
o1: Option<i8>,
#[serde(serialize_with = "serialize_opt_u8_as_string")]
o2: Option<u8>,
#[serde(serialize_with = "serialize_opt_i16_as_string")]
o3: Option<i16>,
#[serde(serialize_with = "serialize_opt_u16_as_string")]
o4: Option<u16>,
#[serde(serialize_with = "serialize_opt_i32_as_string")]
o5: Option<i32>,
#[serde(serialize_with = "serialize_opt_u32_as_string")]
o6: Option<u32>,
#[serde(serialize_with = "serialize_opt_i64_as_string")]
o7: Option<i64>,
#[serde(serialize_with = "serialize_opt_u64_as_string")]
o8: Option<u64>,
}
#[test]
fn serialize_ints_as_string_all_types() {
let big: u64 = 9007199254740993;
let j = serde_json::to_string(&SerAll {
a: -1,
b: 2,
c: -3,
d: 4,
e: -5,
f: 6,
g: -7,
h: big,
o1: Some(-1),
o2: None,
o3: Some(-3),
o4: None,
o5: Some(-5),
o6: None,
o7: Some(-7),
o8: None,
})
.unwrap();
assert!(j.contains(r#""h":"9007199254740993""#)); assert!(j.contains(r#""a":"-1""#));
assert!(j.contains(r#""o2":null"#));
assert!(j.contains(r#""o7":"-7""#));
}
#[derive(Serialize)]
struct SerVecAll {
#[serde(serialize_with = "serialize_vec_i8_as_string")]
a: Vec<i8>,
#[serde(serialize_with = "serialize_vec_u64_as_string")]
b: Vec<u64>,
}
#[test]
fn serialize_vec_ints_as_string() {
let j = serde_json::to_string(&SerVecAll {
a: vec![1, -2],
b: vec![3, 4],
})
.unwrap();
assert_eq!(j, r#"{"a":["1","-2"],"b":["3","4"]}"#);
}
#[derive(Deserialize)]
struct VecNums {
#[serde(deserialize_with = "deserialize_vec_string_or_number_to_i64")]
a: Vec<i64>,
#[serde(deserialize_with = "deserialize_vec_string_or_number_to_u64")]
b: Vec<u64>,
#[serde(default, deserialize_with = "deserialize_opt_vec_string_or_number_to_i64")]
c: Option<Vec<i64>>,
#[serde(default, deserialize_with = "deserialize_opt_vec_string_or_number_to_u64")]
d: Option<Vec<u64>>,
}
#[test]
fn vec_string_or_number_mixed() {
let v: VecNums = serde_json::from_str(
r#"{"a":[1,"2",-3],"b":["4",5],"c":null,"d":["6"]}"#,
)
.unwrap();
assert_eq!(v.a, vec![1, 2, -3]);
assert_eq!(v.b, vec![4, 5]);
assert_eq!(v.c, None);
assert_eq!(v.d, Some(vec![6]));
assert!(serde_json::from_str::<VecNums>(r#"{"a":["x"],"b":[]}"#).is_err());
let v: VecNums = serde_json::from_str(r#"{"a":[],"b":[]}"#).unwrap();
assert!(v.a.is_empty());
assert_eq!(v.c, None);
}
#[test]
fn value_to_number_branches() {
assert_eq!(value_to_number::<i64>(Value::String("5".into())).unwrap(), 5);
assert!(value_to_number::<i64>(Value::String("x".into())).is_err());
assert_eq!(value_to_number::<u8>(Value::from(7u64)).unwrap(), 7);
assert_eq!(value_to_number::<i64>(Value::from(-7i64)).unwrap(), -7);
assert!(value_to_number::<u8>(Value::from(300u64)).is_err()); assert!(value_to_number::<i64>(Value::from(1.5f64)).is_err()); assert!(value_to_number::<i64>(Value::Bool(true)).is_err()); }
#[derive(Deserialize)]
struct Dt {
#[serde(deserialize_with = "deserialize_string_to_naive_datetime")]
v: chrono::NaiveDateTime,
}
#[derive(Deserialize)]
struct OptDt {
#[serde(default, deserialize_with = "deserialize_opt_string_to_naive_datetime")]
v: Option<chrono::NaiveDateTime>,
}
#[test]
fn naive_datetime_formats() {
let d = serde_json::from_str::<Dt>(r#"{"v":"2026-04-09T10:20:30"}"#)
.unwrap()
.v;
assert_eq!(d.to_string(), "2026-04-09 10:20:30");
let d = serde_json::from_str::<Dt>(r#"{"v":"2026-04-09 10:20:30"}"#)
.unwrap()
.v;
assert_eq!(d.to_string(), "2026-04-09 10:20:30");
let d = serde_json::from_str::<Dt>(r#"{"v":"2026-04-09"}"#)
.unwrap()
.v;
assert_eq!(d.to_string(), "2026-04-09 00:00:00");
assert!(serde_json::from_str::<Dt>(r#"{"v":"bad"}"#).is_err());
}
#[test]
fn opt_naive_datetime_formats() {
assert_eq!(
serde_json::from_str::<OptDt>(r#"{}"#).unwrap().v,
None
);
assert_eq!(
serde_json::from_str::<OptDt>(r#"{"v":null}"#).unwrap().v,
None
);
assert_eq!(
serde_json::from_str::<OptDt>(r#"{"v":""}"#).unwrap().v,
None
);
assert!(serde_json::from_str::<OptDt>(r#"{"v":"2026-04-09T10:20:30"}"#)
.unwrap()
.v
.is_some());
assert!(serde_json::from_str::<OptDt>(r#"{"v":"2026-04-09 10:20:30"}"#)
.unwrap()
.v
.is_some());
assert!(serde_json::from_str::<OptDt>(r#"{"v":"2026-04-09"}"#)
.unwrap()
.v
.is_some());
assert!(serde_json::from_str::<OptDt>(r#"{"v":"nope"}"#).is_err());
}
#[derive(Deserialize)]
struct F64e {
#[serde(deserialize_with = "deserialize_string_or_number_to_f64")]
v: f64,
}
#[test]
fn f64_error_branches() {
assert!(serde_json::from_str::<F64e>(r#"{"v":"abc"}"#).is_err());
assert!(serde_json::from_str::<F64e>(r#"{"v":true}"#).is_err());
assert!(serde_json::from_str::<F64e>(r#"{"v":null}"#).is_err());
assert!((serde_json::from_str::<F64e>(r#"{"v":-1}"#).unwrap().v + 1.0).abs() < f64::EPSILON);
}
#[derive(Deserialize)]
struct BoolE {
#[serde(deserialize_with = "deserialize_string_or_number_to_bool")]
v: bool,
}
#[test]
fn bool_error_and_alias_forms() {
assert!(serde_json::from_str::<BoolE>(r#"{"v":2}"#).is_err()); assert!(serde_json::from_str::<BoolE>(r#"{"v":"maybe"}"#).is_err());
assert!(!serde_json::from_str::<BoolE>(r#"{"v":"NO"}"#).unwrap().v); assert!(serde_json::from_str::<BoolE>(r#"{"v":"Yes"}"#).unwrap().v);
assert!(serde_json::from_str::<BoolE>(r#"{"v":"TRUE"}"#).unwrap().v);
assert!(!serde_json::from_str::<BoolE>(r#"{"v":"FALSE"}"#).unwrap().v);
assert!(!serde_json::from_str::<BoolE>(r#"{"v":0}"#).unwrap().v);
#[derive(Deserialize)]
struct OptBoolE {
#[serde(default, deserialize_with = "deserialize_opt_string_or_number_to_bool")]
v: Option<bool>,
}
assert_eq!(serde_json::from_str::<OptBoolE>(r#"{"v":null}"#).unwrap().v, None);
assert_eq!(serde_json::from_str::<OptBoolE>(r#"{"v":0}"#).unwrap().v, Some(false));
assert!(serde_json::from_str::<OptBoolE>(r#"{"v":7}"#).is_err());
}
#[derive(Serialize)]
struct CommaSer {
#[serde(serialize_with = "serialize_vec_string_as_comma_separated")]
a: Vec<String>,
#[serde(serialize_with = "serialize_opt_vec_string_as_comma_separated")]
b: Option<Vec<String>>,
#[serde(serialize_with = "serialize_opt_vec_string_as_comma_separated")]
c: Option<Vec<String>>,
}
#[test]
fn comma_separated_serialize() {
let j = serde_json::to_string(&CommaSer {
a: vec!["x".into(), "y".into()],
b: Some(vec!["p".into()]),
c: None,
})
.unwrap();
assert_eq!(j, r#"{"a":"x,y","b":"p","c":null}"#);
}
}