use std::collections::HashMap;
use std::sync::{Arc, Weak};
use std::cell::UnsafeCell;
use std::mem;

struct ARaw<T> {
    map: T,
}

type AConstruct = ARaw<UnsafeCell<HashMap<u32, Vec<B>>>>;
type A = ARaw<HashMap<u32, Vec<B>>>;

struct B {
    weak: Weak<A>, v:u32
}


impl A {
    fn new() -> Arc<AConstruct> {
        Arc::new(ARaw { map: UnsafeCell::new(HashMap::new()) })
    }
}

fn init_a(a: Arc<AConstruct>) -> Arc<A> {
    let weak_a: Weak<A> = unsafe { mem::transmute(Arc::downgrade(&a)) };
    let b1 = B { weak: weak_a.clone(), v: 1 };
    let b2 = B { weak: weak_a.clone(), v: 2 };
    {
        let mut map = unsafe { &mut *a.map.get() };
        let vec = map.entry(0).or_insert(Vec::new());
        vec.push(b1);
        vec.push(b2);
    }
    unsafe { mem::transmute(a) }
}

fn main() {
    let a = A::new();
    let a = init_a(a);

    println!("a = {:?}", a.map.get(&0).unwrap()[1].v);
}