sofie-db 0.1.0

The handler model (inputs, events, replies), aggregates, read models, the query builder, the unit of work, migrations, the worker and the database seam.
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

use std::fmt;
use std::hash::{Hash, Hasher};
use std::marker::PhantomData;

use serde::{Deserialize, Deserializer, Serialize, Serializer};
use sofie_core::{Cast, ColumnReader, ColumnSpec, Result, Show, Shown, SqlValue, Uuid};
use sofie_values::{Input, Present};

pub struct Id<A> {
    uuid: Uuid,
    aggregate: PhantomData<fn() -> A>,
}

impl<A> Id<A> {
    #[must_use]
    pub const fn from_uuid(uuid: Uuid) -> Self {
        Self {
            uuid,
            aggregate: PhantomData,
        }
    }

    #[must_use]
    pub const fn uuid(self) -> Uuid {
        self.uuid
    }
}

impl<A> Clone for Id<A> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<A> Copy for Id<A> {}

impl<A> sofie_core::Ordered for Id<A> {}

impl<A> PartialEq for Id<A> {
    fn eq(&self, other: &Self) -> bool {
        self.uuid == other.uuid
    }
}

impl<A> Eq for Id<A> {}

impl<A> Hash for Id<A> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.uuid.hash(state);
    }
}

impl<A> fmt::Debug for Id<A> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.uuid, f)
    }
}

impl<A> fmt::Display for Id<A> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.uuid, f)
    }
}

impl<A> Cast for Id<A> {
    const COLUMNS: &'static [ColumnSpec] = Uuid::COLUMNS;

    fn encode(&self, out: &mut Vec<SqlValue>) {
        self.uuid.encode(out);
    }

    fn decode(row: &mut dyn ColumnReader) -> Result<Self> {
        Uuid::decode(row).map(Self::from_uuid)
    }
}

impl<A> Show for Id<A> {
    fn show(&self) -> Shown<'_> {
        Shown::Uuid(self.uuid)
    }
}

impl<A> Serialize for Id<A> {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.collect_str(&self.uuid)
    }
}

impl<'de, A> Deserialize<'de> for Id<A> {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Uuid::deserialize(deserializer).map(Self::from_uuid)
    }
}

impl<A> Present for Id<A> {
    const INPUT: Input = Uuid::INPUT;
    const SEARCH: sofie_values::Search = Uuid::SEARCH;

    fn csv(&self) -> String {
        self.uuid.csv()
    }
}