Struct tuf::interchange::JsonDataInterchange

pub struct JsonDataInterchange {}

JSON data interchange.

Trait Implementations

impl Debug for JsonDataInterchange

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

Formats the value using the given formatter.

impl PartialEq for JsonDataInterchange

fn eq(&self, __arg_0: &JsonDataInterchange) -> bool

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

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

This method tests for !=.

impl DataInterchange for JsonDataInterchange

type RawData = Value

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

fn extension() -> &'static str

use tuf::interchange::{DataInterchange, JsonDataInterchange};

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

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

use tuf::interchange::{DataInterchange, JsonDataInterchange};
use std::collections::HashMap;

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

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

#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate serde_json;
extern crate tuf;

use tuf::interchange::{DataInterchange, JsonDataInterchange};
use std::collections::HashMap;

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

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

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

#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate serde_json;
extern crate tuf;

use tuf::interchange::{DataInterchange, JsonDataInterchange};
use std::collections::HashMap;

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

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

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

use tuf::interchange::{DataInterchange, JsonDataInterchange};

let arr = vec![1, 2, 3];
let mut buf = Vec::new();
JsonDataInterchange::to_writer(&mut buf, &arr).unwrap();
assert!(&buf == b"[1, 2, 3]" || &buf == b"[1,2,3]");

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

use tuf::interchange::{DataInterchange, JsonDataInterchange};
use std::collections::HashMap;

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