modify 0.1.3

A library to track changes of a value.
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

//! Adds a modify flag to an object.

#[cfg(test)]
mod tests;

use std::{
    fmt::Display,
    ops::{Deref, DerefMut},
};

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// Interface for modifiable objects.
pub trait Modifiable {
    /// Return `true` if the object was modified.
    fn is_modified(&self) -> bool;
}

/// Modifiable object
/// Implements `Deref` and `DerefMut` to access the value and
/// adds a flag to indicate if the object was modified.
/// # Example
/// ```
/// use crate::modify::*;
/// let mut value = Modify::new(42);
/// assert_eq!(value.is_modified(), false);
/// *value = 43;
/// assert_eq!(value.is_modified(), true);
/// value.saved();
/// assert_eq!(value.is_modified(), false);
/// ```
/// if you use serde you should use `#[serde(flatten)}` for your
/// `Modify<>` attribute  to avoid the extra level of indirection.
#[derive(Default, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(transparent))]
pub struct Modify<T> {
    /// Value of the object
    value: T,
    /// Flag that is `true` if the object was modified.
    #[cfg_attr(feature = "serde", serde(skip))]
    modified: bool,
}

impl<T> Modify<T> {
    /// Create a new modifiable object.
    pub fn new(value: T) -> Self {
        Self {
            value,
            modified: false,
        }
    }
    /// Clear the modified flag.
    pub fn saved(&mut self) {
        self.modified = false;
    }
}

impl<T> Modifiable for Modify<T> {
    fn is_modified(&self) -> bool {
        self.modified
    }
}

impl<T> Display for Modify<T>
where
    T: Display,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.value)
    }
}

impl<T> From<T> for Modify<T> {
    fn from(value: T) -> Self {
        Self::new(value)
    }
}

impl<T> Deref for Modify<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

impl<T> DerefMut for Modify<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.modified = true;
        &mut self.value
    }
}