Rust Arc指针类型转换：dyn转换为具体类型

impl dyn Base {
    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any> {
        return self;
    }
    fn downcast_arc<T: Base>(self: Arc<Self>) -> Option<Arc<T>> {
        
        let x = self.as_any_arc();

        if x.is::<T>() {
            
            // into_raw不会改变引用计数
            let p = Arc::into_raw(x);
            
            let new = unsafe { Arc::from_raw(p as *const T) };
            return Some(new);
        }
        println!("x.is not <{}>", std::any::type_name::<T>());
        return None;
    }
}

#![feature(trait_upcasting)]
use std::{any::Any, fmt::Debug, sync::Arc};

trait Base: Any + Send + Sync + Debug {
    fn get_name(&self) -> String;
}

impl dyn Base {
    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any> {
        return self;
    }
    fn downcast_arc<T: Base>(self: Arc<Self>) -> Option<Arc<T>> {
        println!("count before: {}", Arc::strong_count(&self));
        let x = self.as_any_arc();
        let y = x.clone();

        if x.is::<T>() {
            println!("x.is::<{}>", std::any::type_name::<T>());
            println!("count in1: {}", Arc::strong_count(&y));
            // into_raw不会改变引用计数
            let p = Arc::into_raw(x);
            println!("count in2: {}", Arc::strong_count(&y));
            let new = unsafe { Arc::from_raw(p as *const T) };
            println!("count after: {}", Arc::strong_count(&new));
            return Some(new);
        }
        println!("x.is not <{}>", std::any::type_name::<T>());
        return None;
    }
}

#[derive(Debug)]
struct A {
    name: String,
}

impl Base for A {
    fn get_name(&self) -> String {
        self.name.clone()
    }
}

impl A {
    fn say_a(&self) {
        println!("say_a");
    }
}

#[derive(Debug)]
struct B {
    name: String,
}

impl Base for B {
    fn get_name(&self) -> String {
        self.name.clone()
    }
}

impl B {
    fn say_b(&self) {
        println!("say_a");
    }
}

fn main() {
    let a: Arc<A> = Arc::new(A {
        name: "A".to_string(),
    });
    let b: Arc<B> = Arc::new(B {
        name: "B".to_string(),
    });

    let x: Arc<dyn Base> = a as Arc<dyn Base>;
    let y: Arc<dyn Base> = b as Arc<dyn Base>;
    assert!(x.clone().downcast_arc::<A>().is_some());
    assert!(x.clone().downcast_arc::<B>().is_none());
    assert!(y.clone().downcast_arc::<A>().is_none());
    assert!(y.clone().downcast_arc::<B>().is_some());

    let a1: Arc<A> = x.downcast_arc::<A>().expect("x is not A");
    println!("a1: {:?}", a1);
    a1.say_a();

    let b1: Arc<B> = y.downcast_arc::<B>().expect("y is not B");
    println!("b1: {:?}", b1);
    b1.say_b();
}

count before: 2
x.is::<downcast::A>
count in1: 3
count in2: 3
count after: 3
count before: 2
x.is not <downcast::B>
count before: 2
x.is not <downcast::A>
count before: 2
x.is::<downcast::B>
count in1: 3
count in2: 3
count after: 3
count before: 1
x.is::<downcast::A>
count in1: 2
count in2: 2
count after: 2
a1: A { name: "A" }
say_a
count before: 1
x.is::<downcast::B>
count in1: 2
count in2: 2
count after: 2
b1: B { name: "B" }
say_a

/// @brief 将Arc<dyn xxx>转换为Arc<具体类型>的trait
trait DowncastArc: Any + Send + Sync {
    /// 请在具体类型中实现这个函数，返回self
    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any>;

    /// @brief 将Arc<dyn xxx>转换为Arc<具体类型>
    /// 
    /// 如果Arc<dyn xxx>是Arc<具体类型>，则返回Some(Arc<具体类型>)，否则返回None
    /// 
    /// @param self Arc<dyn xxx>
    fn downcast_arc<T: Any + Send + Sync>(self: Arc<Self>) -> Option<Arc<T>> {
        let x: Arc<dyn Any> = self.as_any_arc();
        if x.is::<T>() {
            // into_raw不会改变引用计数
            let p = Arc::into_raw(x);
            let new = unsafe { Arc::from_raw(p as *const T) };
            return Some(new);
        }
        return None;
    }
}

#![feature(trait_upcasting)]

impl DowncastArc for dyn Base {
    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any> {
        return self;
    }
}