lil-json 0.1.7

serialize & deserialize JSON in no_std
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

/// proxies a json object from stdin to stdout with stack buffers

use std::{io::{stderr, stdin, stdout}, process::exit};

use embedded_io::{Read, Write};
use embedded_io_adapters::std::FromStd;
use lil_json::{ArrayJsonObject, JsonParseFailure};

const MAX_FIELDS: usize = 50;
const READ_BUFFER_SIZE: usize = 16384; // 16 KiB
const ESCAPE_BUFFER_SIZE: usize = 16384; // 16 KiB

fn main() {
    let stdin = FromStd::new(stdin());
    let stderr = FromStd::new(stderr());
    let stdout = FromStd::new(stdout());
    proxy_json_object(stdin, stdout, stderr);
}

fn proxy_json_object<Input: Read, Output: Write, Logs: Write>(mut input: Input, mut output: Output, mut log_output: Logs) {
    let mut read_buffer = [0_u8; READ_BUFFER_SIZE];
    let mut escape_buffer = [0_u8; ESCAPE_BUFFER_SIZE];
    let mut read_buffer_end = 0;
    loop {
        match input.read(read_buffer.split_at_mut(read_buffer_end).1) {
            Err(e) => {
                log_output.write_fmt(format_args!("failed to read from input: {:?}", e)).unwrap();
                exit(1);
            },
            Ok(n) => {
                read_buffer_end += n;
                match ArrayJsonObject::<MAX_FIELDS>::new_parsed(read_buffer.split_at(read_buffer_end).0, &mut escape_buffer) {
                    Err(JsonParseFailure::Incomplete) => {
                        if read_buffer_end == READ_BUFFER_SIZE {
                            log_output.write_fmt(format_args!("json object incomplete after {} bytes\n", read_buffer_end)).unwrap();
                            exit(1);
                        }
                        assert!(read_buffer_end < READ_BUFFER_SIZE);
                        continue;
                    },
                    Err(e) => {
                        log_output.write_fmt(format_args!("read {} bytes, failed to parse json object: {:?}\n", read_buffer_end, e)).unwrap();
                        exit(1);
                    },
                    Ok((bytes_consumed, json_object)) => {
                        log_output.write_fmt(format_args!("read {} bytes, parsed a json object in {} bytes with {} fields\n", read_buffer_end, bytes_consumed, json_object.len())).unwrap();
                        log_output.flush().unwrap();
                        json_object.serialize(&mut output).expect("failed to write to output");
                        output.flush().unwrap();
                        read_buffer.rotate_left(bytes_consumed);
                        read_buffer_end -= bytes_consumed;
                        // exit(0)
                    },
                }
            },

        }
    }
}