use std::ops::Deref;
use std::marker::PhantomData;

struct RawBasePtr(u8);
struct RawDerivedPtr(u8);

#[derive(Clone, Copy)]
struct BasePtr<T>(T);

impl<T: Into<*mut RawBasePtr>> BasePtr<T> {
    fn f1(&self) {
        let ptr = self.into();
        println!("call f1 on {:?}", ptr);
    }
}

impl<T: Into<*mut RawBasePtr>> Into<*mut RawBasePtr> for BasePtr<T> {
    fn into(self) -> *mut RawBasePtr {
        self.0
    }
}

#[derive(Clone, Copy)]
struct DerivedPtr<T>(T);

impl<T: Into<*mut RawDerivedPtr>> DerivedPtr<T> {
    fn f2(&self) {
        let ptr = self.into();
        println!("call f2 on {:?}", ptr);
    }
}

struct DerivedToBaseCast<T>(PhantomData<T>);

impl<T: Into<*mut RawDerivedPtr>> Into<*mut RawBasePtr> for DerivedToBaseCast<T> {
    fn into(self) -> *mut RawBasePtr {
        self.into() + 2
    }
}

impl<T: Into<*mut RawDerivedPtr>> Into<*mut RawDerivedPtr> for BasePtr<T> {
    fn into(self) -> *mut RawDerivedPtr {
        self.0
    }
}

impl<T: Into<*mut RawDerivedPtr>> Deref for DerivedPtr<T> {
    type Target = BasePtr<DerivedToBaseCast<T>>;
    fn deref(&self) -> &Self::Target {
        unsafe { std::mem::transmute::<&DerivedPtr, &Self::Target>(self) }
    }
}

/*
#[derive(Clone, Copy)]
struct BasePtrSource<T: Into<*mut RawBasePtr>>(T);

impl<T: Into<*mut RawBasePtr>> BasePtrSource<T> {
    fn f1(self) {
        let ptr = self.0.into();
        println!("call f1 on {:?}", ptr);
    }
}

impl Into<*mut RawBasePtr> for BasePtr {
    fn into(self) -> *mut RawBasePtr {
        self.ptr
    }
}*/

/*impl Into<*mut RawBasePtr> for DerivedPtr {
    fn into(self) -> *mut RawBasePtr {
        ((self.ptr as usize) + 2) as _
    }
}*/

/*impl Deref for DerivedPtr {
    type Target = BasePtr<DerivedPtr>;
    fn deref(&self) -> &Self::Target {
        unsafe { std::mem::transmute::<&DerivedPtr, &Self::Target>(self) }
    }
}*/

fn main() {
    let base = BasePtr::<*mut RawBasePtr>(0x100 as _ );
    base.f1();

    let derived = DerivedPtr::<*mut RawDerivedPtr>(0x200 as _);
    derived.f1();


}