use std::fmt;
#[derive(Clone, Debug, PartialEq)]
pub enum Json {
Null,
Bool(bool),
Int(i64),
Float(f64),
Str(String),
Array(Vec<Json>),
Object(Vec<(String, Json)>),
}
impl Json {
pub fn object() -> Json {
Json::Object(Vec::new())
}
pub fn array() -> Json {
Json::Array(Vec::new())
}
pub fn is_null(&self) -> bool {
matches!(self, Json::Null)
}
pub fn as_str(&self) -> Option<&str> {
match self {
Json::Str(s) => Some(s),
_ => None,
}
}
pub fn as_i64(&self) -> Option<i64> {
match self {
Json::Int(n) => Some(*n),
Json::Float(f) if f.fract() == 0.0 => Some(*f as i64),
_ => None,
}
}
pub fn as_f64(&self) -> Option<f64> {
match self {
Json::Int(n) => Some(*n as f64),
Json::Float(f) => Some(*f),
_ => None,
}
}
pub fn as_bool(&self) -> Option<bool> {
match self {
Json::Bool(b) => Some(*b),
_ => None,
}
}
pub fn as_array(&self) -> Option<&Vec<Json>> {
match self {
Json::Array(a) => Some(a),
_ => None,
}
}
pub fn as_object(&self) -> Option<&Vec<(String, Json)>> {
match self {
Json::Object(o) => Some(o),
_ => None,
}
}
pub fn get(&self, key: &str) -> Option<&Json> {
match self {
Json::Object(o) => o.iter().find(|(k, _)| k == key).map(|(_, v)| v),
_ => None,
}
}
pub fn contains_key(&self, key: &str) -> bool {
self.get(key).is_some()
}
pub fn get_str(&self, key: &str) -> Option<&str> {
self.get(key).and_then(|v| v.as_str())
}
pub fn insert(&mut self, key: &str, value: impl Into<Json>) -> &mut Self {
if let Json::Null = self {
*self = Json::object();
}
if let Json::Object(o) = self {
let value = value.into();
if let Some(slot) = o.iter_mut().find(|(k, _)| k == key) {
slot.1 = value;
} else {
o.push((key.to_string(), value));
}
}
self
}
pub fn push(&mut self, value: impl Into<Json>) -> &mut Self {
if let Json::Null = self {
*self = Json::array();
}
if let Json::Array(a) = self {
a.push(value.into());
}
self
}
pub fn dump(&self) -> String {
let mut s = String::new();
self.write_to(&mut s);
s
}
fn write_to(&self, out: &mut String) {
match self {
Json::Null => out.push_str("null"),
Json::Bool(true) => out.push_str("true"),
Json::Bool(false) => out.push_str("false"),
Json::Int(n) => out.push_str(&n.to_string()),
Json::Float(f) => {
if f.is_finite() {
out.push_str(&f.to_string());
} else {
out.push_str("null"); }
}
Json::Str(s) => write_escaped(s, out),
Json::Array(a) => {
out.push('[');
for (i, v) in a.iter().enumerate() {
if i > 0 {
out.push(',');
}
v.write_to(out);
}
out.push(']');
}
Json::Object(o) => {
out.push('{');
for (i, (k, v)) in o.iter().enumerate() {
if i > 0 {
out.push(',');
}
write_escaped(k, out);
out.push(':');
v.write_to(out);
}
out.push('}');
}
}
}
pub fn parse(text: &str) -> Result<Json, String> {
let mut p = Parser {
b: text.as_bytes(),
i: 0,
};
p.skip_ws();
let v = p.parse_value()?;
p.skip_ws();
if p.i != p.b.len() {
return Err(format!("trailing data at byte {}", p.i));
}
Ok(v)
}
}
impl fmt::Display for Json {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.dump())
}
}
impl From<bool> for Json {
fn from(b: bool) -> Json {
Json::Bool(b)
}
}
impl From<i64> for Json {
fn from(n: i64) -> Json {
Json::Int(n)
}
}
impl From<i32> for Json {
fn from(n: i32) -> Json {
Json::Int(n as i64)
}
}
impl From<usize> for Json {
fn from(n: usize) -> Json {
Json::Int(n as i64)
}
}
impl From<f64> for Json {
fn from(f: f64) -> Json {
Json::Float(f)
}
}
impl From<&str> for Json {
fn from(s: &str) -> Json {
Json::Str(s.to_string())
}
}
impl From<String> for Json {
fn from(s: String) -> Json {
Json::Str(s)
}
}
impl From<&String> for Json {
fn from(s: &String) -> Json {
Json::Str(s.clone())
}
}
impl<T: Into<Json>> From<Vec<T>> for Json {
fn from(v: Vec<T>) -> Json {
Json::Array(v.into_iter().map(Into::into).collect())
}
}
fn write_escaped(s: &str, out: &mut String) {
out.push('"');
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
'\u{08}' => out.push_str("\\b"),
'\u{0c}' => out.push_str("\\f"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
c => out.push(c),
}
}
out.push('"');
}
struct Parser<'a> {
b: &'a [u8],
i: usize,
}
impl<'a> Parser<'a> {
fn skip_ws(&mut self) {
while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\t' | b'\n' | b'\r') {
self.i += 1;
}
}
fn peek(&self) -> Option<u8> {
self.b.get(self.i).copied()
}
fn parse_value(&mut self) -> Result<Json, String> {
self.skip_ws();
match self.peek() {
Some(b'{') => self.parse_object(),
Some(b'[') => self.parse_array(),
Some(b'"') => Ok(Json::Str(self.parse_string()?)),
Some(b't') | Some(b'f') => self.parse_bool(),
Some(b'n') => self.parse_null(),
Some(c) if c == b'-' || c.is_ascii_digit() => self.parse_number(),
Some(c) => Err(format!("unexpected byte '{}' at {}", c as char, self.i)),
None => Err("unexpected end of input".to_string()),
}
}
fn expect(&mut self, lit: &[u8], value: Json) -> Result<Json, String> {
if self.b[self.i..].starts_with(lit) {
self.i += lit.len();
Ok(value)
} else {
Err(format!("invalid literal at {}", self.i))
}
}
fn parse_bool(&mut self) -> Result<Json, String> {
if self.peek() == Some(b't') {
self.expect(b"true", Json::Bool(true))
} else {
self.expect(b"false", Json::Bool(false))
}
}
fn parse_null(&mut self) -> Result<Json, String> {
self.expect(b"null", Json::Null)
}
fn parse_number(&mut self) -> Result<Json, String> {
let start = self.i;
let mut is_float = false;
while let Some(c) = self.peek() {
match c {
b'0'..=b'9' | b'-' | b'+' => self.i += 1,
b'.' | b'e' | b'E' => {
is_float = true;
self.i += 1;
}
_ => break,
}
}
let s = std::str::from_utf8(&self.b[start..self.i]).map_err(|e| e.to_string())?;
if !is_float {
if let Ok(n) = s.parse::<i64>() {
return Ok(Json::Int(n));
}
}
s.parse::<f64>()
.map(Json::Float)
.map_err(|_| format!("invalid number '{}'", s))
}
fn parse_string(&mut self) -> Result<String, String> {
self.i += 1; let mut out = String::new();
while let Some(c) = self.peek() {
self.i += 1;
match c {
b'"' => return Ok(out),
b'\\' => {
let esc = self.peek().ok_or("unterminated escape")?;
self.i += 1;
match esc {
b'"' => out.push('"'),
b'\\' => out.push('\\'),
b'/' => out.push('/'),
b'n' => out.push('\n'),
b'r' => out.push('\r'),
b't' => out.push('\t'),
b'b' => out.push('\u{08}'),
b'f' => out.push('\u{0c}'),
b'u' => {
let cp = self.parse_hex4()?;
if (0xD800..=0xDBFF).contains(&cp) {
if self.b[self.i..].starts_with(b"\\u") {
self.i += 2;
let lo = self.parse_hex4()?;
let c = 0x10000
+ ((cp - 0xD800) << 10)
+ (lo - 0xDC00);
out.push(char::from_u32(c).unwrap_or('\u{fffd}'));
} else {
out.push('\u{fffd}');
}
} else {
out.push(char::from_u32(cp).unwrap_or('\u{fffd}'));
}
}
other => return Err(format!("bad escape \\{}", other as char)),
}
}
c if c >= 0x80 => {
let n = if c >= 0xF0 {
3
} else if c >= 0xE0 {
2
} else {
1
};
let seq_start = self.i - 1;
self.i += n;
let slice = &self.b[seq_start..self.i];
out.push_str(std::str::from_utf8(slice).map_err(|e| e.to_string())?);
}
c => out.push(c as char),
}
}
Err("unterminated string".to_string())
}
fn parse_hex4(&mut self) -> Result<u32, String> {
if self.i + 4 > self.b.len() {
return Err("truncated \\u escape".to_string());
}
let s = std::str::from_utf8(&self.b[self.i..self.i + 4]).map_err(|e| e.to_string())?;
let cp = u32::from_str_radix(s, 16).map_err(|_| "bad \\u hex")?;
self.i += 4;
Ok(cp)
}
fn parse_array(&mut self) -> Result<Json, String> {
self.i += 1; let mut arr = Vec::new();
self.skip_ws();
if self.peek() == Some(b']') {
self.i += 1;
return Ok(Json::Array(arr));
}
loop {
arr.push(self.parse_value()?);
self.skip_ws();
match self.peek() {
Some(b',') => {
self.i += 1;
}
Some(b']') => {
self.i += 1;
return Ok(Json::Array(arr));
}
_ => return Err(format!("expected ',' or ']' at {}", self.i)),
}
}
}
fn parse_object(&mut self) -> Result<Json, String> {
self.i += 1; let mut obj = Vec::new();
self.skip_ws();
if self.peek() == Some(b'}') {
self.i += 1;
return Ok(Json::Object(obj));
}
loop {
self.skip_ws();
if self.peek() != Some(b'"') {
return Err(format!("expected object key at {}", self.i));
}
let key = self.parse_string()?;
self.skip_ws();
if self.peek() != Some(b':') {
return Err(format!("expected ':' at {}", self.i));
}
self.i += 1;
let val = self.parse_value()?;
obj.push((key, val));
self.skip_ws();
match self.peek() {
Some(b',') => {
self.i += 1;
}
Some(b'}') => {
self.i += 1;
return Ok(Json::Object(obj));
}
_ => return Err(format!("expected ',' or '}}' at {}", self.i)),
}
}
}
}
pub fn obj(pairs: &[(&str, Json)]) -> Json {
Json::Object(pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect())
}