amethystate 0.9.1

Type-safe reactive persistence for Rust GUI apps
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

use crate::store::builder::WithMigrations;
use crate::{DefaultStore, MigrationReport, StoreBuilder};
use std::path::Path;
use std::sync::OnceLock;

static GLOBAL_STORE: OnceLock<DefaultStore> = OnceLock::new();

pub trait IntoGlobalStore {
    type Output;

    fn init_global(self) -> Self::Output;
}

impl IntoGlobalStore for StoreBuilder {
    type Output = ();

    fn init_global(self) -> Self::Output {
        let store = self.build().unwrap_or_else(|err| {
            panic!(
                "amethystate: Failed to build global Store.\n\
                     Ensure the database path is writable and not locked by another process.\n\
                     Details: {err}"
            );
        });

        GLOBAL_STORE.set(store).unwrap_or_else(|_| {
            panic!(
                "amethystate: Global store is already initialized.\n\
                     Ensure `init_global` is called exactly once during application startup."
            );
        });
    }
}

impl IntoGlobalStore for StoreBuilder<WithMigrations> {
    type Output = MigrationReport;

    fn init_global(self) -> Self::Output {
        let (store, report) = self
            .build()
            .unwrap_or_else(|err| {
                panic!(
                    "amethystate: Failed to build global Store and run migrations.\n\
                     Please verify that the database file is not corrupted and your migration logic is correct.\n\
                     Details: {err}"
                );
            });

        GLOBAL_STORE.set(store).unwrap_or_else(|_| {
            panic!(
                "amethystate: Global store is already initialized.\n\
                     Ensure `init_global` is called exactly once during application startup."
            );
        });

        report
    }
}

impl IntoGlobalStore for &str {
    type Output = ();

    fn init_global(self) -> Self::Output {
        StoreBuilder::new(self).init_global()
    }
}

impl IntoGlobalStore for &Path {
    type Output = ();

    fn init_global(self) -> Self::Output {
        StoreBuilder::new(self).init_global()
    }
}

pub fn init_global<T: IntoGlobalStore>(source: T) -> T::Output {
    source.init_global()
}

pub fn global_store() -> DefaultStore {
    GLOBAL_STORE.get().unwrap().clone()
}