graphrecords-query 0.5.0

High-performance graph-based data records
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::{EntityDomain, Failure, FailureKind, IndexDomain};
use graphrecords_core::graphrecord::{GraphRecordAttribute, GraphRecordValue};
use std::marker::PhantomData;

pub trait ValueDomain: 'static {
    type Owned: 'static + Clone;

    type Value<'a>: 'a + Clone
    where
        Self: 'a;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned;

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_>;
}

pub trait BareValueDomain: ValueDomain {}

pub trait ReturnValueDomain: ValueDomain {}

pub struct Scalar;
pub struct Mask;
#[derive(Clone)]
pub struct AttributeName;
pub struct Unit;
pub struct IndexValue<I: IndexDomain>(PhantomData<I>);
pub struct EntityReference<E: EntityDomain>(PhantomData<E>);
pub struct FailureValue;
pub struct FailureKindValue;

impl ValueDomain for Scalar {
    type Owned = GraphRecordValue;
    type Value<'a> = GraphRecordValue;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned {
        value
    }

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_> {
        owned.clone()
    }
}
impl ValueDomain for Mask {
    type Owned = bool;
    type Value<'a> = bool;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned {
        value
    }

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_> {
        *owned
    }
}
impl ValueDomain for AttributeName {
    type Owned = GraphRecordAttribute;
    type Value<'a> = GraphRecordAttribute;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned {
        value
    }

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_> {
        owned.clone()
    }
}
impl ValueDomain for Unit {
    type Owned = ();
    type Value<'a> = ();

    fn into_owned(_value: Self::Value<'_>) -> Self::Owned {}

    fn from_owned(_owned: &Self::Owned) -> Self::Value<'_> {}
}
impl<I: IndexDomain> ValueDomain for IndexValue<I> {
    type Owned = I::Owned;
    type Value<'a> = I::Owned;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned {
        value
    }

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_> {
        owned.clone()
    }
}
impl<E: EntityDomain> ValueDomain for EntityReference<E> {
    type Owned = E::Owned;
    type Value<'a> = E::Index<'a>;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned {
        E::to_owned(&value)
    }

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_> {
        E::from_owned(owned)
    }
}
impl ValueDomain for FailureValue {
    type Owned = Failure;
    type Value<'a> = Failure;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned {
        value
    }

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_> {
        owned.clone()
    }
}
impl ValueDomain for FailureKindValue {
    type Owned = FailureKind;
    type Value<'a> = FailureKind;

    fn into_owned(value: Self::Value<'_>) -> Self::Owned {
        value
    }

    fn from_owned(owned: &Self::Owned) -> Self::Value<'_> {
        *owned
    }
}

impl BareValueDomain for Scalar {}
impl BareValueDomain for Mask {}
impl BareValueDomain for AttributeName {}
impl<I: IndexDomain> BareValueDomain for IndexValue<I> {}
impl<E: EntityDomain> BareValueDomain for EntityReference<E> {}
impl BareValueDomain for FailureValue {}
impl BareValueDomain for FailureKindValue {}

impl ReturnValueDomain for Scalar {}
impl ReturnValueDomain for Mask {}
impl ReturnValueDomain for AttributeName {}
impl<I: IndexDomain> ReturnValueDomain for IndexValue<I> {}
impl<E: EntityDomain> ReturnValueDomain for EntityReference<E> {}
impl ReturnValueDomain for FailureValue {}
impl ReturnValueDomain for FailureKindValue {}