sem-reg 0.1.1

Handle certain Windows registry binary values semantically. Extensible.
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

pub(crate) mod byte_seq;
pub(crate) mod format;
pub mod hex_bytes;
pub(crate) mod time;

pub use byte_seq::ParseError;

use std::ops::Deref;

#[derive(Debug)]
pub struct TrackedValue<T: PartialEq> {
    old: T,
    new: Option<T>,
}

impl<T: PartialEq> TrackedValue<T> {
    pub fn new(value: T) -> Self {
        Self {
            old: value,
            new: None,
        }
    }

    pub fn set(&mut self, value: T) {
        self.new = Some(value);
    }

    pub fn reset(&mut self) {
        self.new = None;
    }

    pub fn changed(&self) -> bool {
        if let Some(new) = &self.new {
            *new != self.old
        } else {
            false
        }
    }
}

impl<T: PartialEq> Deref for TrackedValue<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.new.as_ref().unwrap_or(&self.old)
    }
}

impl<T: PartialEq> PartialEq for TrackedValue<T> {
    fn eq(&self, other: &Self) -> bool {
        self.new
            .as_ref()
            .unwrap_or(&self.old)
            .eq(other.new.as_ref().unwrap_or(&other.old))
    }
}

/// The mode of operation when parsing and checking values for validity.
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Strictness {
    /// Only accept known formats exact to the byte, and only value ranges last known to be valid. Should normally be used.
    Strict,
    /// Turn a blind eye regarding certain aspects when parsing or checking values for validity. Can be tried when strict mode doesn't work, or when you must overcome certain limitations. Doesn't influence serialization. Rather than this being used regularly, the parsing or other code should be updated.
    Lenient,
}

impl Strictness {
    pub fn from_lenient_bool(lenient: bool) -> Self {
        if lenient {
            Self::Lenient
        } else {
            Self::Strict
        }
    }

    pub fn is_strict(&self) -> bool {
        *self == Strictness::Strict
    }

    pub fn is_lenient(&self) -> bool {
        *self == Strictness::Lenient
    }
}

pub trait ResultOrElseIf<T, E> {
    fn or_else_if<O>(self, flag: bool, op: O) -> Result<T, E>
    where
        O: FnOnce(E) -> Result<T, E>;
}

impl<T, E> ResultOrElseIf<T, E> for Result<T, E> {
    fn or_else_if<O>(self, flag: bool, op: O) -> Result<T, E>
    where
        O: FnOnce(E) -> Result<T, E>,
    {
        match self {
            Ok(t) => Ok(t),
            Err(e) => {
                if flag {
                    op(e)
                } else {
                    Err(e)
                }
            }
        }
    }
}