fieldx 0.2.3

Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax.
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

// Make sure inner_mut doesn't break copy and clone getters

use fieldx::fxstruct;

#[cfg(feature = "sync")]
#[fxstruct(sync, builder, set, get_mut)]
struct Foo {
    #[fieldx(inner_mut, get(copy))]
    m1: u32,

    #[fieldx(inner_mut, get(clone))]
    m2: String,

    #[fieldx(lazy, inner_mut, get(copy), builder(off))]
    m3: i32,
}

#[cfg(feature = "sync")]
impl Foo {
    fn build_m3(&self) -> i32 {
        42
    }
}

#[fxstruct(builder, set, get_mut)]
struct Bar {
    #[fieldx(inner_mut, get(copy))]
    m1: u32,

    #[fieldx(inner_mut, get(clone))]
    m2: String,

    #[fieldx(lazy, inner_mut, get(copy), builder(off))]
    m3: i32,
}

impl Bar {
    fn build_m3(&self) -> i32 {
        42
    }
}

#[test]
#[cfg(feature = "sync")]
fn basic_sync() {
    let foo = Foo::builder()
        .m1(42)
        .m2("from builder".to_string())
        .build()
        .expect("Builder failed");

    assert_eq!(foo.m1(), 42);
    assert_eq!(foo.m2(), "from builder".to_string());

    foo.set_m1(12);

    *foo.m2_mut() = "from user".to_string();
    assert_eq!(foo.m2(), "from user");

    assert_eq!(foo.m3(), 42);
    *foo.m3_mut() = 12;
    assert_eq!(foo.m3(), 12);
}

#[test]
fn basic_plain() {
    let bar = Bar::builder()
        .m1(42)
        .m2("from builder".to_string())
        .build()
        .expect("Builder failed");

    assert_eq!(bar.m1(), 42);
    assert_eq!(bar.m2(), "from builder".to_string());

    *bar.m2_mut() = "from user".to_string();
    assert_eq!(bar.m2(), "from user");

    assert_eq!(bar.m3(), 42);
    *bar.m3_mut() = 12;
    assert_eq!(bar.m3(), 12);
}