vcon 0.4.0

A library for vCons. It reads and checks a vCon (form, compression, uuid, critical extensions) and writes one, unsigned, gzipped, signed or encrypted.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Compact JSON with members in a fixed order, and the depth bound that
//! `read::inspect` applies.

use serde_json::Value;

use super::WriteError;
use crate::read::MAX_JSON_DEPTH;

/// A JSON value whose objects keep their members in the order given.
#[derive(Debug, Clone, PartialEq)]
pub(super) enum Node {
    /// A string.
    Str(String),
    /// A number or literal, already written.
    Raw(String),
    /// An array.
    Arr(Vec<Node>),
    /// An object, its members in order.
    Obj(Vec<(String, Node)>),
    /// A value given by the caller, written as serde_json writes it.
    Val(Value),
}

impl Node {
    pub(super) fn str(text: &str) -> Node {
        Node::Str(text.to_owned())
    }
}

/// An object under construction: members are added in the order written.
#[derive(Debug, Default)]
pub(super) struct Obj(Vec<(String, Node)>);

impl Obj {
    pub(super) fn put(&mut self, name: &str, value: Node) {
        self.0.push((name.to_owned(), value));
    }

    pub(super) fn put_str(&mut self, name: &str, value: &Option<String>) {
        if let Some(text) = value {
            self.put(name, Node::str(text));
        }
    }

    pub(super) fn done(self) -> Node {
        Node::Obj(self.0)
    }
}

/// Writes `node` as compact JSON, refusing output with more than
/// [`MAX_JSON_DEPTH`] arrays and objects open at once.
pub(super) fn render(node: &Node) -> Result<Vec<u8>, WriteError> {
    let mut out = Vec::new();
    write(node, 0, &mut out)?;
    Ok(out)
}

fn quoted(text: &str, out: &mut Vec<u8>) {
    // Serializing a str cannot fail; an empty string is never written,
    // since every string has at least its quotes.
    out.extend_from_slice(serde_json::to_string(text).unwrap_or_default().as_bytes());
}

fn open(depth: usize) -> Result<usize, WriteError> {
    if depth >= MAX_JSON_DEPTH {
        return Err(WriteError::TooDeep);
    }
    Ok(depth + 1)
}

fn write(node: &Node, depth: usize, out: &mut Vec<u8>) -> Result<(), WriteError> {
    match node {
        Node::Str(text) => quoted(text, out),
        Node::Raw(text) => out.extend_from_slice(text.as_bytes()),
        Node::Arr(items) => {
            let inner = open(depth)?;
            out.push(b'[');
            for (i, item) in items.iter().enumerate() {
                if i > 0 {
                    out.push(b',');
                }
                write(item, inner, out)?;
            }
            out.push(b']');
        }
        Node::Obj(members) => {
            let inner = open(depth)?;
            out.push(b'{');
            for (i, (name, value)) in members.iter().enumerate() {
                if i > 0 {
                    out.push(b',');
                }
                quoted(name, out);
                out.push(b':');
                write(value, inner, out)?;
            }
            out.push(b'}');
        }
        Node::Val(value) => write_value(value, depth, out)?,
    }
    Ok(())
}

fn write_value(value: &Value, depth: usize, out: &mut Vec<u8>) -> Result<(), WriteError> {
    match value {
        Value::Array(items) => {
            let inner = open(depth)?;
            out.push(b'[');
            for (i, item) in items.iter().enumerate() {
                if i > 0 {
                    out.push(b',');
                }
                write_value(item, inner, out)?;
            }
            out.push(b']');
        }
        Value::Object(members) => {
            let inner = open(depth)?;
            out.push(b'{');
            for (i, (name, item)) in members.iter().enumerate() {
                if i > 0 {
                    out.push(b',');
                }
                quoted(name, out);
                out.push(b':');
                write_value(item, inner, out)?;
            }
            out.push(b'}');
        }
        Value::String(text) => quoted(text, out),
        // null, booleans and numbers, as serde_json writes them.
        other => out.extend_from_slice(other.to_string().as_bytes()),
    }
    Ok(())
}