optionable 0.17.2

Derive macro (and associated marker trait) to derive nested structs/enums with all subfields being optional (e.g. for patches or Kubernetes server side apply).
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::{Optionable, OptionableConvert};

/// Merges `other` into `target` using Kubernetes-style `set` merge logic.
/// This means that all elements from `other` which are already present in `target` are discarded
/// and the other ones that are missing in `target` get appended.
pub fn merge_append_not_present<TARGET, OTHER, T>(target: &mut TARGET, other: OTHER)
where
    TARGET: Extend<T>,
    for<'a> &'a TARGET: IntoIterator<Item = &'a T>,
    OTHER: IntoIterator<Item = T>,
    T: PartialEq,
{
    for el_other in other {
        if !target.into_iter().any(|el_target| &el_other == el_target) {
            target.extend(Some(el_other));
        }
    }
}

/// Merges `other` into `target` using Kubernetes-style `set` merge logic.
/// This means that all elements from `other` which are already present in `target` are discarded
/// and the other ones that are missing in `target` get appended.
/// Handles the Option wrapping the respective type.
pub fn merge_append_not_present_option_wrapped<TARGET, OTHER, T>(
    target: &mut Option<TARGET>,
    other: Option<OTHER>,
) where
    TARGET: Extend<T>,
    for<'a> &'a TARGET: IntoIterator<Item = &'a T>,
    OTHER: IntoIterator<Item = T> + Into<TARGET>,
    T: PartialEq,
{
    if let Some(other) = other {
        if let Some(target) = target {
            merge_append_not_present(target, other);
        } else {
            *target = Some(other.into());
        }
    }
}

/// Merges `other` into `target` using Kubernetes-style `set` merge logic.
/// This means that all elements from `other` which are already present in `target` are discarded
/// and the other ones that are missing in `target` get appended.
///
/// # Errors
/// - When appending (creating a full type from an optioned one) via `OptionableConvert::try_into_optionable` fails.
pub fn try_merge_optioned_set<TARGET, OTHER, T>(
    target: &mut TARGET,
    other: OTHER,
) -> Result<(), crate::Error>
where
    TARGET: Extend<T>,
    for<'a> &'a TARGET: IntoIterator<Item = &'a T>,
    OTHER: IntoIterator<Item = T::Optioned>,
    T: OptionableConvert + PartialEq,
    T::Optioned: Sized,
{
    for el_other in other {
        let el_other = T::try_from_optioned(el_other)?;
        if !target.into_iter().any(|el_target| &el_other == el_target) {
            target.extend(Some(el_other));
        }
    }
    Ok(())
}

/// Trait for `merge_map` to check if the map keys for the respective merge candidate are equal.
pub trait MapKeysEq {
    /// Whether the keys of two map list merge candidates are equal.
    fn keys_eq(&self, other: &Self) -> bool;
}

/// Trait for `try_merge_map` to check if the map keys for the respective merge candidate are equal.
pub trait OptionableMapKeysEq: Optionable {
    /// Whether the keys of two map list merge candidates are equal.
    fn keys_eq(&self, other: &Self::Optioned) -> bool;
}

/// Merges `other` into `target` using Kubernetes-style `map` merge logic.
/// This means that all elements from `other` which are already present in `target` are merged using `OptionableConvert::merge`
/// and the other ones that are missing in `target` get appended.
/// The merge logic short circuits, i.e. only the first key match from `MapKeysEq` gets its content merged.
///
/// # Errors
/// - When merging into an existing entry via `OptionableConvert::merge_into` fails.
/// - When appending (creating a full type from an optioned one) via `OptionableConvert::try_into_optionable` fails.
pub fn try_merge_optioned_map<TARGET, OTHER, T>(
    target: &mut TARGET,
    other: OTHER,
) -> Result<(), crate::Error>
where
    TARGET: Extend<T>,
    for<'a> &'a mut TARGET: IntoIterator<Item = &'a mut T>,
    OTHER: IntoIterator<Item = T::Optioned>,
    T: OptionableConvert + OptionableMapKeysEq,
    T::Optioned: Sized,
{
    for el_other in other {
        if let Some(el_target) = target
            .into_iter()
            .find(|el_target| el_target.keys_eq(&el_other))
        {
            el_target.merge(el_other)?;
        } else {
            target.extend(Some(T::try_from_optioned(el_other)?));
        }
    }
    Ok(())
}

#[cfg(feature = "std")]
#[cfg(test)]
mod test {

    #[test]
    fn merge_set() {
        let mut target = vec![0, 1, 2];
        super::try_merge_optioned_set(&mut target, vec![3]).unwrap();
        assert_eq!(&target, &vec![0, 1, 2, 3]);
        super::try_merge_optioned_set(&mut target, vec![0, 2, 4, 6, 8]).unwrap();
        assert_eq!(&target, &vec![0, 1, 2, 3, 4, 6, 8]);
        super::try_merge_optioned_set(&mut target, vec![0, 5, 9]).unwrap();
        assert_eq!(&target, &vec![0, 1, 2, 3, 4, 6, 8, 5, 9]);
    }

    // `try_merge_map` is tested in ../tests/merge.rs
}