muon 0.20.1

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

use std::marker::PhantomData;

use crate::general::{DebugHandler, GeneralHandler, GeneralObserver, ReplaceHandler};
use crate::helper::{AsDeref, Invalidate, Zero};

/// A general observer that never reports changes.
///
/// [`NoopObserver`] is a no-operation [`Observer`](crate::observe::Observer) that always returns
/// [`None`] when collecting changes, effectively ignoring all mutations to the observed value.
///
/// ## Derive Usage
///
/// Can be used via the `#[muon(noop)]` attribute in derive macros:
///
/// ```
/// # use muon::Observe;
/// # use serde::Serialize;
/// #[derive(Serialize, Observe)]
/// struct MyStruct {
///     important_field: String,
///     #[muon(noop)]
///     cache: String,      // Changes to cache are not tracked
/// }
/// ```
///
/// ## When to Use
///
/// Use [`NoopObserver`] for fields that:
/// - Are only used internally and not part of the public state
/// - Should not trigger change notifications.
pub type NoopObserver<'ob, S, D = Zero> = GeneralObserver<'ob, NoopHandler<<S as AsDeref<D>>::Target>, S, D>;

pub struct NoopHandler<T: ?Sized>(PhantomData<T>);

impl<T: ?Sized> Invalidate<T> for NoopHandler<T> {
    fn invalidate(&mut self, _: &T) {}
}

impl<T: ?Sized> GeneralHandler for NoopHandler<T> {
    type Target = T;

    fn observe(_value: &T) -> Self {
        Self(PhantomData)
    }
}

impl<T: ?Sized> ReplaceHandler for NoopHandler<T> {
    fn is_replace(&self, _value: &T) -> bool {
        false
    }
}

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