use serde::de::DeserializeOwned;
use serde_json::{Number, Value};
pub fn decode_args<A: DeserializeOwned>(args: &Value) -> Result<A, serde_json::Error> {
crate::json_utils::from_value(args).or_else(|error| as_integers(args).unwrap_or(Err(error)))
}
pub(crate) fn decode_text<A: DeserializeOwned>(args: &str) -> Result<A, serde_json::Error> {
serde_json::from_str(args).or_else(|error| match serde_json::from_str::<Value>(args) {
Ok(value) => as_integers(&value).unwrap_or(Err(error)),
Err(_) => Err(error),
})
}
fn as_integers<A: DeserializeOwned>(args: &Value) -> Option<Result<A, serde_json::Error>> {
let mut whole = args.clone();
integers(&mut whole).then(|| crate::json_utils::from_value(&whole))
}
fn integers(value: &mut Value) -> bool {
match value {
Value::Number(number) if number.is_f64() => match whole(number) {
Some(Whole::Unsigned(unsigned)) => {
*number = unsigned.into();
true
}
Some(Whole::Signed(signed)) => {
*number = signed.into();
true
}
None => false,
},
Value::Array(items) => {
let mut any = false;
for item in items {
any |= integers(item);
}
any
}
Value::Object(fields) => {
let mut any = false;
for field in fields.values_mut() {
any |= integers(field);
}
any
}
_ => false,
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Whole {
Signed(i64),
Unsigned(u64),
}
pub(crate) fn whole(number: &Number) -> Option<Whole> {
if let Some(unsigned) = number.as_u64() {
return Some(Whole::Unsigned(unsigned));
}
if let Some(signed) = number.as_i64() {
return Some(Whole::Signed(signed));
}
let float = number.as_f64().filter(|float| float.fract() == 0.0)?;
if (0.0..18_446_744_073_709_551_616.0).contains(&float) {
Some(Whole::Unsigned(float as u64))
} else if (-9_223_372_036_854_775_808.0..0.0).contains(&float) {
Some(Whole::Signed(float as i64))
} else {
None
}
}
#[cfg(test)]
mod tests;