melodium-lang 0.10.0

Mélodium language parsing and semantic analyser
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

//! Module dedicated to Input semantic analysis.

use super::common::Node;
use super::r#type::Type;
use super::treatment::Treatment;
use super::DeclarativeElement;
use crate::text::Parameter as TextParameter;
use crate::{error::ScriptError, ScriptResult};
use melodium_common::descriptor::{Collection, Input as InputDescriptor};
use std::sync::{Arc, RwLock, Weak};

/// Structure managing and describing semantic of an input.
///
/// It owns the whole [text parameter](TextParameter).
#[derive(Debug)]
pub struct Input {
    pub text: TextParameter,

    pub treatment: Weak<RwLock<Treatment>>,

    pub name: String,
    pub r#type: Arc<RwLock<Type>>,
}

impl Input {
    /// Create a new semantic input, based on textual parameter.
    ///
    /// * `treatment`: the parent treatment that owns this input.
    /// * `text`: the textual parameter.
    ///
    /// # Note
    /// Only parent-child relationships are made at this step. Other references can be made afterwards using the [Node trait](Node).
    ///
    pub fn new(
        treatment: Arc<RwLock<Treatment>>,
        text: TextParameter,
    ) -> ScriptResult<Arc<RwLock<Self>>> {
        let mut result = ScriptResult::new_success(());

        let borrowed_treatment = treatment.read().unwrap();

        let input = borrowed_treatment.find_input(&text.name.string);
        if input.is_some() {
            result = result.and_degrade_failure(ScriptResult::new_failure(
                ScriptError::already_declared(129, text.name.clone()),
            ));
        }

        if text.value.is_some() {
            result = result.and_degrade_failure(ScriptResult::new_failure(
                ScriptError::default_forbidden(131, text.name.clone()),
            ));
        }

        if let Some(text_type) = text.r#type.clone() {
            result
                .and_degrade_failure(Type::new(
                    Arc::clone(&treatment) as Arc<RwLock<dyn DeclarativeElement>>,
                    text_type,
                ))
                .and_then(|r#type| {
                    ScriptResult::new_success(Arc::<RwLock<Self>>::new(RwLock::new(Self {
                        treatment: Arc::downgrade(&treatment),
                        name: text.name.string.clone(),
                        text,
                        r#type: Arc::new(RwLock::new(r#type)),
                    })))
                })
        } else {
            result.and_degrade_failure(ScriptResult::new_failure(ScriptError::missing_type(
                132,
                text.name.clone(),
            )))
        }
    }

    pub fn make_descriptor(&self, collection: &Collection) -> ScriptResult<InputDescriptor> {
        self.r#type
            .read()
            .unwrap()
            .make_descriptor(&collection)
            .and_then(|(described_type, flow)| {
                ScriptResult::new_success(InputDescriptor::new(
                    &self.name,
                    described_type,
                    flow,
                    self.text
                        .annotations
                        .as_ref()
                        .map(|annotations| {
                            annotations
                                .annotations
                                .iter()
                                .filter_map(|annotation| annotation.as_attribute())
                                .collect()
                        })
                        .unwrap_or_default(),
                ))
            })
    }
}

impl Node for Input {
    fn children(&self) -> Vec<Arc<RwLock<dyn Node>>> {
        vec![Arc::clone(&self.r#type) as Arc<RwLock<dyn Node>>]
    }
}