default-conversion 0.2.0

A derive macro to automatic implement conversions between similar 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

use default_conversion::*;

#[test]
fn basic_struct() {
    #[derive(Debug, PartialEq, Eq, Default)]
    struct B {
        a: i32,
    };

    #[derive(Debug, PartialEq, Eq, Default, IntoDefault)]
    #[IntoStruct(B)]
    struct InputB {
        a: i32,
    };

    #[derive(Debug, PartialEq, Eq, Default)]
    struct A {
        a: String,
        b: i32,
        c: B,
        d: B,
        e: B,
        f: Option<B>,
        g: Option<B>,
        h: Option<B>,
        i: Vec<B>,
        j: Vec<B>,
    };

    #[derive(Debug, PartialEq, Eq, Default, IntoDefault)]
    #[IntoStruct(A)]
    struct InputA {
        a: String,
        b: i32,
        c: InputB,
        d: Option<InputB>,
        e: Option<InputB>,
        f: Option<InputB>,
        g: Option<InputB>,
        h: InputB,
        i: Vec<InputB>,
        j: InputB,
    };

    let a = InputA {
        a: String::from("test"),
        b: 2,
        c: InputB { a: 3 },
        d: Some(InputB { a: 4 }),
        e: None,
        f: Some(InputB { a: 5 }),
        g: None,
        h: InputB { a: 6 },
        i: vec!{InputB{a: 7}},
        j: InputB { a: 8},
    };

    assert_eq!(
        A {
            a: String::from("test"),
            b: 2,
            c: B { a: 3 },
            d: B { a: 4 },
            e: B { a: 0 },
            f: Some(B { a: 5 }),
            g: None,
            h: Some(B { a: 6 }),
            i: vec!{B{a: 7}},
            j: vec!{B{a: 8}},
        },
        A::from(a)
    );
}