extern crate serde;
#[macro_use]
extern crate serde_json;

#[macro_use]
extern crate serde_derive;

use serde::de::Deserialize;
use serde::ser::Serialize;

use std::collections::HashMap;
use std::collections::HashSet;
use std::fs::File;
use std::hash::{BuildHasher, Hash};
use std::io::Read;

#[derive(Serialize, Deserialize)]
pub struct MySet<T, S>(
    #[serde(
        bound(
            serialize = "HashSet<T, S>: Serialize", deserialize = "HashSet<T, S>: Deserialize<'de>"
        )
    )]
    HashSet<T, S>,
);

impl<T, S> MySet<T, S>
where
    T: Eq + Default + Hash + for<'de> Deserialize<'de>,
    S: Eq + Default + Hash + BuildHasher,
{
    fn testme() -> Self {
        let mut fp = File::open("no.txt").unwrap();
        let mut content = String::new();
        fp.read_to_string(&mut content).unwrap();
        let d: MySet<T, S> = serde_json::from_str(&content).unwrap();
        d
    }
}

#[derive(Serialize, Deserialize)]
pub struct MyMap<String, S>(
    #[serde(
        bound(
            serialize = "HashMap<String, S>: Serialize",
            deserialize = "HashMap<String, S>: Deserialize<'de>"
        )
    )]
    HashMap<String, S>,
);

impl<String, S> MyMap<String, S>
where
    String: Eq + Hash + for<'a> Deserialize<'a>,
    S: Eq + Hash + for<'a> Deserialize<'a>,
{
    fn testme() -> Self {
        let mut fp = File::open("no.txt").unwrap();
        let mut content = "".to_string();
        fp.read_to_string(&mut content).unwrap();
        let d: MyMap<String, S> = serde_json::from_str(&content).unwrap();
        d
    }
}

fn main() {
    let mut object = json!({ "A": 65, "B": 66, "C": 67 });
    *object.get_mut("A").unwrap() = json!(69);

    let mut array = json!(["A", "B", "C"]);
    *array.get_mut(2).unwrap() = json!("D");

    println!("{:#?}", array);
    *array.get_mut(2).unwrap() = object;
    println!("{:#?}", array);

}