morphix 0.18.5

Observing and serializing mutations
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

use std::fmt::Debug;
use std::ops::{Deref, DerefMut, Index, IndexMut};

use crate::helper::quasi::DerefMutUntracked;
use crate::helper::{QuasiObserver, Zero};

pub struct ShallowMut<'ob, T: ?Sized> {
    pub(crate) inner: &'ob mut T,
    pub(crate) mutated: *mut bool,
}

impl<'ob, T: ?Sized> ShallowMut<'ob, T> {
    pub fn new(inner: &'ob mut T, mutated: *mut bool) -> Self {
        Self { inner, mutated }
    }
}

impl<'ob, T: ?Sized> Deref for ShallowMut<'ob, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.inner
    }
}

impl<'ob, T: ?Sized> DerefMut for ShallowMut<'ob, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { *self.mutated = true }
        self.inner
    }
}

impl<'ob, T: ?Sized> DerefMutUntracked for ShallowMut<'ob, T> {}

impl<'ob, T: ?Sized> QuasiObserver for ShallowMut<'ob, T> {
    type Head = T;
    type OuterDepth = Zero;
    type InnerDepth = Zero;

    fn invalidate(_: &mut Self) {}
}

impl<'ob, T: ?Sized> AsMut<T> for ShallowMut<'ob, T> {
    fn as_mut(&mut self) -> &mut T {
        self.tracked_mut()
    }
}

impl<'ob, T: Debug + ?Sized> Debug for ShallowMut<'ob, T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("ShallowMut").field(&self.untracked_ref()).finish()
    }
}

impl<'ob, T1: ?Sized, T2: ?Sized> PartialEq<ShallowMut<'ob, T2>> for ShallowMut<'ob, T1>
where
    T1: PartialEq<T2>,
{
    fn eq(&self, other: &ShallowMut<'ob, T2>) -> bool {
        self.untracked_ref().eq(other.untracked_ref())
    }
}

impl<'ob, T: Eq + ?Sized> Eq for ShallowMut<'ob, T> {}

impl<'ob, T1: ?Sized, T2: ?Sized> PartialOrd<ShallowMut<'ob, T2>> for ShallowMut<'ob, T1>
where
    T1: PartialOrd<T2>,
{
    fn partial_cmp(&self, other: &ShallowMut<'ob, T2>) -> Option<std::cmp::Ordering> {
        self.untracked_ref().partial_cmp(other.untracked_ref())
    }
}

impl<'ob, T: Ord + ?Sized> Ord for ShallowMut<'ob, T> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.untracked_ref().cmp(other.untracked_ref())
    }
}

impl<'ob, T: Index<I> + ?Sized, I> Index<I> for ShallowMut<'ob, T> {
    type Output = T::Output;

    fn index(&self, index: I) -> &Self::Output {
        self.untracked_ref().index(index)
    }
}

impl<'ob, T: IndexMut<I> + ?Sized, I> IndexMut<I> for ShallowMut<'ob, T> {
    fn index_mut(&mut self, index: I) -> &mut Self::Output {
        self.tracked_mut().index_mut(index)
    }
}

macro_rules! generic_impl_cmp {
    ($(impl $([$($gen:tt)*])? _ for $ty:ty);* $(;)?) => {
        $(
            impl<'ob, $($($gen)*,)? T: ?Sized> PartialEq<$ty> for ShallowMut<'ob, T>
            where
                T: PartialEq<$ty>,
            {
                fn eq(&self, other: &$ty) -> bool {
                    (**self).eq(other)
                }
            }

            impl<'ob, $($($gen)*,)? T: ?Sized> PartialOrd<$ty> for ShallowMut<'ob, T>
            where
                T: PartialOrd<$ty>,
            {
                fn partial_cmp(&self, other: &$ty) -> Option<std::cmp::Ordering> {
                    (**self).partial_cmp(other)
                }
            }
        )*
    };
}

generic_impl_cmp! {
    impl _ for str;
    impl _ for String;
    impl _ for std::ffi::OsStr;
    impl _ for std::ffi::OsString;
    impl _ for std::path::Path;
    impl _ for std::path::PathBuf;
    impl ['a] _ for std::borrow::Cow<'a, str>;
}