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

use super::Parameter;
use core::fmt::Debug;
use melodium_common::descriptor::{Attribuable, Attributes, DescribedType, Identifier, Treatment};
use std::collections::HashMap;
use std::sync::Weak;

#[derive(Debug, Clone)]
pub struct TreatmentInstanciation {
    pub name: String,
    pub descriptor: Weak<dyn Treatment>,
    pub generics: HashMap<String, DescribedType>,
    pub models: HashMap<String, String>,
    pub parameters: HashMap<String, Parameter>,
    pub attributes: Attributes,
}

impl TreatmentInstanciation {
    pub fn make_use(&self, identifier: &Identifier) -> bool {
        self.descriptor
            .upgrade()
            .map(|desc| desc.identifier() == identifier)
            .unwrap_or(false)
            || self
                .parameters
                .iter()
                .any(|(_, parameter)| parameter.make_use(identifier))
            || self.generics.iter().any(|(_, dt)| {
                dt.final_type()
                    .data()
                    .map(|data| data.identifier() == identifier)
                    .unwrap_or(false)
            })
    }

    pub fn uses(&self) -> Vec<Identifier> {
        let mut uses = vec![self.descriptor.upgrade().unwrap().identifier().clone()];
        uses.extend(
            self.generics
                .iter()
                .filter_map(|(_, dt)| dt.final_type().data().map(|data| data.identifier().clone())),
        );
        uses.extend(
            self.parameters
                .iter()
                .flat_map(|(_, parameter)| parameter.uses()),
        );
        uses
    }
}

impl Attribuable for TreatmentInstanciation {
    fn attributes(&self) -> &Attributes {
        &self.attributes
    }
}