#![allow(dead_code)]
use serde::{
de::{DeserializeOwned, Error as _},
ser::Error as _,
Deserialize, Deserializer, Serialize, Serializer,
};
use serde_json::{Map, Value};
pub(crate) fn internally_tagged<S: Serializer, T: Serialize>(
serializer: S,
field: &str,
tag: &str,
value: &T,
) -> Result<S::Ok, S::Error> {
match serde_json::to_value(value).map_err(S::Error::custom)? {
Value::Object(mut object) => {
object.insert(field.to_owned(), tag.into());
object.serialize(serializer)
}
_ => Err(S::Error::custom(format!(
"the `{tag}` variant is not a JSON object"
))),
}
}
pub(crate) fn adjacently_tagged<S: Serializer, T: Serialize>(
serializer: S,
field: &str,
tag: &str,
content: &str,
value: Option<&T>,
) -> Result<S::Ok, S::Error> {
let mut object = Map::new();
object.insert(field.to_owned(), tag.into());
if let Some(value) = value {
let value = serde_json::to_value(value).map_err(S::Error::custom)?;
object.insert(content.to_owned(), value);
}
object.serialize(serializer)
}
pub(crate) fn split_tag<'de, D: Deserializer<'de>>(
deserializer: D,
field: &str,
) -> Result<(String, Value), D::Error> {
let value = Value::deserialize(deserializer)?;
let tag = match value.get(field) {
Some(Value::String(tag)) => tag.clone(),
Some(_) => return Err(D::Error::custom(format!("`{field}` is not a string"))),
None => return Err(D::Error::custom(format!("missing field `{field}`"))),
};
Ok((tag, value))
}
pub(crate) fn from_value<T: DeserializeOwned, E: serde::de::Error>(value: Value) -> Result<T, E> {
serde_json::from_value(value).map_err(E::custom)
}
pub(crate) fn without(mut value: Value, field: &str) -> Value {
if let Value::Object(object) = &mut value {
object.remove(field);
}
value
}
pub(crate) fn take(value: &mut Value, field: &str) -> Value {
value.get_mut(field).map(Value::take).unwrap_or_default()
}
#[allow(clippy::option_option)]
pub(crate) fn nullable<'de, D, T>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
where
D: Deserializer<'de>,
T: Deserialize<'de>,
{
Option::<T>::deserialize(deserializer).map(Some)
}
pub(crate) fn json_type(value: &Value) -> &'static str {
match value {
Value::Null => "null",
Value::Bool(_) => "boolean",
Value::Number(number) if number.is_f64() => "number",
Value::Number(_) => "integer",
Value::String(text) if text.is_empty() => "empty",
Value::String(_) => "string",
Value::Array(_) => "array",
Value::Object(_) => "object",
}
}