struct Pen{
color:(u8,u8,u8)
}
struct Brush{
color:(u8,u8,u8)
}
trait HavePen{
fn get_pen(&self)->Pen;
fn t(&self);
}
trait HaveBrush{
fn get_brush(&self)->Brush;
fn t(&self);
}
struct DC{
color:(u8,u8,u8)
}
impl HaveBrush for DC{
fn get_brush(&self)->Brush{
let color = self.color;
Brush{color:(color.0,color.1,color.2)}
}
fn t(&self){

}
}
impl HavePen for DC{
fn get_pen(&self)->Pen{
let color = self.color;
Pen{color:(color.0,color.1,color.2)}
}
fn t(&self){
}
}
impl DC{
fn new()->Self{
DC{
color:(0,0,0)
}
}
fn c(&self)->u32{
return (self.color.0 as u32) << 24 | (self.color.1 as u32) << 16 | (self.color.2 as u32) << 8;
}
}
fn test(dc:&DC){
let dcbrush:&dyn HaveBrush = dc;
let brush_ = HaveBrush::get_brush(dc);
let dc_pen:&dyn HavePen = dc;
let dcbrush= unsafe{std::mem::transmute::<_,[u64;2]>(dcbrush)};
let dc_pen= unsafe{std::mem::transmute::<_,[u64;2]>(dc_pen)};
let func1:&Fn( &DC)->Brush = &HaveBrush::get_brush;
let func2:&Fn( &DC)->Pen = &HavePen::get_pen;
let func3:_ = &DC::new;
let func4:_ = &DC::get_pen;
let func5:_ = &DC::get_brush;
let func6:_ = &DC::c;
let c = 0;
println!("{:p}-{:p}", dcbrush[0] as *const u64, dcbrush[1] as *const u64);
println!("{:p}-{:p}", dc_pen[0] as *const u64, dc_pen[1] as *const u64);
println!("{:p}", func1);
println!("{:p}", func2);
println!("{:p}", func3);
println!("{:p}", func4);
println!("{:p} {}", func5, std::mem::size_of_val(func5));
println!("{:p} {}", func6, std::mem::size_of_val(func5));
//println!("{:p} {}", dcbrush[0] as *const u64, std::mem::size_of_val(dcbrush[0] as ));
println!("{}", func6(dc));
println!("{:p}", &c);
}
fn test2(b:&dyn HaveBrush){
let pointers= unsafe{std::mem::transmute::<_,[u64;2]>(b)};
println!("{:p}-{:p}", pointers[0] as *const u64, pointers[1] as *const u64);
}
fn main() {
let dc = DC::new();
let dc2 = DC::new();
let b:Box<dyn HaveBrush> = Box::new(DC::new());
let b2:Box<*const HaveBrush> = Box::new( &dc);
test(&dc);
test(&dc2);
//test(b.as_ref());
test2(b.as_ref());
test2(unsafe{b2.as_ref().as_ref().unwrap()});
}