model-mapper 0.7.1

Derive macro to map between different types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

#![allow(dead_code)]

use model_mapper::Mapper;

#[derive(Clone)]
struct Foo {
    field1: String,
    field2: i64,
}

// Skipped fields doesn't affect 'into' derives, they're just ignored
#[derive(Debug, PartialEq, Eq, Mapper)]
#[mapper(into, ty = Foo)]
struct Bar1 {
    field1: String,
    field2: i64,
    #[mapper(skip)]
    field3: i64,
    #[mapper(skip)]
    field4: Option<String>,
}

// But for 'from' derives we need a way of populating its value
#[derive(Debug, PartialEq, Eq, Mapper)]
#[mapper(from, ty = Foo)]
struct Bar2 {
    field1: String,
    field2: i64,
    // Using other values
    #[mapper(skip(default(value = field2 / 2)))]
    field3: i64,
    // Or just with the default, None in this case
    #[mapper(skip(default))]
    field4: Option<String>,
}

// We can also implement a custom function instead, that will require the additional fields at runtime:
#[derive(Debug, PartialEq, Eq, Mapper)]
#[mapper(from(custom = "from_foo_custom"), ty = Foo)]
struct Bar3 {
    field1: String,
    field2: i64,
    #[mapper(skip)]
    field3: i64,
    #[mapper(skip)]
    field4: Option<String>,
}
// impl Bar3 {
//     pub fn from_foo_custom(from: Foo, field3: i64, field4: Option<String>) -> Self {
//         let Foo { field1, field2 } = from;
//         Self { field1, field2, field3, field4 }
//     }
// }

// Or even mix both options
#[derive(Debug, PartialEq, Eq, Mapper)]
#[mapper(from(custom), ty = Foo)]
struct Bar4 {
    field1: String,
    field2: i64,
    #[mapper(skip(default(value = field2 / 2)))]
    field3: i64,
    #[mapper(skip)]
    field4: Option<String>,
}
// impl Bar4 {
//     pub fn from_foo(from: Foo, field4: Option<String>) -> Self {
//         let Foo { field1, field2 } = from;
//         Self {
//             field1,
//             field2,
//             field3: field2 / 2,
//             field4,
//         }
//     }
// }

#[derive(Default)]
enum FooEnum {
    #[default]
    One,
    Two,
}

// For enums, the 'from' derive doesn't require anything but the 'into' requires to provide default values or to
// implement the default trait
#[derive(Mapper)]
#[mapper(into, ty = FooEnum)]
enum BarEnum {
    One,
    Two,
    // We can provide a value and avoid the need of the default trait
    #[mapper(skip(default(value = FooEnum::Two)))]
    Three,
    // Or rely on the default
    #[mapper(skip(default))]
    Four,
}
// impl From<BarEnum> for FooEnum {
//     fn from(other: BarEnum) -> Self {
//         match other {
//             BarEnum::One => FooEnum::One,
//             BarEnum::Two => FooEnum::Two,
//             BarEnum::Three => FooEnum::Two,
//             BarEnum::Four => FooEnum::default(),
//         }
//     }
// }

fn main() {
    let source = Foo {
        field1: "val".into(),
        field2: 2,
    };

    let mapped = Bar2::from(source.clone());
    assert_eq!(
        Bar2 {
            field1: "val".into(),
            field2: 2,
            field3: 1,
            field4: None,
        },
        mapped
    );

    let mapped = Bar3::from_foo_custom(source.clone(), 1, None);
    assert_eq!(
        Bar3 {
            field1: "val".into(),
            field2: 2,
            field3: 1,
            field4: None,
        },
        mapped
    );

    let mapped = Bar4::from_foo(source, None);
    assert_eq!(
        Bar4 {
            field1: "val".into(),
            field2: 2,
            field3: 1,
            field4: None,
        },
        mapped
    );
}