fea-rs 0.2.0

Tools for working with Adobe OpenType Feature files.
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

//! helpers for managing tracking language systems

use std::{collections::HashSet, rc::Rc};

use write_fonts::types::Tag;

use super::{lookups::FeatureKey, tags};

/// A script/language pair
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct LanguageSystem {
    pub script: Tag,
    pub language: Tag,
}

/// Track languagesystem statements
///
/// Seeing no statements is the same as seeing 'DFLT dflt'.
#[derive(Clone, Debug)]
pub(crate) struct DefaultLanguageSystems {
    has_explicit_entry: bool,
    // this is me being fancy, because we clone this everytime we start a lookup.
    items: Rc<HashSet<LanguageSystem>>,
}

impl DefaultLanguageSystems {
    pub(crate) fn insert(&mut self, system: LanguageSystem) {
        if !self.has_explicit_entry {
            Rc::get_mut(&mut self.items).unwrap().clear();
            self.has_explicit_entry = true;
        }
        Rc::get_mut(&mut self.items).unwrap().insert(system);
    }

    pub(crate) fn contains(&self, key: &LanguageSystem) -> bool {
        self.items.contains(key)
    }

    pub(crate) fn iter(&self) -> impl Iterator<Item = LanguageSystem> + '_ {
        self.items.iter().copied()
    }
}

impl LanguageSystem {
    pub(crate) fn to_feature_key(self, feature: Tag) -> FeatureKey {
        let LanguageSystem { script, language } = self;
        FeatureKey {
            feature,
            language,
            script,
        }
    }
}

impl Default for LanguageSystem {
    fn default() -> Self {
        Self {
            script: tags::SCRIPT_DFLT,
            language: tags::LANG_DFLT,
        }
    }
}

impl Default for DefaultLanguageSystems {
    fn default() -> Self {
        Self {
            has_explicit_entry: false,
            items: Rc::new(HashSet::from_iter([LanguageSystem::default()])),
        }
    }
}