melodium-engine 0.10.0

Mélodium core engine and executor implementation
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
139
140
141
142
143
144
145
146

pub use crate::world::{InfoTrack, TrackResult};
use crate::{
    building::{BuildId, ContextualEnvironment, HostTreatment},
    world::World,
};
use chrono::{DateTime, Utc};
use melodium_common::{
    descriptor::{Model, Treatment},
    executive::{Context, ModelId, TrackId, Value},
};
use std::{collections::HashMap, sync::Arc};
use uuid::Uuid;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DebugLevel {
    None,
    Basic,
    Detailed,
}

#[derive(Debug, Clone)]
pub struct Event {
    pub timestamp: DateTime<Utc>,
    pub kind: EventKind,
}

impl Event {
    pub fn new(kind: EventKind) -> Self {
        Self {
            timestamp: Utc::now(),
            kind,
        }
    }
}

#[derive(Debug, Clone)]
pub enum EventKind {
    ModelBuilt {
        model: Arc<dyn Model>,
        parameters: HashMap<String, Value>,
        host_treatment: HostTreatment,
        host_build: Option<BuildId>,
        label: String,
    },
    ModelAdded {
        model_id: ModelId,
        model: Arc<dyn Model>,
    },
    ContinuousModelsStarted,
    ContinuousModelsFinished,
    TreatmentBuilt {
        treatment: Arc<dyn Treatment>,
        environment: ContextualEnvironment,
        host_treatment: HostTreatment,
        host_build: Option<BuildId>,
        build_id: BuildId,
        label: String,
    },
    TrackAdded {
        info: InfoTrack,
        creation: TrackCreation,
    },
    TrackFinished {
        info: InfoTrack,
    },
    TreatmentStarted {
        treatment: Arc<dyn Treatment>,
        host_treatment: HostTreatment,
        host_build: Option<BuildId>,
        build_id: BuildId,
        track_id: TrackId,
        label: String,
    },
    TreatmentFinished {
        treatment: Arc<dyn Treatment>,
        host_treatment: HostTreatment,
        host_build: Option<BuildId>,
        build_id: BuildId,
        track_id: TrackId,
        label: String,
    },
    DataSent {
        output: TransmissionDetails,
        track_id: TrackId,
        data: DataContent,
    },
    DataTransmitted {
        output: TransmissionDetails,
        input: TransmissionDetails,
        track_id: TrackId,
        data: DataContent,
    },
    DataReceived {
        input: TransmissionDetails,
        track_id: TrackId,
        data: DataContent,
    },
    OutputClosed {
        output: TransmissionDetails,
        track_id: TrackId,
    },
    InputClosed {
        input: TransmissionDetails,
        track_id: TrackId,
    },
    Distant {
        run_id: Uuid,
        text: String,
        //event: Box<Event>,
    },
}

#[derive(Debug, Clone)]
pub enum TrackCreation {
    Direct,
    Source {
        source: String,
        model_id: ModelId,
        parameters: HashMap<String, Value>,
        contexts: Vec<Arc<dyn Context>>,
    },
}

#[derive(Debug, Clone)]
pub enum DataContent {
    Undetailed,
    Count { count: usize },
    Values { values: Vec<Value> },
}

#[derive(Debug, Clone)]
pub enum TransmissionDebug {
    None,
    Basic(Arc<World>, TransmissionDetails),
    Detailed(Arc<World>, TransmissionDetails),
}

#[derive(Debug, Clone)]
pub struct TransmissionDetails {
    pub treatment: Arc<dyn Treatment>,
    pub host_treatment: HostTreatment,
    pub host_build: Option<BuildId>,
    pub build_id: BuildId,
    pub label: String,
    pub name: String,
}