Rust宏编程库metastruct_macro的使用：高效元数据结构生成与代码转换

metastruct简介

metastruct是一个用于结构体字段元编程的Rust库。通过metastruct可以实现以下功能：

• 遍历结构体的字段
• 对所有或部分结构体字段应用闭包
• 通过const在编译时访问结构体的字段数量

这些功能是通过一个生成macro_rules!宏的过程宏实现的。

可以将metastruct理解为编写自定义derive宏的快捷方式。如果你有一个想要一次性实现的trait，metastruct可以帮助你在不编写derive宏的情况下实现它。

当前状态

⚠️ 施工中 ⚠️

该库目前正在开发中，不应被视为稳定版本。目前除了少量代码注释和示例/测试外，没有其他文档。

安装

在项目目录中运行以下Cargo命令：

cargo add metastruct_macro

或者在Cargo.toml中添加以下行：

metastruct_macro = "0.1.3"

示例使用

下面是一个使用metastruct_macro的完整示例：

use metastruct_macro::metastruct;

// 定义一个结构体并使用metastruct宏
#[metastruct]
struct Person {
    name: String,
    age: u32,
    active: bool,
}

fn main() {
    // 创建结构体实例
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
        active: true,
    };
    
    // 使用生成的宏访问字段信息
    println!("Field count: {}", Person::FIELD_COUNT);
    
    // 遍历字段
    Person::for_each_field(|name, ty| {
        println!("Field {} has type {}", name, ty);
    });
    
    // 映射字段
    let field_types = Person::map_fields(|name, _| name.to_string());
    println!("Field names: {:?}", field_types);
}

完整示例代码

use metastruct_macro::metastruct;

// 定义一个更复杂的使用示例
#[metastruct]
struct Config {
    debug_mode: bool,
    max_connections: usize,
    timeout: u64,
    hostname: String,
    port: u16,
}

impl Config {
    fn display_fields(&self) {
        Config::for_each_field(|name, _| {
            println!("{}: {:?}", name, self.get_field(name));
        });
    }
    
    // 注意：实际get_field方法需要根据metastruct生成的API实现
    fn get_field(&self, name: &str) -> String {
        match name {
            "debug_mode" => self.debug_mode.to_string(),
            "max_connections" => self.max_connections.to_string(),
            "timeout" => self.timeout.to_string(),
            "hostname" => self.hostname.clone(),
            "port" => self.port.to_string(),
            _ => "Unknown field".to_string(),
        }
    }
}

fn main() {
    let config = Config {
        debug_mode: true,
        max_connections: 100,
        timeout: 30,
        hostname: "example.com".to_string(),
        port: 8080,
    };
    
    println!("Config has {} fields", Config::FIELD_COUNT);
    config.display_fields();
    
    // 使用映射功能生成字段类型信息
    let field_info: Vec<String> = Config::map_fields(|name, ty| {
        format!("{}: {}", name, ty)
    });
    
    println!("Field info:");
    for info in field_info {
        println!("- {}", info);
    }
}

完整示例demo

下面是一个更完整的示例，展示了metastruct_macro的更多用法：

use metastruct_macro::metastruct;

// 定义一个包含不同类型字段的结构体
#[metastruct]
struct Product {
    id: u64,
    name: String,
    price: f64,
    in_stock: bool,
    categories: Vec<String>,
}

impl Product {
    // 打印所有字段信息
    pub fn print_info(&self) {
        println!("Product Details:");
        Product::for_each_field(|name, ty| {
            println!("  {} ({}): {:?}", name, ty, self.get_field_value(name));
        });
    }

    // 获取字段值
    fn get_field_value(&self, name: &str) -> String {
        match name {
            "id" => self.id.to_string(),
            "name" => self.name.clone(),
            "price" => format!("{:.2}", self.price),
            "in_stock" => self.in_stock.to_string(),
            "categories" => format!("{:?}", self.categories),
            _ => "Unknown field".to_string(),
        }
    }

    // 检查字段是否存在
    pub fn has_field(&self, name: &str) -> bool {
        let fields = Product::map_fields(|n, _| n.to_string());
        fields.contains(&name.to_string())
    }
}

fn main() {
    let product = Product {
        id: 12345,
        name: "Rust Programming Book".to_string(),
        price: 39.99,
        in_stock: true,
        categories: vec!["Programming".to_string(), "Rust".to_string()],
    };

    // 使用metastruct生成的功能
    println!("Product has {} fields", Product::FIELD_COUNT);
    product.print_info();

    // 检查字段是否存在
    println!("Has field 'price': {}", product.has_field("price"));
    println!("Has field 'discount': {}", product.has_field("discount"));

    // 生成字段类型映射
    let type_map: Vec<(String, String)> = Product::map_fields(|name, ty| {
        (name.to_string(), ty.to_string())
    });
    
    println!("\nField types:");
    for (name, ty) in type_map {
        println!("  {} => {}", name, ty);
    }

    // 使用字段过滤功能
    let numeric_fields = Product::map_fields(|name, ty| {
        if ty == "u64" || ty == "f64" {
            Some((name.to_string(), ty.to_string()))
        } else {
            None
        }
    }).into_iter().flatten().collect::<Vec<_>>();
    
    println!("\nNumeric fields:");
    for (name, ty) in numeric_fields {
        println!("  {}: {}", name, ty);
    }
}

许可证

Apache 2.0