struct-patch 0.10.5

A library that helps you implement partial updates for your 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

#[cfg(feature = "op")]
fn main() {
    use std::collections::{
        BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque,
    };
    use std::iter::{Extend, IntoIterator};
    use struct_patch::Filler;

    #[derive(Clone, Default, Filler)]
    #[filler(attribute(derive(Clone, Debug, Default)))]
    struct Item {
        _field_complete: bool,
        // Will check the field is equal to the value to define the field is empty or not
        #[filler(empty_value = 0)]
        // Will allow field add each other when `+` on fillers
        #[filler(addable)]
        field_int: usize,
        _field_string: String,
        maybe_field_int: Option<usize>,
        maybe_field_string: Option<String>,
        // Will allow field extend each other when `+` on fillers
        #[filler(addable)]
        list: Vec<usize>,
        _deque: VecDeque<usize>,
        _linked_list: LinkedList<usize>,
        _map: HashMap<usize, usize>,
        _bmap: BTreeMap<usize, usize>,
        _set: HashSet<usize>,
        _bset: BTreeSet<usize>,
        _heap: BinaryHeap<usize>,
    }

    let item = Item::default();

    let mut filler1: ItemFiller = Item::new_empty_filler();
    filler1.field_int = 7;
    filler1.list = vec![1, 2];

    let mut filler2: ItemFiller = Item::new_empty_filler();
    filler2.field_int = 8;
    filler2.list = vec![3, 4];
    filler2.maybe_field_string = Some("Something".into());

    let final_item_from_added_fillers = item.clone() << (filler1.clone() + filler2.clone());

    assert_eq!(final_item_from_added_fillers.field_int, 15);
    assert_eq!(final_item_from_added_fillers.list, vec![1, 2, 3, 4]);
    assert_eq!(
        final_item_from_added_fillers.maybe_field_string,
        Some("Something".into())
    );

    let final_item_after_fillers_applied = item << filler1 << filler2;

    assert_eq!(final_item_after_fillers_applied.field_int, 7);
    assert_eq!(final_item_after_fillers_applied.list, vec![1, 2]);
    assert_eq!(
        final_item_after_fillers_applied.maybe_field_string,
        Some("Something".into())
    );
}

#[cfg(not(feature = "op"))]
fn main() {}