fea-rs 0.22.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
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

use write_fonts::{read::collections::IntSet, types::GlyphId16};

use super::GlyphOrClass;

/// A glyph class, as used in the FEA spec.
///
/// This should not be confused with the `ClassDef` table used in OpenType.
/// In a feature file, a glyph class is an ordered sequence of glyphs, and
/// may contain duplicates.
///
/// For example, single sub format C can take the form,
///
/// ```fea
/// sub [a b c] by [z z d];
/// # equivalent to:
/// sub a by z;
/// sub b by z;
/// sub c by d;
/// ```
///
/// See the [spec docs] for more information.
///
/// [spec docs]: http://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#2g-glyph-classes
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub(crate) struct GlyphClass(Vec<GlyphId16>);

/// A sorted set of unique glyph ids.
///
/// This type exists to clearly separate the use of 'glyph class' in the fea spec
/// from how we use it when building tables that contain OpenType glyph ClassDefs.
pub type GlyphSet = IntSet<GlyphId16>;

impl GlyphClass {
    /// An empty glyph class
    pub const EMPTY: Self = GlyphClass(Vec::new());

    pub(crate) fn items(&self) -> &[GlyphId16] {
        &self.0
    }

    /// Return a `GlyphSet` containing the unique glyphs in this class.
    pub(crate) fn to_glyph_set(&self) -> GlyphSet {
        self.iter().collect()
    }

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

    pub(crate) fn len(&self) -> usize {
        self.0.len()
    }
}

impl std::iter::FromIterator<GlyphId16> for GlyphClass {
    fn from_iter<T: IntoIterator<Item = GlyphId16>>(iter: T) -> Self {
        GlyphClass(iter.into_iter().collect())
    }
}

impl<'a> std::iter::IntoIterator for &'a GlyphClass {
    type Item = &'a GlyphId16;

    type IntoIter = std::slice::Iter<'a, GlyphId16>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.iter()
    }
}

impl From<Vec<GlyphId16>> for GlyphClass {
    fn from(src: Vec<GlyphId16>) -> GlyphClass {
        GlyphClass(src)
    }
}

impl From<GlyphClass> for GlyphSet {
    fn from(value: GlyphClass) -> Self {
        value.iter().collect()
    }
}

impl From<GlyphId16> for GlyphClass {
    fn from(src: GlyphId16) -> GlyphClass {
        let slice: &[_] = &[src];
        GlyphClass(slice.into())
    }
}

impl From<GlyphOrClass> for GlyphClass {
    fn from(src: GlyphOrClass) -> GlyphClass {
        match src {
            GlyphOrClass::Class(class) => class,
            GlyphOrClass::Glyph(id) => id.into(),
            GlyphOrClass::Null => GlyphClass::EMPTY,
        }
    }
}