mapper

此库提供了一个方便的 derive 宏，用于实现 mapper_api::Mapper 或 std::convert::Into 特性，并生成映射而无需样板代码。

示例

use mapper::Mapper;

fn map_account_id(account_id: &u16) -> String{
    account_id.to_string()
}

#[derive(Mapper)]
#[to(Person)]
struct User{
    #[to(Person, field=_name)]
    pub name: String,
    #[to(Person, with=map_account_id)]
    pub account_id: u16,
    pub age: u8
}
struct Person{
    pub _name: String,
    pub account_id: String,
    pub age: u8
}

免责声明

• 宏仅适用于结构体
• Mapper不处理嵌套属性

默认行为

默认行为是采用注解结构体的每个字段，并通过实现 mapper_api::Mapper 特性，在目标结构体的初始化器中克隆这些字段

#[derive(Mapper)]
#[to(Person)]
struct User{
    pub name: String
}
struct Person{
    pub name: String
}

生成 🔄

impl Mapper<Person> for User{
    fn to(&self)->Person{
        Person{name: self.name.clone()}
    }
}

映射类型

有两种映射类型可供选择

• 自动映射：为在to struct attributes中指定的目标生成映射，如果未显式排除，则使用源的所有字段进行映射。如果目标已经使用了添加映射和策略，则不能使用自动映射
• 添加映射：为在to field attributes中指定的目标生成映射，仅映射注解字段。如果已经使用自动映射为目标和策略生成映射，则不能使用添加映射

映射策略

有两种映射策略可供选择

• mapper(默认), 不消耗源映射源到目标，生成 mapper_api::Mapper 的实现
• into, 通过消耗 std::convert::Into 的源映射到目标

映射到结构体属性

为指定的策略生成自动映射

• 可以通过结构体设置多个映射到属性
• 在此属性中指定一个或多个目标类型：#[to(Animal, Vehicle)]
• 在此属性中指定一个或多个映射策略：#[to(Animal, strategy=into, strategy=mapper)]

映射到字段属性

在父结构体上完成自动映射配置集，提供附加映射或排除字段从任何映射

• 可以通过字段设置多个映射到属性
• 如果只使用 DestinationType，则禁止此属性

DestinationType

映射目标类型。除非字段无条件排除，否则为必选参数。

泛型

您可以使用泛型指定目标类型，这些泛型应与源结构体字段兼容

#[derive(Mapper)]
#[to(Person::<String, u8>)]
struct User {
    name: String,
    age: u8
}
struct Person<T, U> {
    name: T,
    age: U
}

策略

触发映射目标类型和指定策略的附加映射

#[derive(Mapper)]
struct User(#[to(Person, strategy=into)]u16, String);
struct Person(u16);

生成 🔄

impl Into<Person> for User{
    fn into(self)->Person{
        Person{0:self.0}
    }
}

排除

可选参数，指定字段是否排除映射，有2种排除方式。

• 无条件排除，排除任何类型映射的字段，例如

#[derive(Mapper)]
#[to(Person)]
struct User(u16, #[to(exclude)]String);
struct Person(u16);

生成 🔄

impl Mapper<Person> for User{
    fn into(self)->Person{
        Person{0:self.0}
    }
}

• 特定目标排除（⚠️对于附加映射不适用），排除特定目标映射的字段，例如

#[derive(Mapper)]
#[to(Person,Account, strategy=into)]
struct User(u16, #[to(Person,exclude)]String);
struct Account(u16, String);
struct Person(u16);

生成 🔄

impl Into<Person> for User{
    fn into(self)->Person{
        Person{0:self.0}
    }
}
impl Into<Account> for User{
    fn into(self)->Account{
        Account{0:self.0, 1: self.1}
    }
}

字段

可选参数，针对目标类型字段

#[derive(Mapper)]
#[to(Person)]
struct User{
    #[to(Person, field=0)
    name: String
};
struct Person( String);

生成 🔄

impl Mapper<Person> for User{
    fn to(&self)->Person{
        Person{0:self.name.clone()}
    }
}

With

可选参数，提供一个函数将注解字段转换为目标字段。如果您在 without 指定策略的情况下使用 with： with 默认将使用 mapper 策略。函数的签名应与使用的策略相关

• with(mapper) | with

fn foo_mapping(val: &<src_field_type>)-><dst_field_type>

• with(into)

fn foo_mapping(val: <src_field_type>)-><dst_field_type>

泛型

如果泛型类型约束与源字段类型和目标字段类型兼容，则可以在您的函数中使用泛型

    fn gen_func<T: Display>(val: &T)->String{
        val.to_string()
    }
    #[derive(Mapper)]
    #[to(Person)]
    struct User {
        #[to(Person, with=gen_func)]
        age: u16,
    }
    struct Person {
        age: String,
    }

许可：MIT OR Apache-2.0