write_fonts/tables/
post.rs

1//! The post table
2
3use std::collections::HashMap;
4
5include!("../../generated/generated_post.rs");
6
7//TODO: I imagine we're going to need a builder for this
8
9/// A string in the post table.
10#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12pub struct PString(String);
13
14impl Post {
15    /// Construct a new version 2.0 table from a glyph order.
16    pub fn new_v2<'a>(order: impl IntoIterator<Item = &'a str>) -> Self {
17        let standard_glyphs = read_fonts::tables::post::DEFAULT_GLYPH_NAMES
18            .iter()
19            .enumerate()
20            .map(|(i, name)| (*name, i as u16))
21            .collect::<HashMap<_, _>>();
22        const NUM_STANDARD: usize = 258;
23        let mut name_index = Vec::new();
24        let mut storage = Vec::new();
25        let mut visited_names = HashMap::new();
26
27        for name in order {
28            match standard_glyphs.get(name) {
29                Some(i) => name_index.push(*i),
30                None => {
31                    let idx = match visited_names.get(name) {
32                        Some(i) => *i,
33                        None => {
34                            let idx = (NUM_STANDARD + storage.len()).try_into().unwrap();
35                            visited_names.insert(name, idx);
36                            storage.push(PString(name.into()));
37                            idx
38                        }
39                    };
40                    name_index.push(idx);
41                }
42            }
43        }
44
45        Post {
46            version: Version16Dot16::VERSION_2_0,
47            num_glyphs: Some(name_index.len() as u16),
48            glyph_name_index: Some(name_index),
49            string_data: Some(storage),
50            ..Default::default()
51        }
52    }
53}
54
55impl std::ops::Deref for PString {
56    type Target = str;
57    fn deref(&self) -> &Self::Target {
58        self.0.as_ref()
59    }
60}
61
62impl AsRef<str> for PString {
63    fn as_ref(&self) -> &str {
64        self.0.as_ref()
65    }
66}
67
68impl<'a> FromObjRef<read_fonts::tables::post::PString<'a>> for PString {
69    fn from_obj_ref(from: &read_fonts::tables::post::PString<'a>, _: FontData) -> Self {
70        PString(from.as_str().to_owned())
71    }
72}
73
74impl FontWrite for PString {
75    fn write_into(&self, writer: &mut TableWriter) {
76        let len = self.0.len() as u8;
77        len.write_into(writer);
78        self.0.as_bytes().write_into(writer);
79    }
80}
81
82impl PartialEq<&str> for PString {
83    fn eq(&self, other: &&str) -> bool {
84        self.0 == *other
85    }
86}
87
88#[cfg(test)]
89mod tests {
90    use super::*;
91
92    #[test]
93    fn roundtrip() {
94        use font_test_data::post as test_data;
95
96        let table = Post::read(test_data::SIMPLE.into()).unwrap();
97        let dumped = crate::dump_table(&table).unwrap();
98        assert_eq!(test_data::SIMPLE, &dumped);
99    }
100
101    #[test]
102    fn compilev2() {
103        let post = Post::new_v2([".dotdef", "A", "B", "one", "flarb", "C"]);
104        let dumped = crate::dump_table(&post).unwrap();
105        let loaded = read_fonts::tables::post::Post::read(FontData::new(&dumped)).unwrap();
106        assert_eq!(loaded.version(), Version16Dot16::VERSION_2_0);
107        assert_eq!(loaded.glyph_name(GlyphId16::new(1)), Some("A"));
108        assert_eq!(loaded.glyph_name(GlyphId16::new(4)), Some("flarb"));
109        assert_eq!(loaded.glyph_name(GlyphId16::new(5)), Some("C"));
110    }
111
112    #[test]
113    fn compilev2_with_duplicates() {
114        let post = Post::new_v2([".dotdef", "A", "flarb", "C", "A", "flarb"]);
115        let dumped = crate::dump_table(&post).unwrap();
116        let loaded = read_fonts::tables::post::Post::read(FontData::new(&dumped)).unwrap();
117
118        assert_eq!(post.num_glyphs, Some(6));
119        assert_eq!(post.glyph_name_index.as_ref().unwrap().len(), 6);
120        assert_eq!(post.glyph_name_index.as_ref().unwrap().first(), Some(&258));
121        assert_eq!(post.glyph_name_index.as_ref().unwrap().get(1), Some(&36));
122        assert_eq!(post.glyph_name_index.as_ref().unwrap().get(2), Some(&259));
123        assert_eq!(post.glyph_name_index.as_ref().unwrap().get(3), Some(&38));
124        assert_eq!(post.glyph_name_index.as_ref().unwrap().get(4), Some(&36));
125        assert_eq!(post.glyph_name_index.as_ref().unwrap().get(5), Some(&259));
126        assert_eq!(post.string_data.unwrap().len(), 2);
127
128        assert_eq!(loaded.version(), Version16Dot16::VERSION_2_0);
129        assert_eq!(loaded.num_glyphs(), Some(6));
130        assert_eq!(loaded.glyph_name(GlyphId16::new(1)), Some("A"));
131        assert_eq!(loaded.glyph_name(GlyphId16::new(2)), Some("flarb"));
132        assert_eq!(loaded.glyph_name(GlyphId16::new(3)), Some("C"));
133        assert_eq!(loaded.glyph_name(GlyphId16::new(4)), Some("A"));
134        assert_eq!(loaded.glyph_name(GlyphId16::new(5)), Some("flarb"));
135    }
136}