Struct in_toto::interchange::JsonPretty

pub struct JsonPretty;

Pretty JSON data interchange.

This is identical to Json in all manners except for the to_writer method. Instead of writing the metadata in the canonical format, it instead pretty prints the metadata.

Trait Implementations

impl Clone for JsonPretty

fn clone(&self) -> JsonPretty

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DataInterchange for JsonPretty

type RawData = Value

The type of data that is contained in the signed portion of metadata.

fn extension() -> &'static str

assert_eq!(JsonPretty::extension(), "json");

fn canonicalize(raw_data: &Self::RawData) -> Result<Vec<u8>>

let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
let raw = JsonPretty::from_reader(jsn).unwrap();
let out = JsonPretty::canonicalize(&raw).unwrap();
assert_eq!(out, br#"{"baz":"quux","foo":"bar"}"#);

fn deserialize<T>(raw_data: &Self::RawData) -> Result<T> where
    T: DeserializeOwned, 

#[derive(Deserialize, Debug, PartialEq)]
struct Thing {
   foo: String,
   bar: String,
}

let jsn = json!({"foo": "wat", "bar": "lol"});
let thing = Thing { foo: "wat".into(), bar: "lol".into() };
let de: Thing = JsonPretty::deserialize(&jsn).unwrap();
assert_eq!(de, thing);

fn serialize<T>(data: &T) -> Result<Self::RawData> where
    T: Serialize, 

#[derive(Serialize)]
struct Thing {
   foo: String,
   bar: String,
}

let jsn = json!({"foo": "wat", "bar": "lol"});
let thing = Thing { foo: "wat".into(), bar: "lol".into() };
let se: serde_json::Value = JsonPretty::serialize(&thing).unwrap();
assert_eq!(se, jsn);

fn to_writer<W, T: Sized>(writer: W, value: &T) -> Result<()> where
    W: Write,
    T: Serialize, 

let json = json!({
    "o": {
        "a": [1, 2, 3],
        "s": "string",
        "n": 123,
        "t": true,
        "f": false,
        "0": null,
    },
});
let mut buf = Vec::new();
JsonPretty::to_writer(&mut buf, &json).unwrap();
assert_eq!(&String::from_utf8(buf).unwrap(), r#"{
  "o": {
    "0": null,
    "a": [
      1,
      2,
      3
    ],
    "f": false,
    "n": 123,
    "s": "string",
    "t": true
  }
}"#);

fn from_reader<R, T>(rdr: R) -> Result<T> where
    R: Read,
    T: DeserializeOwned, 

let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
let _: HashMap<String, String> = JsonPretty::from_reader(jsn).unwrap();

fn from_slice<T>(slice: &[u8]) -> Result<T> where
    T: DeserializeOwned, 

let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
let _: HashMap<String, String> = JsonPretty::from_slice(&jsn).unwrap();

impl Debug for JsonPretty

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

Formats the value using the given formatter.

impl PartialEq<JsonPretty> for JsonPretty

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl StructuralPartialEq for JsonPretty