extern crate core;

use core::marker::PhantomData;
pub struct Mut<'a>(PhantomData<&'a mut ()>);

struct Bucket {
    ptr: *mut u32,
    len: usize,
}

struct Ref<M> {
    base: *mut u32,
    index: usize,
    _marker: PhantomData<M>,
}

impl Bucket {
    pub fn get_first(&self) -> Ref<Mut> {
        Ref {
            base: self.ptr,
            index: 0,
            _marker: PhantomData,
        }
    }

    pub fn get(&self, index: usize) -> Ref<Mut> {
        Ref {
            base: self.ptr,
            index,
            _marker: PhantomData,
        }
    }
}

impl<'a> Ref<Mut<'a>> {
    pub fn into_mut(self) -> &'a mut u32 {
        unsafe {
            &mut *self.base.add(self.index)
        }
    }
}

fn main() {
    let mut data = vec![1, 2, 3];
    /*
    let r;
    {
        let bucket = Bucket { ptr: data.as_mut_ptr(), len: data.len() };
        r = bucket.get_first(); // does this work? should be compile error
    }
    */
    let bucket = Bucket { ptr: data.as_mut_ptr(), len: data.len() };
    let r1 = bucket.get(0);
    let r11 = bucket.get(0);
    let r2 = bucket.get(1);
    let r3 = bucket.get(2);
    println!("Val1 : {}", r1.into_mut());
    println!("Val2 : {}", r2.into_mut());
    println!("Val3 : {}", r3.into_mut());
    //let d1 =

    /*
    let r1;
    {
        let mut v1 = 53u32;
        r1 = Ref { ptr : &mut v1 as *mut u32, _p: PhantomData };
    }
    println!("Val : {}", r1.into_mut());

    let mut v2 = 64u32;
    let r2;
    {
        let root = Root { ptr : &mut v2 as *mut u32 };
        r2 = root.as_ref();
    }
    println!("Val : {}", r2.into_mut());
    */
}