delve 0.3.0

Provides a number of macros that make working with enums and strings more convenient.
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

use delve::ModifyField;
use delve_derive::EnumModify;

#[test]
fn test_plain() {
    #[derive(Debug, PartialEq, EnumModify)]
    #[allow(dead_code)]
    enum Week {
        Sunday,
        Monday,
        Tuesday,
        Wednesday(String),
        Thursday { good: bool, foo: usize },
        Friday,
        Saturday,
    }

    let mut wed = Week::Wednesday("true".into());

    assert_eq!(Some(&"true".into()), wed.get_field(0));

    wed.set_field(0, "false".into());

    assert_eq!(Some(&"false".into()), wed.get_field(0));

    assert_eq!(None, wed.get_field(100));

    /////

    let mut thurs = Week::Thursday {
        good: false,
        foo: 0,
    };

    assert_eq!(Some(&false), thurs.get_field("good"));

    thurs.set_field("good", true);

    assert_eq!(Some(&true), thurs.get_field("good"));

    assert_eq!(
        None,
        <Week as ModifyField<&str, bool>>::get_field(&thurs, "bar")
    );
}

#[test]
fn test_attrs() {
    #[derive(Debug, PartialEq, EnumModify)]
    #[allow(dead_code)]
    #[delve(rename_fields = "uppercase")]
    enum Week<'a, T> {
        Sunday(String, #[delve(skip)] &'a T),
        Monday,
        Tuesday,
        Wednesday(String),
        Thursday {
            #[delve(skip)]
            good: bool,
            #[delve(rename_field = "foo")]
            foo: usize,
            bar: bool,
        },
        Friday,
        Saturday,
    }

    let sun: Week<bool> = Week::Sunday("true".into(), &true);

    assert_eq!(Some(&"true".into()), sun.get_field(0));

    assert_eq!(None, sun.get_field(1));

    /////

    let thurs: Week<bool> = Week::Thursday {
        good: false,
        foo: 0,
        bar: true,
    };

    assert_eq!(Some(&0), thurs.get_field("foo"));

    assert_eq!(Some(&true), thurs.get_field("BAR"));

    assert_eq!(
        None,
        <Week<bool> as ModifyField<&str, bool>>::get_field(&thurs, "bar")
    );
}

#[test]
fn test_resolve() {
    type Foo = u16;
    type Bar = u16;

    #[derive(Debug, PartialEq, EnumModify)]
    #[allow(dead_code)]
    #[delve(rename_fields = "uppercase")]
    #[delve(resolve(Foo, u16), resolve(Bar, u16))]
    enum Week {
        Sunday,
        Monday { a: Foo, b: Bar },
        Tuesday,
        Thursday,
        Friday,
        Saturday,
    }
}