jsoncall 0.0.3

A simple asynchronous JSON-RPC 2.0 library leveraging Rust's type system
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use std::any::Any;
use std::fmt;

use serde_json::Value;

pub(crate) fn downcast<T: 'static, S: 'static>(value: S) -> Result<T, S> {
    let mut value = Some(value);
    if let Some(value) = <dyn Any>::downcast_mut::<Option<T>>(&mut value) {
        Ok(value.take().unwrap())
    } else {
        Err(value.unwrap())
    }
}
pub(crate) fn write_string_no_escape(value: &Value, f: &mut fmt::Formatter) -> fmt::Result {
    if f.alternate() {
        write_string_pretty_no_escape(value, f, 0)
    } else {
        write_string_no_escape_oneline(value, f)
    }
}

fn write_string_no_escape_oneline(value: &Value, f: &mut fmt::Formatter) -> fmt::Result {
    match value {
        Value::Null => write!(f, "null"),
        Value::Bool(b) => write!(f, "{b}"),
        Value::Number(n) => write!(f, "{n}"),
        Value::String(s) => write!(f, "{s}"),
        Value::Array(arr) => {
            write!(f, "[")?;
            let mut first = true;
            for item in arr {
                if !first {
                    write!(f, ",")?;
                }
                first = false;
                write_string_no_escape(item, f)?;
            }
            write!(f, "]")
        }
        Value::Object(obj) => {
            write!(f, "{{")?;
            let mut first = true;
            for (key, value) in obj {
                if !first {
                    write!(f, ",")?;
                }
                first = false;
                write!(f, "{key}:")?;
                write_string_no_escape(value, f)?;
            }
            write!(f, "}}")
        }
    }
}

fn write_string_pretty_no_escape(
    value: &Value,
    f: &mut fmt::Formatter,
    indent: usize,
) -> fmt::Result {
    match value {
        Value::Null => write!(f, "null"),
        Value::Bool(b) => write!(f, "{b}"),
        Value::Number(n) => write!(f, "{n}"),
        Value::String(s) => write!(f, "{s}"),
        Value::Array(arr) => {
            if arr.is_empty() {
                return write!(f, "[]");
            }

            writeln!(f, "[")?;
            let next_indent = indent + 2;

            for (i, item) in arr.iter().enumerate() {
                write!(f, "{:indent$}", "", indent = next_indent)?;
                write_string_pretty_no_escape(item, f, next_indent)?;

                if i < arr.len() - 1 {
                    writeln!(f, ",")?;
                } else {
                    writeln!(f)?;
                }
            }

            write!(f, "{:indent$}]", "", indent = indent)
        }
        Value::Object(obj) => {
            if obj.is_empty() {
                return write!(f, "{{}}");
            }

            writeln!(f, "{{")?;
            let next_indent = indent + 2;

            let entries: Vec<_> = obj.iter().collect();
            for (i, (key, value)) in entries.iter().enumerate() {
                write!(f, "{:indent$}\"{key}\": ", "", indent = next_indent)?;
                write_string_pretty_no_escape(value, f, next_indent)?;

                if i < entries.len() - 1 {
                    writeln!(f, ",")?;
                } else {
                    writeln!(f)?;
                }
            }

            write!(f, "{:indent$}}}", "", indent = indent)
        }
    }
}