sst 0.24.0

SST provides a sorted string table abstraction.
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

//! A Setsum type that's more ergonomic for working with key-value pairs.

use setsum::Setsum as RawSetsum;

pub use setsum::SETSUM_BYTES;

use super::KeyValueRef;

////////////////////////////////////////////// Setsum //////////////////////////////////////////////

/// A wrapper around the Setsum type that provides methods to uniformly insert KeyValueRef, or
/// put/del key-value pairs.
#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash)]
pub struct Setsum {
    setsum: RawSetsum,
}

impl Setsum {
    /// The digest of this setsum.
    pub fn digest(&self) -> [u8; 32] {
        self.setsum.digest()
    }

    /// Build this setsum from a digest.
    pub fn from_digest(digest: [u8; SETSUM_BYTES]) -> Setsum {
        let setsum = RawSetsum::from_digest(digest);
        Self { setsum }
    }

    /// The hexdigest of this setsum.
    pub fn hexdigest(&self) -> String {
        self.setsum.hexdigest()
    }

    /// Build this setsum from a hexdigest.
    pub fn from_hexdigest(digest: &str) -> Option<Setsum> {
        let setsum = RawSetsum::from_hexdigest(digest)?;
        Some(Setsum { setsum })
    }

    /// Insert the KeyValueRef into the setsum.
    pub fn insert(&mut self, kvr: KeyValueRef) {
        if let Some(value) = kvr.value {
            self.put(kvr.key, kvr.timestamp, value);
        } else {
            self.del(kvr.key, kvr.timestamp);
        }
    }

    /// Put the key@timestamp => value.
    pub fn put(&mut self, key: &[u8], timestamp: u64, value: &[u8]) {
        self.setsum
            .insert_vectored(&[&[8], key, &timestamp.to_le_bytes(), value]);
    }

    /// Put the key@timestamp => TOMBSTONE.
    pub fn del(&mut self, key: &[u8], timestamp: u64) {
        self.setsum
            .insert_vectored(&[&[9], key, &timestamp.to_le_bytes()]);
    }

    /// Get the underlying setsum.
    pub fn into_inner(self) -> RawSetsum {
        self.setsum
    }
}

impl std::ops::Add<Setsum> for Setsum {
    type Output = Setsum;

    fn add(self, rhs: Setsum) -> Setsum {
        Setsum {
            setsum: self.setsum + rhs.setsum,
        }
    }
}

impl std::ops::AddAssign<Setsum> for Setsum {
    fn add_assign(&mut self, rhs: Setsum) {
        self.setsum += rhs.setsum;
    }
}

impl std::ops::Sub<Setsum> for Setsum {
    type Output = Setsum;

    fn sub(self, rhs: Setsum) -> Setsum {
        Setsum {
            setsum: self.setsum - rhs.setsum,
        }
    }
}

impl std::ops::SubAssign<Setsum> for Setsum {
    fn sub_assign(&mut self, rhs: Setsum) {
        self.setsum -= rhs.setsum;
    }
}