dbstruct 0.6.0

Build a typed database by defining a struct
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

use std::cell::Cell;
use std::error::Error;
use std::marker::PhantomData;
use std::sync::atomic::AtomicUsize;
use std::sync::Arc;

use dbstruct::traits::data_store;
use dbstruct::traits::DataStore;
use dbstruct::wrapper;
use serde::{Deserialize, Serialize};
use tracing::instrument;

mod setup_tracing;

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
pub struct Song;
#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq)]
pub struct Preferences;
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
pub struct Account;

const PLAYING_DEFAULT: bool = true;

// macro input:
#[allow(dead_code)]
struct MacroInput {
    // lets say the actual name is Db
    pub queue: Vec<Song>,
    //#[dbstruct(Default("true")]
    pub playing: bool,
    //#[dbstruct(Default)]
    pub preferences: Preferences,
    pub account: Option<Account>,
}

// note only make fields pub if they are in the
// original struct
// start macro output
// note the macro would use absolute paths for everything
pub struct MacroOutput<DS: DataStore> {
    ds: DS,
    queue_len: Arc<AtomicUsize>,
    phantom: PhantomData<Cell<()>>,
}

impl<DS> MacroOutput<DS>
where
    DS: DataStore + data_store::Ordered + Clone,
{
    pub fn new(ds: DS) -> Result<Self, dbstruct::Error<<DS as DataStore>::DbError>> {
        // 1+1 means given the prefix for the queue (one) go to the next prefix then
        // get the element in the database one less. That is the last element of the Vec
        // the key being the index
        let queue_len = data_store::Ordered::get_lt(&ds, &(1 + 1))?
            .map(|(key, _): (usize, Song)| key)
            .map(|key| key + 1)
            .unwrap_or(0);
        tracing::debug!("opening vector queue with len: {queue_len}");
        Ok(Self {
            ds,
            queue_len: Arc::new(AtomicUsize::new(queue_len)),
            phantom: PhantomData,
        })
    }

    #[instrument(skip_all)]
    pub fn queue(&self) -> wrapper::Vec<Song, DS> {
        wrapper::Vec::new(self.ds.clone(), 1, self.queue_len.clone())
    }
    #[instrument(skip_all)]
    pub fn playing(&self) -> wrapper::DefaultValue<bool, DS> {
        wrapper::DefaultValue::new(self.ds.clone(), 2, PLAYING_DEFAULT)
    }
    #[instrument(skip_all)]
    pub fn preferences(&self) -> wrapper::DefaultTrait<Preferences, DS> {
        wrapper::DefaultTrait::new(self.ds.clone(), 3)
    }
    #[instrument(skip_all)]
    pub fn account(&self) -> wrapper::OptionValue<Account, DS> {
        wrapper::OptionValue::new(self.ds.clone(), 4)
    }
}
// end macro output

pub fn main() -> Result<(), Box<dyn Error>> {
    setup_tracing::setup("");
    let ds = sled::Config::default()
        .temporary(true)
        .open()?
        .open_tree("MacroInput")?;
    let db = MacroOutput::new(ds)?;

    let last = db.queue().pop()?;
    assert_eq!(last, None);
    db.queue().push(&Song {})?;
    let last = db.queue().pop()?;
    assert_eq!(last, Some(Song {}));

    let playing = db.playing().get()?;
    assert_eq!(playing, PLAYING_DEFAULT);

    let preferences = db.preferences().get()?;
    assert_eq!(preferences, Default::default());

    db.account().set(&Account {})?;
    let account = db.account().get()?;
    assert_eq!(account, Some(Account {}));

    db.account().conditional_update(&Account {}, &Account {})?;

    Ok(())
}