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

use std::ptr::NonNull;

use crate::Observe;
use crate::general::{DebugHandler, GeneralHandler, GeneralObserver, ReplaceHandler};
use crate::helper::macros::default_impl_ref_observe;
use crate::helper::{AsDeref, AsDerefMut, ObserverState, Unsigned};
use crate::observe::DefaultSpec;

/// A general observer implementation for reference types.
///
/// This observer stores the initial pointer value and compares it with the current value at
/// collection time using [`std::ptr::eq`]. A change is detected if the reference now points to a
/// different memory location.
///
/// ## Limitations
///
/// - **False negatives**: If the referenced value contains interior mutability and is mutated
///   without changing the pointer, the mutation will not be detected.
/// - **False positives**: If two distinct references point to equal values, changing from one to
///   the other will be detected as a change, even if the underlying value is effectively the same.
///
/// ## When to Use
///
/// Use [`PointerObserver`] for types where:
/// 1. Pointer identity is a reliable indicator of value identity
/// 2. Value comparison is expensive or unavailable
/// 3. The type has no interior mutability
///
/// For types where value comparison is cheap and preferred, consider using
/// [`SnapshotObserver`](crate::general::SnapshotObserver) for references.
pub type PointerObserver<'ob, S, D> = GeneralObserver<'ob, PointerHandler<<S as AsDeref<D>>::Target>, S, D>;

pub struct PointerHandler<T: ?Sized> {
    ptr: Option<NonNull<T>>,
}

impl<T: ?Sized> ObserverState for PointerHandler<T> {
    type Target = T;

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

impl<T: ?Sized> GeneralHandler for PointerHandler<T> {
    fn observe(value: &T) -> Self {
        Self {
            ptr: Some(NonNull::from(value)),
        }
    }
}

impl<T: ?Sized> ReplaceHandler for PointerHandler<T> {
    unsafe fn is_replace(&self, value: &T) -> bool {
        !std::ptr::eq(
            value,
            self.ptr
                .expect("pointer should not be null in GeneralHandler::flush")
                .as_ptr(),
        )
    }
}

impl<T: ?Sized> DebugHandler for PointerHandler<T> {
    const NAME: &'static str = "PointerObserver";
}

impl Observe for std::fmt::Arguments<'_> {
    type Observer<'ob, S, D>
        = PointerObserver<'ob, S, D>
    where
        Self: 'ob,
        D: Unsigned,
        S: AsDerefMut<D, Target = Self> + ?Sized + 'ob;

    type Spec = DefaultSpec;
}

default_impl_ref_observe! {
    impl RefObserve for std::fmt::Arguments<'_>;
}