asterix_parser 0.1.1

use serde::Serialize;
use serde::Deserialize;

use std::str;

#[derive(Serialize, Deserialize)]
struct Car {
    model: i32,
    year: i32,
}

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    age: i32,
}

// constrain output types to have the `Deserialize` trait
fn deserialize<'a, T>(data: &'a [u8]) -> T
where
    T: Deserialize<'a>,
{
    let msg = str::from_utf8(data).unwrap();
    serde_json::from_str::<T>(msg).unwrap()
}

fn deserialize_bytes<'a, T>(data: &'a Vec<u8>) -> T
where
    T: Deserialize<'a>,
{
    let msg = data;
    serde_json::from_slice::<T>(msg).unwrap()
}

// shorthand for the above when `T` isn't needed in the function body
fn serialize(object: &impl Serialize) -> String {
    let msg = serde_json::to_string(object).unwrap();
    return msg;
}

fn serialize_bytes(object: &impl Serialize) -> Vec<u8> {
    let msg = serde_json::to_vec(object).unwrap();
    return msg;
}

pub fn test_serialization() {
    let car = Car {
        model: 7,
        year: 2077,
    };
    let person = Person {
        name: "Bob".to_string(),
        age: 42,
    };

    // types are infrerred from the parameters
    let car_json = serialize(&car);
    let person_json = serialize(&person);
    let car_u8 = serialize_bytes(&car);
    let person_u8 = serialize_bytes(&person);

    let car1 : Car = deserialize(car_json.as_bytes()); // output type can be inferred
    println!("Deserialized car1 model {}, year {} ", car1.model, car1.year);
    let car2 = deserialize::<Car>(car_json.as_bytes()); // requres turbofish
    println!("Deserialized car2 model {}, year {} ", car2.model, car2.year);

    let car3 : Car = deserialize_bytes(&car_u8);
    println!("Deserialized car3 model {}, year {} ", car3.model, car3.year);
    let car4  = deserialize_bytes::<Car>(&car_u8);
    println!("Deserialized car4 model {}, year {} ", car4.model, car4.year);

    let person: Person = deserialize(person_json.as_bytes()); // works for `Person` too
    println!("Deserialized person name {}, age {} ", person.name , person.age);
    let person1 : Person = deserialize_bytes(&person_u8);
    println!("Deserialized person1 name {}, age {} ", person1.name , person1.age);
}