infinite-db 0.4.0

A spatial-graph database using n-dimensional curves and hyperedges for engineering logic.
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

//! Named on-disk counter block for database metadata.

use std::io;

use bincode::{config::standard, decode_from_slice, Decode, Encode};

/// Revision and allocation counters persisted in `counters.bin`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
pub struct PersistedCounters {
    /// Highest allocated revision id.
    pub revision: u64,
    /// Next block id to assign.
    pub next_block: u64,
    /// Next snapshot id to assign.
    pub next_snapshot: u64,
    /// Next branch id to assign.
    pub next_branch: u64,
    /// Next asserting `SessionId` to mint (D-P2).
    pub next_session: u32,
}

impl PersistedCounters {
    /// Create a counter snapshot from runtime values.
    pub fn new(
        revision: u64,
        next_block: u64,
        next_snapshot: u64,
        next_branch: u64,
        next_session: u32,
    ) -> Self {
        Self {
            revision,
            next_block,
            next_snapshot,
            next_branch,
            next_session,
        }
    }
}

/// Decode `counters.bin`, migrating legacy positional layouts.
pub fn decode_counters(bytes: &[u8]) -> io::Result<PersistedCounters> {
    if let Ok((c, _)) = decode_from_slice::<PersistedCounters, _>(bytes, standard()) {
        return Ok(c);
    }
    if let Ok((c, _)) = decode_from_slice::<[u64; 4], _>(bytes, standard()) {
        return Ok(PersistedCounters::new(c[0], c[1], c[2], c[3], 1));
    }
    let (c, _): ([u64; 3], _) = decode_from_slice(bytes, standard())
        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
    Ok(PersistedCounters::new(c[0], c[1], c[2], 2, 1))
}