armour 0.30.27

DDL and serialization for key-value storage
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

use fjall::{Guard, Slice};

use super::ItemWithRaw;
use crate::{DbError, DbResult, Entry, Record, logdb::KeyValue};

pub type IterFnPointer<T> = fn(fjall::Guard) -> Option<T>;
pub type TryFnPointer<T> = fn(fjall::Guard) -> DbResult<T>;
pub type RawFnPointer = fn(fjall::Guard) -> Option<KeyValue>;

pub type IterTree<T> = std::iter::FilterMap<fjall::Iter, IterFnPointer<T>>;
pub type TryIterTree<T> = std::iter::Map<fjall::Iter, TryFnPointer<T>>;
pub type RawIterTree = std::iter::FilterMap<fjall::Iter, RawFnPointer>;

#[inline]
pub fn entry_filter_map<Item: Record<Value = Slice>>(guard: Guard) -> Option<Entry<Item>> {
    match guard.into_inner() {
        Ok((key, value)) => {
            let id = Item::deser_key(&key);

            let value = Item::deser_owned(value);
            Some(Entry {
                key: id,
                val: value,
            })
        }
        Err(e) => {
            error!(%e);
            None
        }
    }
}

#[inline]
pub fn entry_map<Item: Record<Value = Slice>>(guard: Guard) -> DbResult<Entry<Item>> {
    guard.into_inner().map_err(DbError::from).map(|item| {
        let (key, value) = item;
        let id = Item::deser_key(&key);
        let val = Item::deser_owned(value);
        Entry { key: id, val }
    })
}

#[inline]
pub fn entry_map_with_raw<Item: Record<Value = Slice>>(
    guard: Guard,
) -> DbResult<ItemWithRaw<Item>> {
    guard.into_inner().map_err(DbError::from).map(|item| {
        let (key, value) = item;
        let id = Item::deser_key(&key);
        let val = Item::deser(&value);
        (key, value, Entry { key: id, val })
    })
}

#[inline]
pub fn entry_key_filter_map<Item: Record<Value = Slice>>(guard: Guard) -> Option<Item::SelfId> {
    match guard.key() {
        Ok(key) => Some(Item::deser_key(&key)),
        Err(e) => {
            error!(%e);
            None
        }
    }
}

#[inline]
pub fn raw_filter_map(guard: Guard) -> Option<KeyValue> {
    match guard.into_inner() {
        Ok(kv) => Some(kv),
        Err(e) => {
            error!(%e);
            None
        }
    }
}