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

//! The STAT table

include!("../../generated/generated_stat.rs");

impl Stat {
    /// Create a new STAT 1.2 table
    pub fn new(
        design_axes: Vec<AxisRecord>,
        axis_values: Vec<AxisValue>,
        elided_fallback_name_id: NameId,
    ) -> Self {
        Stat {
            design_axes: design_axes.into(),
            offset_to_axis_values: OffsetMarker::new(
                axis_values.into_iter().map(Into::into).collect(),
            ),
            elided_fallback_name_id: Some(elided_fallback_name_id),
        }
    }
}

// we use a custom conversion here because we use a shim table in read-fonts
// (required because it is an offset to an array of offsets, which is too recursive for us)
// but in write-fonts we want to skip the shim table and just use a vec.
fn convert_axis_value_offsets(
    from: Result<read_fonts::tables::stat::AxisValueArray, ReadError>,
) -> OffsetMarker<Vec<OffsetMarker<AxisValue>>, WIDTH_32> {
    from.ok()
        .map(|array| {
            array
                .axis_values()
                .map(|val| val.to_owned_obj(array.offset_data()))
                .collect::<Vec<_>>()
        })
        .unwrap_or_default()
        .into()
}

#[cfg(test)]
mod tests {
    use crate::dump_table;
    use crate::read::tables::stat as read_stat;

    use super::*;

    #[test]
    fn smoke_test() {
        let table = Stat::new(
            vec![AxisRecord::new(Tag::new(b"wght"), NameId::new(257), 1)],
            vec![
                AxisValue::format_1(
                    0,
                    AxisValueTableFlags::empty(),
                    NameId::new(258),
                    Fixed::from_f64(100.),
                ),
                AxisValue::format_1(
                    0,
                    AxisValueTableFlags::empty(),
                    NameId::new(261),
                    Fixed::from_f64(400.),
                ),
            ],
            NameId::new(0),
        );

        let bytes = dump_table(&table).unwrap();
        let read = read_stat::Stat::read(FontData::new(&bytes)).unwrap();

        assert_eq!(read.design_axes().unwrap().len(), 1);
        assert_eq!(read.axis_value_count(), 2);
        let axis_values = read.offset_to_axis_values().unwrap();
        assert_eq!(axis_values.axis_value_offsets().len(), 2);
        let value2 = axis_values.axis_values().nth(1).unwrap().unwrap();
        let read_stat::AxisValue::Format1(value2) = value2 else { panic!("wrong format"); };
        assert_eq!(value2.value_name_id(), NameId::new(261));
    }
}