compris 0.0.11

Composite Primitive Schema (CPS) for Rust
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

use super::{
    super::{map::*, variant::*},
    error::*,
    mode::*,
};

use {kutil::std::error::*, std::fmt};

impl<AnnotatedT> Map<AnnotatedT> {
    /// Merge another map into this map. Return true if any change happened.
    ///
    /// The merging behavior depends on the [MergeMode].
    pub fn merge_with_errors<'own, ErrorReceiverT>(
        &mut self,
        other: &'own Self,
        merge_mode: &MergeMode,
        errors: &mut ErrorReceiverT,
    ) -> Result<bool, MergeError<'own, AnnotatedT>>
    where
        Self: 'own,
        AnnotatedT: Clone,
        ErrorReceiverT: ErrorReceiver<MergeError<'own, AnnotatedT>>,
    {
        let mut changed = false;

        for (other_key, other_value) in &other.inner {
            if self.merge_key(other_key, other_value, merge_mode, errors)? {
                changed = true;
            }
        }

        Ok(changed)
    }

    /// Merge another map into this map while failing on the first encountered error.
    /// Return true if any change happened.
    ///
    /// The merging behavior depends on the [MergeMode].
    pub fn merge_with_mode<'own>(
        &mut self,
        other: &'own Self,
        merge_mode: &MergeMode,
    ) -> Result<bool, MergeError<'own, AnnotatedT>>
    where
        AnnotatedT: Clone,
    {
        self.merge_with_errors(other, merge_mode, &mut FailFastErrorReceiver)
    }

    /// Merge another map into this map. Return true if any change happened.
    ///
    /// Uses the default [MergeMode].
    pub fn merge(&mut self, other: &Self) -> bool
    where
        AnnotatedT: Clone + fmt::Debug,
    {
        // The default mode should never cause errors, so unwrap is safe
        self.merge_with_mode(other, &Default::default()).expect("merge_with_mode")
    }

    fn merge_key<'own, ErrorReceiverT>(
        &mut self,
        other_key: &'own Variant<AnnotatedT>,
        other_value: &'own Variant<AnnotatedT>,
        merge_mode: &MergeMode,
        errors: &mut ErrorReceiverT,
    ) -> Result<bool, MergeError<'own, AnnotatedT>>
    where
        AnnotatedT: Clone,
        ErrorReceiverT: ErrorReceiver<MergeError<'own, AnnotatedT>>,
    {
        match self.inner.get_mut(other_key) {
            Some(value) => {
                // We already have the key, so merge the value
                Ok(value.merge_with_errors(other_value, merge_mode, errors)?)
            }

            None => {
                // We don't have the key, so insert it
                if self.inner.insert(other_key.clone(), other_value.clone()).is_some() {
                    if merge_mode.map == MapMergeMode::FailExisting {
                        errors.give(MergeError::new(other_key))?;
                    }
                }
                Ok(true)
            }
        }
    }
}