seq-marked 0.3.5

Sequence-numbered values with tombstone support for LSM trees and versioned data.
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

mod impl_display;
mod impl_try_from_meta_bytes;

/// Data that can be marked as tombstone.
///
/// Tombstones are always greater than normal values for ordering.
///
/// ```rust
/// use seq_marked::Marked;
///
/// let data = Marked::Normal("hello");
/// let tombstone = Marked::<&str>::TombStone;
/// assert!(tombstone > data);
/// ```
#[derive(Debug)]
#[derive(Clone, Copy)]
#[derive(PartialEq, Eq)]
#[derive(PartialOrd, Ord)]
#[cfg_attr(
    feature = "seq-marked-serde",
    derive(serde::Serialize, serde::Deserialize)
)]
#[cfg_attr(
    feature = "seq-marked-bincode",
    derive(bincode::Encode, bincode::Decode)
)]
pub enum Marked<D> {
    /// Normal data.
    // Keep `Normal` as the first variant so that `TombStone` is greater than `Normal`.
    Normal(D),

    /// Deletion marker.
    TombStone,
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_marked_is_copy() {
        let marked = Marked::Normal("data");
        let marked_copy = marked;
        assert_eq!(marked, marked_copy);
    }

    #[test]
    fn test_marked_ord() {
        let a = Marked::Normal(1u64);
        let b = Marked::TombStone;

        assert!(a < b);
        assert!(b > a);
        assert_eq!(a, a);
        assert_eq!(b, b);
    }
}

#[cfg(test)]
#[cfg(feature = "seq-marked-bincode")]
mod tests_bincode {

    use super::*;
    use crate::testing::bincode_config;
    use crate::testing::test_bincode_decode;

    #[test]
    fn test_marked_bincode() {
        let a = Marked::Normal(1u64);
        let encoded = bincode::encode_to_vec(&a, bincode_config()).unwrap();
        let (decoded, n): (Marked<u64>, usize) =
            bincode::decode_from_slice(&encoded, bincode_config()).unwrap();
        assert_eq!(n, 2);
        assert_eq!(a, decoded);
    }

    #[test]
    fn test_marked_bincode_decode_v010() -> anyhow::Result<()> {
        let value = Marked::Normal(1u64);
        let encoded = vec![0, 1];

        test_bincode_decode(&encoded, &value)?;

        let value = Marked::TombStone::<()>;
        let encoded = vec![1];

        test_bincode_decode(&encoded, &value)?;
        Ok(())
    }
}

#[cfg(test)]
#[cfg(feature = "seq-marked-serde")]
mod tests_serde {
    use super::*;
    use crate::testing::test_serde_decode;

    #[test]
    fn test_marked_serde() {
        let a = Marked::Normal(1u64);
        let encoded = serde_json::to_string(&a).unwrap();
        let decoded: Marked<u64> = serde_json::from_str(&encoded).unwrap();
        assert_eq!(a, decoded);
    }

    #[test]
    fn test_marked_serde_decode_v010() -> anyhow::Result<()> {
        let value = Marked::Normal(1u64);
        let encoded = r#"{"Normal":1}"#;

        test_serde_decode(encoded, &value)?;

        let value = Marked::TombStone::<()>;
        let encoded = r#""TombStone""#;

        test_serde_decode(encoded, &value)?;
        Ok(())
    }
}