Rust动态类型处理库dynosaur_derive的使用指南

概述

dynosaur_derive是一个Rust过程宏库，用于实现运行时反射和动态对象操作。它通过派生宏自动为结构体生成必要的trait实现，使开发者能够在运行时检查和操作类型信息。

主要功能

• 运行时类型反射
• 动态字段访问和修改
• 类型信息查询
• 序列化和反序列化支持

安装方法

在Cargo.toml中添加依赖：

[dependencies]
dynosaur_derive = "0.1"
dynosaur = "0.1"

基本用法

1. 为结构体添加派生宏

use dynosaur_derive::Dynosaur;

#[derive(Dynosaur)]
struct Person {
    name: String,
    age: u32,
    active: bool,
}

2. 运行时类型信息查询

use dynosaur::Dynosaur;

let person = Person {
    name: "Alice".to_string(),
    age: 30,
    active: true,
};

// 获取类型名称
println!("Type name: {}", person.type_name());

// 检查字段是否存在
if person.has_field("name") {
    println!("Field 'name' exists");
}

3. 动态字段访问

// 获取字段值
if let Some(value) = person.get_field("age") {
    println!("Age: {:?}", value);
}

// 设置字段值
let mut person = person;
person.set_field("age", 31).unwrap();
println!("Updated age: {}", person.age);

4. 字段迭代

for (field_name, field_value) in person.fields() {
    println!("{}: {:?}", field_name, field_value);
}

高级用法

嵌套结构体支持

#[derive(Dynosaur)]
struct Address {
    street: String,
    city: String,
}

#[derive(Dynosaur)]
struct Company {
    name: String,
    address: Address,
    employees: Vec<Person>,
}

自定义类型处理

#[derive(Dynosaur)]
#[dynosaur(rename_all = "camelCase")]
struct UserProfile {
    user_name: String,
    is_verified: bool,
    created_at: DateTime<Utc>,
}

错误处理

match person.set_field("nonexistent", value) {
    Ok(_) => println!("Field set successfully"),
    Err(e) => println!("Error: {}", e),
}

注意事项

1. 仅支持命名结构体（struct with named fields）
2. 所有字段类型必须实现必要的trait
3. 对于复杂类型，可能需要额外的trait实现

完整示例

use dynosaur_derive::Dynosaur;
use dynosaur::Dynosaur;

#[derive(Dynosaur, Debug)]
struct Config {
    timeout: u64,
    retries: u32,
    enabled: bool,
}

fn main() {
    let mut config = Config {
        timeout: 1000,
        retries: 3,
        enabled: true,
    };

    // 动态修改配置
    config.set_field("timeout", 2000).unwrap();
    config.set_field("enabled", false).unwrap();

    // 打印所有字段
    for (name, value) in config.fields() {
        println!("{}: {:?}", name, value);
    }
}

这个库特别适合需要动态配置、运行时对象操作或实现插件系统的场景。

完整示例demo

// 导入必要的库
use dynosaur_derive::Dynosaur;
use dynosaur::Dynosaur;
use std::collections::HashMap;

// 定义Person结构体并派生Dynosaur trait
#[derive(Dynosaur, Debug, Clone)]
struct Person {
    name: String,
    age: u32,
    active: bool,
    metadata: HashMap<String, String>, // 复杂类型示例
}

// 定义Address结构体
#[derive(Dynosaur, Debug)]
struct Address {
    street: String,
    city: String,
    zip_code: String,
}

fn main() {
    // 创建Person实例
    let mut person = Person {
        name: "张三".to_string(),
        age: 28,
        active: true,
        metadata: HashMap::from([
            ("department".to_string(), "engineering".to_string()),
            ("level".to_string(), "senior".to_string()),
        ]),
    };

    println!("=== 类型信息查询 ===");
    // 获取类型名称
    println!("类型名称: {}", person.type_name());
    
    // 检查字段是否存在
    println!("是否存在name字段: {}", person.has_field("name"));
    println!("是否存在不存在的字段: {}", person.has_field("nonexistent"));

    println!("\n=== 动态字段访问 ===");
    // 获取字段值
    if let Some(value) = person.get_field("age") {
        println!("年龄字段值: {:?}", value);
    }

    // 设置字段值
    person.set_field("age", 29).unwrap();
    println!("更新后的年龄: {}", person.age);

    // 设置复杂类型字段
    let mut new_metadata = person.metadata.clone();
    new_metadata.insert("project".to_string(), "dynosaur".to_string());
    person.set_field("metadata", new_metadata).unwrap();

    println!("\n=== 字段迭代 ===");
    // 迭代所有字段
    for (field_name, field_value) in person.fields() {
        println!("字段 {}: {:?}", field_name, field_value);
    }

    println!("\n=== 嵌套结构体示例 ===");
    // 创建Address实例
    let mut address = Address {
        street: "科技路".to_string(),
        city: "北京".to_string(),
        zip_code: "100000".to_string(),
    };

    // 动态修改地址信息
    address.set_field("city", "上海".to_string()).unwrap();
    println!("更新后的城市: {}", address.city);

    println!("\n=== 错误处理示例 ===");
    // 尝试设置不存在的字段
    match person.set_field("nonexistent_field", "value") {
        Ok(_) => println!("字段设置成功"),
        Err(e) => println!("错误: {}", e),
    }

    // 尝试设置类型不匹配的字段值
    match person.set_field("age", "不是数字") {
        Ok(_) => println!("字段设置成功"),
        Err(e) => println!("错误: {}", e),
    }

    println!("\n=== 完整信息展示 ===");
    println!("{:#?}", person);
}

// 测试函数
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dynamic_field_access() {
        let mut person = Person {
            name: "测试用户".to_string(),
            age: 25,
            active: false,
            metadata: HashMap::new(),
        };

        // 测试字段存在性检查
        assert!(person.has_field("name"));
        assert!(!person.has_field("nonexistent"));

        // 测试字段值获取
        assert!(person.get_field("age").is_some());

        // 测试字段值设置
        person.set_field("active", true).unwrap();
        assert!(person.active);
    }
}

这个完整的示例展示了dynosaur_derive库的主要功能，包括：

1. 基本类型支持：字符串、数字、布尔值等基本类型的动态操作
2. 复杂类型支持：HashMap等复杂类型的处理
3. 错误处理：处理字段不存在和类型不匹配的情况
4. 字段迭代：遍历所有字段及其值
5. 测试用例：包含基本的单元测试

要运行此示例，请确保在Cargo.toml中添加了正确的依赖项，并且所有字段类型都实现了所需的trait。