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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use super::NodeOperand;
use crate::{
    errors::MedRecordResult,
    medrecord::querying::{
        edges::EdgeOperand,
        group_by::{GroupBy, GroupOperand, GroupedOperand, PartitionGroups, Ungroup},
        nodes::{NodeIndexOperand, NodeIndicesOperand, NodeIndicesOperandContext},
        wrapper::Wrapper,
        DeepClone, EvaluateBackward, EvaluateForward, EvaluateForwardGrouped, GroupedIterator,
    },
    prelude::MedRecordAttribute,
    MedRecord,
};

#[derive(Debug, Clone)]
pub enum NodeOperandContext {
    Discriminator(<NodeOperand as GroupBy>::Discriminator),
    Nodes(Box<GroupOperand<NodeOperand>>),
    Edges(Box<GroupOperand<EdgeOperand>>),
}

impl DeepClone for NodeOperandContext {
    fn deep_clone(&self) -> Self {
        match self {
            Self::Discriminator(discriminator) => Self::Discriminator(discriminator.clone()),
            Self::Nodes(operand) => Self::Nodes(operand.deep_clone()),
            Self::Edges(operand) => Self::Edges(operand.deep_clone()),
        }
    }
}

impl From<<NodeOperand as GroupBy>::Discriminator> for NodeOperandContext {
    fn from(discriminator: <NodeOperand as GroupBy>::Discriminator) -> Self {
        Self::Discriminator(discriminator)
    }
}

impl From<GroupOperand<NodeOperand>> for NodeOperandContext {
    fn from(operand: GroupOperand<NodeOperand>) -> Self {
        Self::Nodes(Box::new(operand))
    }
}

impl From<GroupOperand<EdgeOperand>> for NodeOperandContext {
    fn from(operand: GroupOperand<EdgeOperand>) -> Self {
        Self::Edges(Box::new(operand))
    }
}

impl GroupedOperand for NodeOperand {
    type Context = NodeOperandContext;
}

#[derive(Debug, Clone)]
pub enum NodeOperandGroupDiscriminator {
    Attribute(MedRecordAttribute),
}

impl DeepClone for NodeOperandGroupDiscriminator {
    fn deep_clone(&self) -> Self {
        match self {
            Self::Attribute(attr) => Self::Attribute(attr.clone()),
        }
    }
}

impl<'a> EvaluateForward<'a> for GroupOperand<NodeOperand> {
    type InputValue = <NodeOperand as EvaluateForward<'a>>::InputValue;
    type ReturnValue = GroupedIterator<'a, <NodeOperand as EvaluateForward<'a>>::ReturnValue>;

    fn evaluate_forward(
        &self,
        medrecord: &'a MedRecord,
        indices: Self::InputValue,
    ) -> MedRecordResult<Self::ReturnValue> {
        match &self.context {
            NodeOperandContext::Discriminator(discriminator) => {
                let partitions = NodeOperand::partition(medrecord, indices, discriminator);

                self.operand
                    .evaluate_forward_grouped(medrecord, Box::new(partitions))
            }
            NodeOperandContext::Nodes(_) => unreachable!(),
            NodeOperandContext::Edges(_) => unreachable!(),
        }
    }
}

impl GroupedOperand for NodeIndicesOperand {
    type Context = GroupOperand<NodeOperand>;
}

impl<'a> EvaluateBackward<'a> for GroupOperand<NodeIndicesOperand> {
    type ReturnValue =
        GroupedIterator<'a, <NodeIndicesOperand as EvaluateBackward<'a>>::ReturnValue>;

    fn evaluate_backward(&self, medrecord: &'a MedRecord) -> MedRecordResult<Self::ReturnValue> {
        let partitions = self.context.evaluate_backward(medrecord)?;

        let indices = Box::new(partitions.map(|(key, partition)| {
            let reduced_partition = self.operand.reduce_input(partition)?;

            Ok((key, reduced_partition))
        }))
        .collect::<MedRecordResult<Vec<_>>>()?;

        self.operand
            .evaluate_forward_grouped(medrecord, Box::new(indices.into_iter()))
    }
}

impl Ungroup for GroupOperand<NodeIndicesOperand> {
    type OutputOperand = NodeIndicesOperand;

    fn ungroup(&self) -> Wrapper<Self::OutputOperand> {
        let operand = Wrapper::<Self::OutputOperand>::new(
            NodeIndicesOperandContext::NodeIndicesGroupByOperand(self.deep_clone()),
        );

        self.operand.push_merge_operation(operand.clone());

        operand
    }
}

impl GroupedOperand for NodeIndexOperand {
    type Context = GroupOperand<NodeIndicesOperand>;
}

impl<'a> EvaluateBackward<'a> for GroupOperand<NodeIndexOperand> {
    type ReturnValue = GroupedIterator<'a, <NodeIndexOperand as EvaluateBackward<'a>>::ReturnValue>;

    fn evaluate_backward(&self, medrecord: &'a MedRecord) -> MedRecordResult<Self::ReturnValue> {
        let partitions = self.context.evaluate_backward(medrecord)?;

        let indices: Vec<_> = partitions
            .map(|(key, partition)| {
                let reduced_partition = self.operand.reduce_input(partition)?;

                Ok((key, reduced_partition))
            })
            .collect::<MedRecordResult<_>>()?;

        self.operand
            .evaluate_forward_grouped(medrecord, Box::new(indices.into_iter()))
    }
}

impl Ungroup for GroupOperand<NodeIndexOperand> {
    type OutputOperand = NodeIndicesOperand;

    fn ungroup(&self) -> Wrapper<Self::OutputOperand> {
        let operand = Wrapper::<Self::OutputOperand>::new(
            NodeIndicesOperandContext::NodeIndexGroupByOperand(self.deep_clone()),
        );

        self.operand.push_merge_operation(operand.clone());

        operand
    }
}