datom 0.1.1-pre4

datom-rs: an open-source database inspired by Datomic
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// SPDX-FileCopyrightText: 2021 Lutris Engineering, Inc
// SPDX-License-Identifier: BlueOak-1.0.0 OR BSD-2-Clause-Patent
// SPDX-FileContributor: Piper McCorkle <piper@lutris.engineering>

use std::{
    fmt::{self, Debug, Formatter},
    hash::Hash,
};

use crate::{storage::Storage, Entity, Value, ID};

#[derive(Clone)]
/// The result of getting an attribute on an entity
pub enum EntityResult<'connection, S: Storage> {
    /// A value for that attribute wasn't found on this entity
    NotFound,
    /// A value for that attribute was found on this entity
    Value(Value),
    /// A value for that attribute was found on this entity, and it
    /// refers to another entity.
    Ref(Entity<'connection, S>),
    /// Possibly multiple values for that attribute were found on this
    /// entity
    Repeated(Vec<Self>),
}

impl<'connection, S: Storage> Debug for EntityResult<'connection, S> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::NotFound => write!(f, "NotFound")?,
            Self::Value(v) => {
                write!(f, "Value(")?;
                v.fmt(f)?;
                write!(f, ")")?;
            }
            Self::Ref(e) => {
                write!(f, "Ref(")?;
                e.id().fmt(f)?;
                write!(f, ")")?;
            }
            Self::Repeated(xs) => {
                write!(f, "Repeated(")?;
                for x in xs {
                    x.fmt(f)?;
                    write!(f, ", ")?;
                }
                write!(f, ")")?;
            }
        }
        Ok(())
    }
}

impl<'connection, S: Storage> EntityResult<'connection, S> {
    /// Check if the result is a reference to a specific ID
    pub fn is_ref_to(&self, id: &ID) -> bool {
        if let Self::Ref(e) = self {
            e.id() == id
        } else {
            false
        }
    }
}

impl<'connection, S: Storage> PartialEq<Self> for EntityResult<'connection, S> {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Value(l0), Self::Value(r0)) => l0 == r0,
            (Self::Ref(l0), Self::Ref(r0)) => l0 == r0,
            (Self::Repeated(l0), Self::Repeated(r0)) => l0 == r0,
            _ => core::mem::discriminant(self) == core::mem::discriminant(other),
        }
    }
}

impl<'connection, S: Storage> Eq for EntityResult<'connection, S> {}

impl<'connection, S: Storage> Hash for EntityResult<'connection, S> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        core::mem::discriminant(self).hash(state);
    }
}

impl<'connection, S: Storage> PartialEq<Value> for EntityResult<'connection, S> {
    fn eq(&self, other: &Value) -> bool {
        match self {
            Self::Value(s) => s == other,
            _ => false,
        }
    }
}

impl<'connection, S: Storage + PartialEq> PartialEq<Entity<'connection, S>>
    for EntityResult<'connection, S>
{
    fn eq(&self, other: &Entity<'connection, S>) -> bool {
        match self {
            Self::Ref(s) => s == other,
            _ => false,
        }
    }
}

impl<'connection, S: Storage> PartialEq<ID> for EntityResult<'connection, S> {
    fn eq(&self, other: &ID) -> bool {
        self.is_ref_to(other)
    }
}

impl<'connection, S: Storage + PartialEq> PartialEq<Vec<Self>> for EntityResult<'connection, S> {
    fn eq(&self, other: &Vec<Self>) -> bool {
        match self {
            Self::Repeated(s) => s == other,
            _ => false,
        }
    }
}

impl<'connection, S: Storage> From<Value> for EntityResult<'connection, S> {
    fn from(v: Value) -> Self {
        Self::Value(v)
    }
}

impl<'connection, S: Storage> From<Entity<'connection, S>> for EntityResult<'connection, S> {
    fn from(e: Entity<'connection, S>) -> Self {
        Self::Ref(e)
    }
}