generic_caster.rs

use std::any::Any;
use std::marker::PhantomData;

//####################################################
struct Test{ data: Box<dyn Any> }

#[derive(Default, Debug)]
struct Pos{ x: f32 }

#[derive(Default, Debug)]
struct Rot{ z: f32 }

//####################################################
fn main() {
    let t = Test{ data: Box::new( Pos::default() ) };
    println!("t.data = {:?}", t.data ); // Its Any
    
    // Straight From Any
    let p = t.data.downcast_ref::<Pos>().unwrap();
    println!("A: {:?}", p ); // its Pos!
    
    // Create Struct that hold T that can then downcast
    let d = DCast::<Pos>::new();
    println!( "B: {:?}", d.downcast( &t.data ).unwrap() );
    
    // Create a Generic function and save it for later down casting
    let f : F<Pos> = d_cast;
    println!( "C: {:?}", f( &t.data ).unwrap() );
    
    let ff : F<Rot> = d_cast;
    println!( "D: {:?}", ff( &t.data ) );
}

//####################################################
struct DCast<T>{
	_marker: PhantomData<*const T>,
}

impl<T:'static> DCast<T>{
	fn new() -> DCast<T>{ DCast{ _marker: PhantomData, } }

	fn downcast<'a>( &self, a: &'a Box<Any> ) -> Option<&'a T>{
		a.downcast_ref::< T >()
	}
}

//####################################################
type F<T> = fn( a: &Box<Any> ) -> Option<&T>;

fn d_cast<T:'static>( a: &Box<Any> ) -> Option<&T>{
	a.downcast_ref::<T>()
}