tiny-serde 0.1.2

A tiny library to serialize and deserialize to/from JSON
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

pub mod deserialize;
pub mod error;
pub mod serialize;
pub use deserialize::{from_str, Deserialize};
pub use serialize::Serialize;
pub use tiny_serde_derive::Serialize;

use std::collections::HashMap;

#[derive(Clone, Debug)]
pub enum Number {
    Integer(u128),
    SignedInteger(i128),
    Decimal(f64),
}

impl ToString for Number {
    fn to_string(&self) -> String {
        match self {
            Self::Integer(int) => int.to_string(),
            Self::SignedInteger(int) => int.to_string(),
            Self::Decimal(dec) => dec.to_string(),
        }
    }
}

#[derive(Clone, Debug)]
pub enum Value {
    Null,
    Boolean(bool),
    Number(Number),
    String(String),
    Array(Vec<Value>),
    Object(HashMap<String, Value>),
}

impl ToString for Value {
    fn to_string(&self) -> String {
        match self {
            Self::Null => "null".to_string(),
            Self::Boolean(b) => match b {
                true => "true",
                false => "false",
            }
            .to_string(),
            Self::Number(nb) => nb.to_string(),
            Self::String(value) => {
                let value = value
                    .replace('"', r#"\""#)
                    .replace('\\', r#"\\"#)
                    .replace('\n', r#"\n"#)
                    .replace('\r', r#"\r"#);
                format!("\"{value}\"")
            }
            Self::Array(array) => array_to_json(array),
            Self::Object(object) => object_to_json(object),
        }
    }
}

fn array_to_json(array: &[Value]) -> String {
    let mut final_value = "[".to_string();
    let last_index = array.len() - 1;
    for (i, value) in array.iter().enumerate() {
        final_value += &value.to_string();
        if i < last_index {
            final_value.push(',');
        }
    }
    final_value += "]";
    final_value
}

fn object_to_json(object: &HashMap<String, Value>) -> String {
    let mut final_value = "{".to_string();
    let last_index = object.len() - 1;
    let mut i = 0;
    for (key, value) in object.iter() {
        if i < last_index {
            final_value += &format!("\"{key}\":{},", value.to_string());
        } else {
            final_value += &format!("\"{key}\":{}", value.to_string());
        }
        i += 1;
    }
    final_value += "}";
    final_value
}