sofie-engine 0.2.0

Screens: the template parser and renderer, and the component catalog.
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

use std::collections::HashMap;

use super::toml::{self, Entry};
use super::{Message, TranslationError};

#[derive(Debug)]
pub(super) struct Entries {
    by_key: HashMap<String, Vec<Option<Definition>>>,
    language_count: usize,
}

#[derive(Debug)]
pub(super) struct Definition {
    pub message: Message,
    module: String,
    is_builtin: bool,
}

/// A framework crate's file loses to the app's own text.
pub(super) struct Origin<'o> {
    pub module: &'o str,
    pub file: &'o str,
    pub served: &'o [usize],
    pub is_builtin: bool,
}

impl Entries {
    pub(super) fn new(language_count: usize) -> Self {
        Self {
            by_key: HashMap::new(),
            language_count,
        }
    }

    pub(super) fn add_file(
        &mut self,
        origin: &Origin<'_>,
        source: &str,
    ) -> Result<(), TranslationError> {
        let entries = toml::parse(source).map_err(|syntax| {
            TranslationError::in_file(origin.file, syntax.line, syntax.column, syntax.message)
        })?;
        for entry in &entries {
            for &index in origin.served {
                self.define(origin, entry, index)?;
            }
        }
        Ok(())
    }

    fn define(
        &mut self,
        origin: &Origin<'_>,
        entry: &Entry,
        index: usize,
    ) -> Result<(), TranslationError> {
        let at = |message: String| {
            TranslationError::in_file(origin.file, entry.line, entry.column, message)
        };
        let message = Message::parse(&entry.text).map_err(at)?;
        let language_count = self.language_count;
        let slots = self
            .by_key
            .entry(entry.key.clone())
            .or_insert_with(|| (0..language_count).map(|_| None).collect());
        let Some(slot) = slots.get_mut(index) else {
            return Ok(());
        };
        if let Some(existing) = slot {
            match (existing.is_builtin, origin.is_builtin) {
                (false, true) => return Ok(()),
                (true, true) if existing.module == origin.module => return Ok(()),
                (true, false) => {}
                _ => {
                    return Err(at(format!(
                        "`{}` is already defined by module `{}`",
                        entry.key, existing.module
                    )));
                }
            }
        }
        *slot = Some(Definition {
            message,
            module: origin.module.to_owned(),
            is_builtin: origin.is_builtin,
        });
        Ok(())
    }

    pub(super) fn get(&self, key: &str, index: usize) -> Option<&Definition> {
        self.by_key.get(key)?.get(index)?.as_ref()
    }

    /// One lookup of the key.
    pub(super) fn get_or_default(&self, key: &str, index: usize) -> Option<&Definition> {
        let definitions = self.by_key.get(key)?;
        definitions
            .get(index)
            .and_then(Option::as_ref)
            .or_else(|| definitions.first()?.as_ref())
    }

    #[cfg(feature = "parse")]
    pub(super) fn contains(&self, key: &str) -> bool {
        self.by_key.contains_key(key)
    }

    pub(super) fn keys(&self) -> impl Iterator<Item = &str> {
        self.by_key.keys().map(String::as_str)
    }
}