derive_builder 0.20.2

Rust macro to automatically implement the builder pattern for arbitrary 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

#[macro_use]
extern crate derive_builder;

#[derive(Debug, PartialEq, Default, Builder, Clone)]
#[builder(pattern = "immutable")]
struct Lorem {
    immutable: u32,
    #[builder(pattern = "mutable")]
    mutable_override: u32,
}

#[derive(Debug, PartialEq, Default, Builder, Clone)]
#[builder(pattern = "mutable")]
struct Ipsum {
    mutable: u32,
    #[builder(pattern = "owned")]
    owned_override: u32,
}

#[derive(Debug, PartialEq, Default, Builder, Clone)]
#[builder(pattern = "owned")]
struct Dolor {
    #[builder(pattern = "immutable")]
    immutable_override: u32,
    owned: u32,
}

#[derive(Debug, PartialEq, Default, Builder, Clone)]
struct Sit {
    default: u32,
}

type ImmutableSetter<T, U> = fn(&T, U) -> T;
type OwnedSetter<T, U> = fn(T, U) -> T;
type MutableSetter<T, U> = fn(&mut T, U) -> &mut T;

#[test]
fn mutable_by_default() {
    // the setter must have the correct signature
    let mutable_setter: MutableSetter<SitBuilder, u32> = SitBuilder::default;

    let mut old = <SitBuilder as Default>::default();
    mutable_setter(&mut old, 42);
    assert_eq!(old.default, Some(42));
}

#[test]
fn mutable() {
    // the setter must have the correct signature
    let mutable_setter: MutableSetter<IpsumBuilder, u32> = IpsumBuilder::mutable;

    let mut old = IpsumBuilder::default();
    mutable_setter(&mut old, 42);
    assert_eq!(old.mutable, Some(42));
}

#[test]
fn mutable_override() {
    // the setter must have the correct signature
    let mutable_setter: MutableSetter<LoremBuilder, u32> = LoremBuilder::mutable_override;

    let mut old = LoremBuilder::default();
    mutable_setter(&mut old, 42);
    assert_eq!(old.mutable_override, Some(42));
}

#[test]
fn immutable() {
    // the setter must have the correct signature
    let immutable_setter: ImmutableSetter<LoremBuilder, u32> = LoremBuilder::immutable;

    let old = LoremBuilder::default();
    let new = immutable_setter(&old, 42);
    assert_eq!(new.immutable, Some(42));
}

#[test]
fn immutable_override() {
    // the setter must have the correct signature
    let immutable_setter: ImmutableSetter<DolorBuilder, u32> = DolorBuilder::immutable_override;

    let old = DolorBuilder::default();
    let new = immutable_setter(&old, 42);
    assert_eq!(new.immutable_override, Some(42));
}

#[test]
fn owned() {
    // the setter must have the correct signature
    let owned_setter: OwnedSetter<DolorBuilder, u32> = DolorBuilder::owned;

    let old = DolorBuilder::default();
    let new = owned_setter(old, 42);
    assert_eq!(new.owned, Some(42));
}

#[test]
fn owned_override() {
    // the setter must have the correct signature
    let owned_setter: OwnedSetter<IpsumBuilder, u32> = IpsumBuilder::owned_override;

    let old = IpsumBuilder::default();
    let new = owned_setter(old, 42);
    assert_eq!(new.owned_override, Some(42));
}