use std::collections::HashMap;
use std::fmt;
use serde::de::{self, Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
pub const MAX_SAFE_INTEGER: f64 = 9_007_199_254_740_991.0;
#[derive(Clone, Debug, PartialEq)]
pub enum Value {
Null,
Bool(bool),
Number(f64),
String(String),
Array(Vec<Value>),
Object(Vec<(String, Value)>),
}
impl Value {
pub fn get(&self, key: &str) -> Option<&Value> {
self.as_object()?
.iter()
.find(|(name, _)| name == key)
.map(|(_, value)| value)
}
pub fn as_str(&self) -> Option<&str> {
match self {
Value::String(text) => Some(text),
_ => None,
}
}
pub fn as_bool(&self) -> Option<bool> {
match self {
Value::Bool(flag) => Some(*flag),
_ => None,
}
}
pub fn as_f64(&self) -> Option<f64> {
match self {
Value::Number(number) => Some(*number),
_ => None,
}
}
pub fn as_array(&self) -> Option<&[Value]> {
match self {
Value::Array(items) => Some(items),
_ => None,
}
}
pub fn as_object(&self) -> Option<&[(String, Value)]> {
match self {
Value::Object(pairs) => Some(pairs),
_ => None,
}
}
pub fn type_name(&self) -> &'static str {
match self {
Value::Null => "null",
Value::Bool(_) => "boolean",
Value::Number(_) => "number",
Value::String(_) => "string",
Value::Array(_) => "array",
Value::Object(_) => "object",
}
}
pub fn json_equal(&self, other: &Value) -> bool {
self.canonical() == other.canonical()
}
pub fn canonical(&self) -> String {
match self {
Value::Array(items) => {
let parts: Vec<String> = items.iter().map(Value::canonical).collect();
format!("[{}]", parts.join(","))
}
Value::Object(pairs) => {
let mut sorted: Vec<&(String, Value)> = pairs.iter().collect();
sorted.sort_by(|left, right| left.0.cmp(&right.0));
let parts: Vec<String> = sorted
.iter()
.map(|(key, value)| {
format!("{}:{}", Value::String(key.clone()), value.canonical())
})
.collect();
format!("{{{}}}", parts.join(","))
}
other => other.to_string(),
}
}
}
fn shortest_digits(magnitude: f64) -> (Vec<u8>, i32) {
let text = format!("{magnitude:e}");
let (mantissa, exponent) = text.split_once('e').unwrap_or((&text, "0"));
let mut digits: Vec<u8> = mantissa.bytes().filter(u8::is_ascii_digit).collect();
let mut exponent: i32 = exponent.parse().unwrap_or(0);
let length = digits.len();
let probe = format!("{magnitude:.*e}", length + 25);
let exact: Vec<u8> = probe
.split_once('e')
.map_or(&probe[..], |(mantissa, _)| mantissa)
.bytes()
.filter(u8::is_ascii_digit)
.collect();
let is_tie = |exact: &[u8]| {
exact[length] == b'5' && exact[length + 1..].iter().all(|digit| *digit == b'0')
};
if exact.len() > length + 1 && is_tie(&exact) {
let full = format!("{magnitude:.800e}");
let full: Vec<u8> = full
.split_once('e')
.map_or(&full[..], |(mantissa, _)| mantissa)
.bytes()
.filter(u8::is_ascii_digit)
.collect();
if is_tie(&full) {
let mut lower = full[..length].to_vec();
let mut upper = lower.clone();
let mut carry = true;
for digit in upper.iter_mut().rev() {
if *digit == b'9' {
*digit = b'0';
} else {
*digit += 1;
carry = false;
break;
}
}
let mut upper_exponent = exponent;
if carry {
upper.insert(0, b'1');
upper.pop();
upper_exponent += 1;
}
let reads_back = |candidate: &[u8], exponent: i32| {
let text = format!(
"{}.{}e{exponent}",
char::from(candidate[0]),
String::from_utf8_lossy(&candidate[1..])
);
text.parse::<f64>() == Ok(magnitude)
};
let even_lower = lower
.last()
.is_some_and(|digit| (digit - b'0').is_multiple_of(2));
let (chosen, chosen_exponent) = if even_lower {
(&mut lower, exponent)
} else {
(&mut upper, upper_exponent)
};
if reads_back(chosen, chosen_exponent) {
digits = std::mem::take(chosen);
exponent = chosen_exponent;
}
}
}
while digits.len() > 1 && digits.last() == Some(&b'0') {
digits.pop();
}
(digits, exponent)
}
pub fn number_to_string(number: f64) -> String {
if number.is_nan() {
return "NaN".to_owned();
}
if number.is_infinite() {
return if number < 0.0 {
"-Infinity"
} else {
"Infinity"
}
.to_owned();
}
if number == 0.0 {
return "0".to_owned();
}
let (digits, exponent) = shortest_digits(number.abs());
let digits = String::from_utf8_lossy(&digits).into_owned();
let length = i32::try_from(digits.len()).unwrap_or(i32::MAX);
let point = exponent + 1;
let sign = if number < 0.0 { "-" } else { "" };
let body = if length <= point && point <= 21 {
format!(
"{digits}{}",
"0".repeat(usize::try_from(point - length).unwrap_or(0))
)
} else if 0 < point && point <= 21 {
let split = usize::try_from(point).unwrap_or(0);
format!("{}.{}", &digits[..split], &digits[split..])
} else if -6 < point && point <= 0 {
format!(
"0.{}{digits}",
"0".repeat(usize::try_from(-point).unwrap_or(0))
)
} else {
let sign_of_exponent = if point - 1 < 0 { "-" } else { "+" };
let power = (point - 1).abs();
if digits.len() == 1 {
format!("{digits}e{sign_of_exponent}{power}")
} else {
format!(
"{}.{}e{sign_of_exponent}{power}",
&digits[..1],
&digits[1..]
)
}
};
format!("{sign}{body}")
}
impl fmt::Display for Value {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Value::Null => formatter.write_str("null"),
Value::Bool(flag) => write!(formatter, "{flag}"),
Value::Number(number) => formatter.write_str(&number_to_string(*number)),
Value::String(text) => {
formatter.write_str(&serde_json::to_string(text).map_err(|_| fmt::Error)?)
}
Value::Array(items) => {
formatter.write_str("[")?;
for (position, item) in items.iter().enumerate() {
if position > 0 {
formatter.write_str(",")?;
}
write!(formatter, "{item}")?;
}
formatter.write_str("]")
}
Value::Object(pairs) => {
formatter.write_str("{")?;
for (position, (key, value)) in pairs.iter().enumerate() {
if position > 0 {
formatter.write_str(",")?;
}
formatter.write_str(&serde_json::to_string(key).map_err(|_| fmt::Error)?)?;
write!(formatter, ":{value}")?;
}
formatter.write_str("}")
}
}
}
}
struct ValueVisitor;
impl<'de> Visitor<'de> for ValueVisitor {
type Value = Value;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("any JSON value")
}
fn visit_unit<E: de::Error>(self) -> Result<Value, E> {
Ok(Value::Null)
}
fn visit_none<E: de::Error>(self) -> Result<Value, E> {
Ok(Value::Null)
}
fn visit_bool<E: de::Error>(self, flag: bool) -> Result<Value, E> {
Ok(Value::Bool(flag))
}
fn visit_i64<E: de::Error>(self, number: i64) -> Result<Value, E> {
Ok(Value::Number(number as f64))
}
fn visit_u64<E: de::Error>(self, number: u64) -> Result<Value, E> {
Ok(Value::Number(number as f64))
}
fn visit_f64<E: de::Error>(self, number: f64) -> Result<Value, E> {
if number.is_finite() {
Ok(Value::Number(number))
} else {
Err(E::custom("a JSON number must be finite"))
}
}
fn visit_str<E: de::Error>(self, text: &str) -> Result<Value, E> {
Ok(Value::String(text.to_owned()))
}
fn visit_string<E: de::Error>(self, text: String) -> Result<Value, E> {
Ok(Value::String(text))
}
fn visit_seq<A: SeqAccess<'de>>(self, mut sequence: A) -> Result<Value, A::Error> {
let mut items = Vec::new();
while let Some(item) = sequence.next_element::<Value>()? {
items.push(item);
}
Ok(Value::Array(items))
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Value, A::Error> {
let mut pairs: Vec<(String, Value)> = Vec::new();
let mut positions: HashMap<String, usize> = HashMap::new();
while let Some((key, value)) = map.next_entry::<String, Value>()? {
match positions.get(&key) {
Some(position) => pairs[*position].1 = value,
None => {
positions.insert(key.clone(), pairs.len());
pairs.push((key, value));
}
}
}
Ok(Value::Object(pairs))
}
}
impl<'de> Deserialize<'de> for Value {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Value, D::Error> {
deserializer.deserialize_any(ValueVisitor)
}
}
impl Serialize for Value {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Value::Null => serializer.serialize_unit(),
Value::Bool(flag) => serializer.serialize_bool(*flag),
Value::Number(number) => {
if number.fract() == 0.0 && number.abs() < MAX_SAFE_INTEGER {
serializer.serialize_i64(*number as i64)
} else {
serde_json::value::RawValue::from_string(number_to_string(*number))
.map_err(serde::ser::Error::custom)?
.serialize(serializer)
}
}
Value::String(text) => serializer.serialize_str(text),
Value::Array(items) => {
let mut sequence = serializer.serialize_seq(Some(items.len()))?;
for item in items {
sequence.serialize_element(item)?;
}
sequence.end()
}
Value::Object(pairs) => {
let mut map = serializer.serialize_map(Some(pairs.len()))?;
for (key, value) in pairs {
map.serialize_entry(key, value)?;
}
map.end()
}
}
}
}