skera 0.4.0

Subsetting a font file according to provided input.
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

//! Subset arrays of offsets
use crate::{offset::SerializeSubset, Plan, SerializeErrorFlags, Serializer, SubsetTable};
use write_fonts::{
    read::{ArrayOfNullableOffsets, ArrayOfOffsets, FontReadWithArgs, Offset, ReadArgs, ReadError},
    types::{FixedSize, Scalar},
};

pub(crate) trait SubsetOffsetArray<'a, T: SubsetTable<'a>> {
    fn subset_offset(
        &self,
        idx: usize,
        s: &mut Serializer,
        plan: &Plan,
        args: T::ArgsForSubset,
    ) -> Result<(), SerializeErrorFlags>;
}

impl<'a, T, O> SubsetOffsetArray<'a, T> for ArrayOfOffsets<'a, T, O>
where
    O: Scalar + Offset + FixedSize + SerializeSubset,
    T: ReadArgs + FontReadWithArgs<'a> + SubsetTable<'a>,
    T::Args: Copy + 'static,
{
    fn subset_offset(
        &self,
        idx: usize,
        s: &mut Serializer,
        plan: &Plan,
        args: T::ArgsForSubset,
    ) -> Result<(), SerializeErrorFlags> {
        let t = match self.get(idx) {
            Err(ReadError::NullOffset) => return Err(SerializeErrorFlags::SERIALIZE_ERROR_EMPTY),
            Ok(table) => table,
            Err(_) => return Err(s.set_err(SerializeErrorFlags::SERIALIZE_ERROR_READ_ERROR)),
        };
        let snap = s.snapshot();
        let offset_pos = s.allocate_size(O::RAW_BYTE_LEN, true)?;

        if let Err(e) = O::serialize_subset(&t, s, plan, args, offset_pos) {
            s.revert_snapshot(snap);
            return Err(e);
        }

        Ok(())
    }
}

impl<'a, T, O> SubsetOffsetArray<'a, T> for ArrayOfNullableOffsets<'a, T, O>
where
    O: Scalar + Offset + FixedSize + SerializeSubset,
    T: ReadArgs + FontReadWithArgs<'a> + SubsetTable<'a>,
    T::Args: Copy + 'static,
{
    fn subset_offset(
        &self,
        idx: usize,
        s: &mut Serializer,
        plan: &Plan,
        args: T::ArgsForSubset,
    ) -> Result<(), SerializeErrorFlags> {
        match self.get(idx) {
            Some(Ok(t)) => {
                let snap = s.snapshot();
                let offset_pos = s.allocate_size(O::RAW_BYTE_LEN, true)?;

                match O::serialize_subset(&t, s, plan, args, offset_pos) {
                    Ok(_) => Ok(()),
                    Err(e) => {
                        s.revert_snapshot(snap);
                        Err(e)
                    }
                }
            }
            None => Err(SerializeErrorFlags::SERIALIZE_ERROR_EMPTY),
            Some(Err(_)) => Err(s.set_err(SerializeErrorFlags::SERIALIZE_ERROR_READ_ERROR)),
        }
    }
}

pub(crate) trait IterNullableHelper<'a, T> {
    fn iter_as_nullable(&self) -> impl Iterator<Item = Option<Result<T, ReadError>>> + 'a;
}

impl<'a, T, O> IterNullableHelper<'a, T> for ArrayOfOffsets<'a, T, O>
// these bounds have to match what is in the read-fonts impl block that has the normal `iter` method
where
    O: Scalar + Offset,
    T: ReadArgs + FontReadWithArgs<'a>,
    T::Args: Copy + 'static,
{
    fn iter_as_nullable(&self) -> impl Iterator<Item = Option<Result<T, ReadError>>> + 'a {
        self.iter().map(|off| match off {
            Err(ReadError::NullOffset) => None,
            other => Some(other),
        })
    }
}