medmodels-core 0.4.9

Limebit MedModels Crate
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

use crate::medrecord::querying::{
    group_by::{GroupOperand, GroupedOperand},
    wrapper::Wrapper,
    DeepClone,
};
use medmodels_utils::traits::ReadWriteOrPanic;

pub trait EitherOr {
    type QueryOperand;

    fn either_or<EQ, OQ>(&mut self, either_query: EQ, or_query: OQ)
    where
        EQ: FnOnce(&mut Wrapper<Self::QueryOperand>),
        OQ: FnOnce(&mut Wrapper<Self::QueryOperand>);
}

impl<O: EitherOr> Wrapper<O> {
    pub fn either_or<EQ, OQ>(&self, either_query: EQ, or_query: OQ)
    where
        EQ: FnOnce(&mut Wrapper<O::QueryOperand>),
        OQ: FnOnce(&mut Wrapper<O::QueryOperand>),
    {
        self.0.write_or_panic().either_or(either_query, or_query);
    }
}

impl<O: GroupedOperand + EitherOr> EitherOr for GroupOperand<O> {
    type QueryOperand = O::QueryOperand;

    fn either_or<EQ, OQ>(&mut self, either_query: EQ, or_query: OQ)
    where
        EQ: FnOnce(&mut Wrapper<Self::QueryOperand>),
        OQ: FnOnce(&mut Wrapper<Self::QueryOperand>),
    {
        self.operand.either_or(either_query, or_query)
    }
}

pub trait Exclude {
    type QueryOperand;

    fn exclude<Q>(&mut self, query: Q)
    where
        Q: FnOnce(&mut Wrapper<Self::QueryOperand>);
}

impl<O: Exclude> Wrapper<O> {
    pub fn exclude<Q>(&self, query: Q)
    where
        Q: FnOnce(&mut Wrapper<O::QueryOperand>),
    {
        self.0.write_or_panic().exclude(query);
    }
}

impl<O: GroupedOperand + Exclude> Exclude for GroupOperand<O> {
    type QueryOperand = O::QueryOperand;

    fn exclude<Q>(&mut self, query: Q)
    where
        Q: FnOnce(&mut Wrapper<Self::QueryOperand>),
    {
        self.operand.exclude(query)
    }
}

pub trait Random {
    type ReturnOperand;

    fn random(&mut self) -> Wrapper<Self::ReturnOperand>;
}

impl<O: Random> Wrapper<O> {
    pub fn random(&self) -> Wrapper<O::ReturnOperand> {
        self.0.write_or_panic().random()
    }
}

impl<O: GroupedOperand + Random> Random for GroupOperand<O>
where
    Self: DeepClone,
    O::ReturnOperand: GroupedOperand,
    <O::ReturnOperand as GroupedOperand>::Context: From<Self>,
{
    type ReturnOperand = GroupOperand<O::ReturnOperand>;

    fn random(&mut self) -> Wrapper<Self::ReturnOperand> {
        let operand = self.operand.random();

        Wrapper::<GroupOperand<O::ReturnOperand>>::new(self.deep_clone().into(), operand)
    }
}

pub trait IsMax {
    fn is_max(&mut self);
}

impl<O: IsMax> Wrapper<O> {
    pub fn is_max(&self) {
        self.0.write_or_panic().is_max();
    }
}

impl<O: GroupedOperand + IsMax> IsMax for GroupOperand<O> {
    fn is_max(&mut self) {
        self.operand.is_max()
    }
}

pub trait IsMin {
    fn is_min(&mut self);
}

impl<O: IsMin> Wrapper<O> {
    pub fn is_min(&self) {
        self.0.write_or_panic().is_min();
    }
}

impl<O: GroupedOperand + IsMin> IsMin for GroupOperand<O> {
    fn is_min(&mut self) {
        self.operand.is_min()
    }
}