Rust类型转换与动态分发库mopa的使用

以下是基于提供内容的完整示例demo，展示了mopa库的核心功能：

use mopa::{mopafy, Any, AnyExt};
use std::any::TypeId;

// 1. 定义可多态化的trait
trait Animal: mopa::Any {
    fn speak(&self);
    fn name(&self) -> &str;
    fn animal_type(&self) -> &str;
}

// 使用mopafy宏为trait添加Any功能
mopafy!(Animal);

// 2. 实现具体类型
#[derive(Debug)]
struct Dog {
    name: String,
    breed: String,
}

impl Animal for Dog {
    fn speak(&self) {
        println!("{} the {} says: Woof!", self.name, self.breed);
    }
    
    fn name(&self) -> &str {
        &self.name
    }
    
    fn animal_type(&self) -> &str {
        "Dog"
    }
}

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

impl Animal for Cat {
    fn speak(&self) {
        println!("{} the {} cat says: Meow!", self.name, self.color);
    }
    
    fn name(&self) -> &str {
        &self.name
    }
    
    fn animal_type(&self) -> &str {
        "Cat"
    }
}

// 3. 类型擦除容器
struct TypeErasedContainer {
    value: Box<dyn Any>,
    type_id: TypeId,
}

impl TypeErasedContainer {
    fn new<T: Any>(value: T) -> Self {
        TypeErasedContainer {
            value: Box::new(value),
            type_id: TypeId::of::<T>(),
        }
    }
    
    fn downcast<T: Any>(self) -> Result<T, Self> {
        if self.type_id == TypeId::of::<T>() {
            Ok(*self.value.downcast::<T>().unwrap())
        } else {
            Err(self)
        }
    }
}

// 4. 动态方法调用函数
fn call_animal_method(obj: &dyn Any) {
    if let Some(animal) = obj.downcast_ref::<&dyn Animal>() {
        println!("Calling method on {}:", animal.animal_type());
        animal.speak();
    } else {
        println!("Object doesn't implement Animal trait");
    }
}

fn main() {
    // 创建动物集合
    let animals: Vec<Box<dyn Animal>> = vec![
        Box::new(Dog { name: "Buddy".to_string(), breed: "Golden Retriever".to_string() }),
        Box::new(Cat { name: "Whiskers".to_string(), color: "black".to_string() }),
    ];
    
    // 遍历并调用方法
    println!("=== 基本多态示例 ===");
    for animal in &animals {
        animal.speak();
        
        // 尝试向下转型获取具体类型
        if let Some(dog) = animal.downcast_ref::<Dog>() {
            println!("It's a {} named {}", dog.breed, dog.name);
        } else if let Some(cat) = animal.downcast_ref::<Cat>() {
            println!("It's a {} cat named {}", cat.color, cat.name);
        }
    }
    
    // 使用类型擦除容器
    println!("\n=== 类型擦除容器示例 ===");
    let container = TypeErasedContainer::new(Dog {
        name: "Max".to_string(),
        breed: "Beagle".to_string(),
    });
    
    match container.downcast::<Dog>() {
        Ok(dog) => println!("Downcast成功: {} is a {}", dog.name, dog.breed),
        Err(_) => println!("Downcast失败"),
    }
    
    // 尝试错误转型
    let wrong_container = TypeErasedContainer::new(Dog {
        name: "Bella".to_string(),
        breed: "Poodle".to_string(),
    });
    
    match wrong_container.downcast::<Cat>() {
        Ok(_) => println!("这不应该发生"),
        Err(_) => println!("预期的转型失败，因为存储的是Dog不是Cat"),
    }
    
    // 动态方法调用
    println!("\n=== 动态方法调用示例 ===");
    let dog = Dog {
        name: "Rocky".to_string(),
        breed: "Bulldog".to_string(),
    };
    call_animal_method(&dog as &dyn Any);
    
    let cat = Cat {
        name: "Misty".to_string(),
        color: "gray".to_string(),
    };
    call_animal_method(&cat as &dyn Any);
    
    // 尝试调用非Animal类型
    let not_animal = 42;
    call_animal_method(&not_animal as &dyn Any);
}

这个完整示例展示了mopa库的主要功能：

1. 定义了可多态化的Animal trait，并使用mopafy宏扩展功能
2. 实现了Dog和Cat两个具体类型
3. 演示了基本的多态使用和向下转型
4. 实现了类型擦除容器TypeErasedContainer
5. 展示了动态方法调用的函数call_animal_method
6. 包含了错误处理的示例

输出结果示例：

=== 基本多态示例 ===
Buddy the Golden Retriever says: Woof!
It's a Golden Retriever named Buddy
Whiskers the black cat says: Meow!
It's a black cat named Whiskers

=== 类型擦除容器示例 ===
Downcast成功: Max is a Beagle
预期的转型失败，因为存储的是Dog不是Cat

=== 动态方法调用示例 ===
Calling method on Dog:
Rocky the Bulldog says: Woof!
Calling method on Cat:
Misty the gray cat says: Meow!
Object doesn't implement Animal trait