Enum Json 

pub enum Json {
    Null,
    Bool(bool),
    Number(f64),
    String(String),
    Array(Vec<Json>),
    Object(BTreeMap<String, Json>),
}

A JSON value.

Variants

Null

null

Bool(bool)

true or false

Number(f64)

A number.

String(String)

A string.

Array(Vec<Json>)

An array.

Object(BTreeMap<String, Json>)

An object. Ordered so output is deterministic.

Implementations

impl Json

pub fn object(pairs: Vec<(&str, Self)>) -> Self

Build an object from pairs.

Examples found in repository

examples/parse_and_build.rs (lines 37-44)

fn main() {
    let request = r#"{"jsonrpc":"2.0","id":7,"method":"initialize","params":{"trace":"off"}}"#;

    let value = parse(request).expect("the request is valid JSON");

    // `get` walks objects; it returns `None` for a missing key and for
    // a value that is not an object, so chains do not need a type check
    // at every step.
    assert_eq!(
        value.get("method").and_then(Json::as_str),
        Some("initialize")
    );
    assert_eq!(
        value
            .get("params")
            .and_then(|p| p.get("trace"))
            .and_then(Json::as_str),
        Some("off")
    );

    // Building a reply. Object keys come back out in sorted order,
    // which makes serialised output comparable in a test without
    // parsing it again.
    let reply = Json::object(vec![
        ("jsonrpc", Json::str("2.0")),
        ("id", value.get("id").cloned().unwrap_or(Json::Null)),
        (
            "result",
            Json::object(vec![("capabilities", Json::object(vec![]))]),
        ),
    ]);

    println!("{}", reply.to_json());

    // Malformed input is an error with a message, not a panic and not
    // a silent default.
    let bad = parse("{\"unterminated\": ");
    println!("malformed input: {}", bad.unwrap_err());
}

pub fn str(s: impl Into<String>) -> Self

A string value.

Examples found in repository

examples/parse_and_build.rs (line 38)

fn main() {
    let request = r#"{"jsonrpc":"2.0","id":7,"method":"initialize","params":{"trace":"off"}}"#;

    let value = parse(request).expect("the request is valid JSON");

    // `get` walks objects; it returns `None` for a missing key and for
    // a value that is not an object, so chains do not need a type check
    // at every step.
    assert_eq!(
        value.get("method").and_then(Json::as_str),
        Some("initialize")
    );
    assert_eq!(
        value
            .get("params")
            .and_then(|p| p.get("trace"))
            .and_then(Json::as_str),
        Some("off")
    );

    // Building a reply. Object keys come back out in sorted order,
    // which makes serialised output comparable in a test without
    // parsing it again.
    let reply = Json::object(vec![
        ("jsonrpc", Json::str("2.0")),
        ("id", value.get("id").cloned().unwrap_or(Json::Null)),
        (
            "result",
            Json::object(vec![("capabilities", Json::object(vec![]))]),
        ),
    ]);

    println!("{}", reply.to_json());

    // Malformed input is an error with a message, not a panic and not
    // a silent default.
    let bad = parse("{\"unterminated\": ");
    println!("malformed input: {}", bad.unwrap_err());
}

pub fn get(&self, key: &str) -> Option<&Self>

Look up a key on an object.

Examples found in repository

examples/parse_and_build.rs (line 23)

fn main() {
    let request = r#"{"jsonrpc":"2.0","id":7,"method":"initialize","params":{"trace":"off"}}"#;

    let value = parse(request).expect("the request is valid JSON");

    // `get` walks objects; it returns `None` for a missing key and for
    // a value that is not an object, so chains do not need a type check
    // at every step.
    assert_eq!(
        value.get("method").and_then(Json::as_str),
        Some("initialize")
    );
    assert_eq!(
        value
            .get("params")
            .and_then(|p| p.get("trace"))
            .and_then(Json::as_str),
        Some("off")
    );

    // Building a reply. Object keys come back out in sorted order,
    // which makes serialised output comparable in a test without
    // parsing it again.
    let reply = Json::object(vec![
        ("jsonrpc", Json::str("2.0")),
        ("id", value.get("id").cloned().unwrap_or(Json::Null)),
        (
            "result",
            Json::object(vec![("capabilities", Json::object(vec![]))]),
        ),
    ]);

    println!("{}", reply.to_json());

    // Malformed input is an error with a message, not a panic and not
    // a silent default.
    let bad = parse("{\"unterminated\": ");
    println!("malformed input: {}", bad.unwrap_err());
}

pub fn as_str(&self) -> Option<&str>

The value as a string slice, if it is one.

pub fn to_json(&self) -> String

Serialise to JSON text.

Examples found in repository

examples/parse_and_build.rs (line 46)

fn main() {
    let request = r#"{"jsonrpc":"2.0","id":7,"method":"initialize","params":{"trace":"off"}}"#;

    let value = parse(request).expect("the request is valid JSON");

    // `get` walks objects; it returns `None` for a missing key and for
    // a value that is not an object, so chains do not need a type check
    // at every step.
    assert_eq!(
        value.get("method").and_then(Json::as_str),
        Some("initialize")
    );
    assert_eq!(
        value
            .get("params")
            .and_then(|p| p.get("trace"))
            .and_then(Json::as_str),
        Some("off")
    );

    // Building a reply. Object keys come back out in sorted order,
    // which makes serialised output comparable in a test without
    // parsing it again.
    let reply = Json::object(vec![
        ("jsonrpc", Json::str("2.0")),
        ("id", value.get("id").cloned().unwrap_or(Json::Null)),
        (
            "result",
            Json::object(vec![("capabilities", Json::object(vec![]))]),
        ),
    ]);

    println!("{}", reply.to_json());

    // Malformed input is an error with a message, not a panic and not
    // a silent default.
    let bad = parse("{\"unterminated\": ");
    println!("malformed input: {}", bad.unwrap_err());
}

Trait Implementations

impl Clone for Json

fn clone(&self) -> Json

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Json

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Json

fn eq(&self, other: &Json) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Json