struct-convert 1.4.0

Auto Convert between structs
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

use struct_convert::Convert;

#[derive(Debug, Clone, PartialEq)]
struct B {
    bid: String,
    num: String,
    name: String,
}

#[derive(Debug, Clone, PartialEq)]
struct C {
    cid: Option<String>,
    num: String,
    name: String,
}

#[derive(Debug, Clone, Convert, PartialEq)]
#[convert(into = "B")]
#[convert(into = "C")]
struct A {
    #[convert_field(into = "B", rename = "bid", to_string)]
    #[convert_field(into = "C", rename = "cid", custom_fn = "wrap_id")]
    id: i64,

    #[convert_field(to_string)]
    num: i64,

    #[convert_field(unwrap)]
    name: Option<String>,
}

#[derive(Debug, Clone, Convert, PartialEq)]
#[convert(from = "B")]
#[convert(from = "C")]
struct D {
    #[convert_field(from = "B", rename = "bid", custom_fn = "to_i64")]
    #[convert_field(from = "C", rename = "cid", custom_fn = "from_cid")]
    id: i64,
    #[convert_field(wrap)]
    name: Option<String>,
}

#[derive(Debug, Clone, Convert, PartialEq)]
#[convert(into = "Bo")]
#[convert(from = "Bo")]
struct Vo {
    #[convert_field(into = "Bo", unwrap)]
    #[convert_field(from = "Bo", wrap)]
    name: Option<String>,
}

#[derive(Debug, Clone, PartialEq)]
struct Bo {
    name: String,
}

fn to_i64(b: &B) -> i64 {
    b.bid.parse::<i64>().unwrap()
}

fn from_cid(c: &C) -> i64 {
    c.clone().cid.unwrap().parse::<i64>().unwrap()
}

fn wrap_id(a: &A) -> Option<String> {
    Some(a.id.to_string())
}

fn main() {}

#[test]
fn test_multiple_convert() {
    let a = A {
        id: 2,
        num: 1,
        name: Some("Jack".to_string()),
    };
    let b: B = a.clone().into();
    debug_assert_eq!(
        B {
            num: "1".to_string(),
            bid: 2.to_string(),
            name: "Jack".to_string(),
        },
        b
    );

    let c: C = a.clone().into();
    debug_assert_eq!(
        C {
            num: "1".to_string(),
            cid: Some("2".into()),
            name: "Jack".to_string(),
        },
        c
    );

    let d: D = b.clone().into();
    debug_assert_eq!(
        D {
            id: 2,
            name: Some("Jack".to_string()),
        },
        d
    );

    let d: D = c.clone().into();
    debug_assert_eq!(
        D {
            id: 2,
            name: Some("Jack".to_string()),
        },
        d
    );

    let vo: Vo = Vo {
        name: Some("vo".to_string()),
    };
    let bo: Bo = vo.into();
    debug_assert_eq!(
        Bo {
            name: "vo".to_string()
        },
        bo
    );
    let vo2: Vo = bo.into();
    debug_assert_eq!(
        Vo {
            name: Some("vo".to_string())
        },
        vo2
    );
}