//! Generic traversal of font tables.
//!
//! This module defines functionality that allows untyped access to font table
//! data. This is used as the basis for things like debug printing.
//!
//! The basis of traversal is the [`SomeTable`] trait, which is implemented for
//! all font tables. This trait provides the table's name, as well as ordered access
//! to the table's fields. Using this, it is possible to iterate through a table
//! and its subtables, records, and values.
use std::{fmt::Debug, ops::Deref};
use types::{
BigEndian, F2Dot14, FWord, Fixed, GlyphId16, LongDateTime, MajorMinor, NameId, Nullable,
Offset16, Offset24, Offset32, Scalar, Tag, UfWord, Uint24, Version16Dot16,
};
use crate::{
array::{ComputedArray, VarLenArray},
read::{ComputeSize, ReadArgs},
FontData, FontRead, FontReadWithArgs, ReadError, VarSize,
};
/// Types of fields in font tables.
///
/// Fields can either be scalars, offsets to tables, or arrays.
pub enum FieldType<'a> {
I8(i8),
U8(u8),
I16(i16),
U16(u16),
I32(i32),
U32(u32),
U24(Uint24),
Tag(Tag),
FWord(FWord),
UfWord(UfWord),
MajorMinor(MajorMinor),
Version16Dot16(Version16Dot16),
F2Dot14(F2Dot14),
Fixed(Fixed),
LongDateTime(LongDateTime),
GlyphId16(GlyphId16),
NameId(NameId),
BareOffset(OffsetType),
ResolvedOffset(ResolvedOffset<'a>),
/// Used in tables like name/post so we can actually print the strings
StringOffset(StringOffset<'a>),
/// Used in COLR/CPAL
ArrayOffset(ArrayOffset<'a>),
Record(RecordResolver<'a>),
Array(Box<dyn SomeArray<'a> + 'a>),
Unknown,
}
/// Any offset type.
#[derive(Clone, Copy)]
pub enum OffsetType {
Offset16(u16),
Offset24(Uint24),
Offset32(u32),
}
impl OffsetType {
/// Return this offset as a u32.
pub fn to_u32(self) -> u32 {
match self {
Self::Offset16(val) => val.into(),
Self::Offset24(val) => val.into(),
Self::Offset32(val) => val,
}
}
}
/// An offset, as well as the table it references.
pub struct ResolvedOffset<'a> {
/// The raw offset
pub offset: OffsetType,
/// The parsed table pointed to by this offset, or an error if parsing fails.
pub target: Result<Box<dyn SomeTable<'a> + 'a>, ReadError>,
}
/// An offset to string data.
///
/// This is a special case for the name table (and maybe elsewhere?)
pub struct StringOffset<'a> {
pub offset: OffsetType,
pub target: Result<Box<dyn SomeString<'a> + 'a>, ReadError>,
}
/// An offset to an array.
pub struct ArrayOffset<'a> {
pub offset: OffsetType,
pub target: Result<Box<dyn SomeArray<'a> + 'a>, ReadError>,
}
pub(crate) struct ArrayOfOffsets<'a, O> {
type_name: &'static str,
offsets: &'a [O],
resolver: Box<dyn Fn(&O) -> FieldType<'a> + 'a>,
}
impl<'a, O> SomeArray<'a> for ArrayOfOffsets<'a, O> {
fn type_name(&self) -> &str {
self.type_name
}
fn len(&self) -> usize {
self.offsets.len()
}
fn get(&self, idx: usize) -> Option<FieldType<'a>> {
let off = self.offsets.get(idx)?;
let target = (self.resolver)(off);
Some(target)
}
}
impl<'a> FieldType<'a> {
/// makes a field, handling the case where this array may not be present in
/// all versions
pub fn array_of_records<T>(
type_name: &'static str,
records: &'a [T],
data: FontData<'a>,
) -> FieldType<'a>
where
T: Clone + SomeRecord<'a> + 'a,
{
ArrayOfRecords {
type_name,
data,
records,
}
.into()
}
// Convenience method for handling computed arrays
pub fn computed_array<T>(
type_name: &'static str,
array: ComputedArray<'a, T>,
data: FontData<'a>,
) -> FieldType<'a>
where
T: FontReadWithArgs<'a> + ComputeSize + SomeRecord<'a> + 'a,
T::Args: Copy + 'static,
{
ComputedArrayOfRecords {
type_name,
data,
array,
}
.into()
}
// Convenience method for handling VarLenArrays
pub fn var_array<T>(
type_name: &'static str,
array: VarLenArray<'a, T>,
data: FontData<'a>,
) -> FieldType<'a>
where
T: FontRead<'a> + VarSize + SomeRecord<'a> + 'a,
{
VarLenArrayOfRecords {
type_name,
data,
array,
}
.into()
}
/// Convenience method for creating a `FieldType` from an array of offsets.
///
/// The `resolver` argument is a function that takes an offset and resolves
/// it.
pub fn array_of_offsets<O>(
type_name: &'static str,
offsets: &'a [O],
resolver: impl Fn(&O) -> FieldType<'a> + 'a,
) -> Self
where {
FieldType::Array(Box::new(ArrayOfOffsets {
type_name,
offsets,
resolver: Box::new(resolver),
}))
}
/// Convenience method for creating a `FieldType` from an offset to an array.
pub fn offset_to_array_of_scalars<T: SomeArray<'a> + 'a>(
offset: impl Into<OffsetType>,
result: impl Into<Option<Result<T, ReadError>>>,
) -> Self {
let offset = offset.into();
match result.into() {
Some(target) => FieldType::ArrayOffset(ArrayOffset {
offset,
target: target.map(|x| Box::new(x) as Box<dyn SomeArray>),
}),
None => FieldType::BareOffset(offset),
}
}
/// Convenience method for creating a `FieldType` from an offset to an array.
pub fn offset_to_array_of_records<T: Clone + SomeRecord<'a> + 'a>(
offset: impl Into<OffsetType>,
result: impl Into<Option<Result<&'a [T], ReadError>>>,
type_name: &'static str,
data: FontData<'a>,
) -> Self {
let offset = offset.into();
match result.into() {
Some(target) => {
let target = target.map(|records| {
Box::new(ArrayOfRecords {
type_name,
data,
records,
}) as Box<dyn SomeArray>
});
FieldType::ArrayOffset(ArrayOffset { offset, target })
}
None => FieldType::BareOffset(offset),
}
}
//FIXME: I bet this is generating a *lot* of code
/// Convenience method for creating a `FieldType` for a resolved offset.
///
/// This handles cases where offsets are nullable, in which case the `result`
/// argument may be `None`.
pub fn offset<T: SomeTable<'a> + 'a>(
offset: impl Into<OffsetType>,
result: impl Into<Option<Result<T, ReadError>>>,
) -> Self {
let offset = offset.into();
match result.into() {
Some(target) => FieldType::ResolvedOffset(ResolvedOffset {
offset,
target: target.map(|x| Box::new(x) as Box<dyn SomeTable>),
}),
None => FieldType::BareOffset(offset),
}
}
/// Convenience method for creating a `FieldType` from an unknown offset.
pub fn unknown_offset(offset: impl Into<OffsetType>) -> Self {
Self::BareOffset(offset.into())
}
}
/// A generic field in a font table.
pub struct Field<'a> {
/// The field's name.
pub name: &'static str,
/// The field's value.
pub value: FieldType<'a>,
}
/// A generic table type.
///
/// This is intended to be used as a trait object, and is a way of generically
/// representing any table, providing ordered access to that table's fields.
pub trait SomeTable<'a> {
/// The name of this table
fn type_name(&self) -> &str;
/// Access this table's fields, in declaration order.
fn get_field(&self, idx: usize) -> Option<Field<'a>>;
}
impl<'a> dyn SomeTable<'a> + 'a {
/// Returns an iterator over this table's fields.
pub fn iter(&self) -> impl Iterator<Item = Field<'a>> + '_ {
FieldIter {
table: self,
idx: 0,
}
}
}
struct FieldIter<'a, 'b> {
table: &'b dyn SomeTable<'a>,
idx: usize,
}
impl<'a, 'b> Iterator for FieldIter<'a, 'b> {
type Item = Field<'a>;
fn next(&mut self) -> Option<Self::Item> {
let this = self.idx;
self.idx += 1;
self.table.get_field(this)
}
}
impl<'a> SomeTable<'a> for Box<dyn SomeTable<'a> + 'a> {
fn type_name(&self) -> &str {
self.deref().type_name()
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
self.deref().get_field(idx)
}
}
/// A generic trait for records, which need to be passed in data
/// in order to fully resolve themselves.
pub trait SomeRecord<'a> {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a>;
}
/// A struct created from a record and the data it needs to resolve any
/// contained offsets.
pub struct RecordResolver<'a> {
pub(crate) name: &'static str,
pub(crate) get_field: Box<dyn Fn(usize, FontData<'a>) -> Option<Field<'a>> + 'a>,
pub(crate) data: FontData<'a>,
}
/// A generic trait for arrays.
pub trait SomeArray<'a> {
/// The name of this type. For an array of u16s, this is `[u16]`.
fn type_name(&self) -> &str;
/// The length of the array.
fn len(&self) -> usize;
/// Returns `true` if this array is empty.
fn is_empty(&self) -> bool {
self.len() == 0
}
/// Return the item at `idx`, or `None` if `idx` is out of bounds.
fn get(&self, idx: usize) -> Option<FieldType<'a>>;
}
impl<'a> dyn SomeArray<'a> + 'a {
/// Return an iterator over the contents of this array.
pub fn iter(&self) -> impl Iterator<Item = FieldType<'a>> + '_ {
ArrayIter {
array: self,
idx: 0,
}
}
}
struct ArrayIter<'a, 'b> {
array: &'b dyn SomeArray<'a>,
idx: usize,
}
impl<'a, 'b> Iterator for ArrayIter<'a, 'b> {
type Item = FieldType<'a>;
fn next(&mut self) -> Option<Self::Item> {
let this = self.idx;
self.idx += 1;
self.array.get(this)
}
}
impl<'a, T: Scalar + Into<FieldType<'a>>> SomeArray<'a> for &'a [BigEndian<T>]
where
BigEndian<T>: Copy, // i don't know why i need this??
{
fn len(&self) -> usize {
(*self).len()
}
fn get(&self, idx: usize) -> Option<FieldType<'a>> {
(*self).get(idx).map(|val| val.get().into())
}
fn type_name(&self) -> &str {
let full_name = std::any::type_name::<T>();
full_name.split("::").last().unwrap_or(full_name)
}
}
impl<'a> SomeArray<'a> for &'a [u8] {
fn type_name(&self) -> &str {
"u8"
}
fn len(&self) -> usize {
(*self).len()
}
fn get(&self, idx: usize) -> Option<FieldType<'a>> {
(*self).get(idx).copied().map(Into::into)
}
}
impl<'a> SomeArray<'a> for Box<dyn SomeArray<'a> + 'a> {
fn type_name(&self) -> &str {
self.deref().type_name()
}
fn len(&self) -> usize {
self.deref().len()
}
fn get(&self, idx: usize) -> Option<FieldType<'a>> {
self.deref().get(idx)
}
}
pub trait SomeString<'a> {
fn iter_chars(&self) -> Box<dyn Iterator<Item = char> + 'a>;
}
impl<'a> SomeString<'a> for Box<dyn SomeString<'a> + 'a> {
fn iter_chars(&self) -> Box<dyn Iterator<Item = char> + 'a> {
self.deref().iter_chars()
}
}
// only used as Box<dyn SomeArray<'a>>
struct ArrayOfRecords<'a, T> {
pub(crate) type_name: &'static str,
pub(crate) data: FontData<'a>,
pub(crate) records: &'a [T],
}
// only used as Box<dyn SomeArray<'a>>
struct ComputedArrayOfRecords<'a, T: ReadArgs> {
pub(crate) type_name: &'static str,
pub(crate) data: FontData<'a>,
pub(crate) array: ComputedArray<'a, T>,
}
struct VarLenArrayOfRecords<'a, T> {
pub(crate) type_name: &'static str,
pub(crate) data: FontData<'a>,
pub(crate) array: VarLenArray<'a, T>,
}
impl<'a, T> SomeArray<'a> for ComputedArrayOfRecords<'a, T>
where
T: FontReadWithArgs<'a> + ComputeSize + SomeRecord<'a> + 'a,
T::Args: Copy + 'static,
Self: 'a,
{
fn len(&self) -> usize {
self.array.len()
}
fn get(&self, idx: usize) -> Option<FieldType<'a>> {
self.array
.get(idx)
.ok()
.map(|record| record.traverse(self.data).into())
}
fn type_name(&self) -> &str {
self.type_name
}
}
impl<'a, T: SomeRecord<'a> + Clone> SomeArray<'a> for ArrayOfRecords<'a, T> {
fn type_name(&self) -> &str {
self.type_name
}
fn len(&self) -> usize {
self.records.len()
}
fn get(&self, idx: usize) -> Option<FieldType<'a>> {
self.records
.get(idx)
.map(|record| record.clone().traverse(self.data).into())
}
}
impl<'a, T> SomeArray<'a> for VarLenArrayOfRecords<'a, T>
where
T: FontRead<'a> + VarSize + SomeRecord<'a> + 'a,
Self: 'a,
{
fn len(&self) -> usize {
self.array.iter().count()
}
fn get(&self, idx: usize) -> Option<FieldType<'a>> {
self.array
.get(idx)?
.ok()
.map(|record| record.traverse(self.data).into())
}
fn type_name(&self) -> &str {
self.type_name
}
}
impl<'a> Field<'a> {
/// Create a new field with the given name and value.
pub fn new(name: &'static str, value: impl Into<FieldType<'a>>) -> Self {
Field {
name,
value: value.into(),
}
}
}
/// A wrapper type that implements `Debug` for any table.
struct DebugPrintTable<'a, 'b>(pub &'b (dyn SomeTable<'a> + 'a));
/// A wrapper type that implements `Debug` for any array.
struct DebugPrintArray<'a, 'b>(pub &'b (dyn SomeArray<'a> + 'a));
impl<'a> Debug for FieldType<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::I8(arg0) => arg0.fmt(f),
Self::U8(arg0) => arg0.fmt(f),
Self::I16(arg0) => arg0.fmt(f),
Self::U16(arg0) => arg0.fmt(f),
Self::I32(arg0) => arg0.fmt(f),
Self::U32(arg0) => arg0.fmt(f),
Self::U24(arg0) => arg0.fmt(f),
Self::Tag(arg0) => arg0.fmt(f),
Self::FWord(arg0) => arg0.to_i16().fmt(f),
Self::UfWord(arg0) => arg0.to_u16().fmt(f),
Self::MajorMinor(arg0) => write!(f, "{}.{}", arg0.major, arg0.minor),
Self::Version16Dot16(arg0) => arg0.fmt(f),
Self::F2Dot14(arg0) => arg0.fmt(f),
Self::Fixed(arg0) => arg0.fmt(f),
Self::LongDateTime(arg0) => arg0.as_secs().fmt(f),
Self::GlyphId16(arg0) => {
write!(f, "g")?;
arg0.to_u16().fmt(f)
}
Self::NameId(arg0) => arg0.fmt(f),
Self::StringOffset(string) => match &string.target {
Ok(arg0) => arg0.as_ref().fmt(f),
Err(_) => string.target.fmt(f),
},
Self::ArrayOffset(array) => match &array.target {
Ok(arg0) => arg0.as_ref().fmt(f),
Err(_) => array.target.fmt(f),
},
Self::BareOffset(arg0) => write!(f, "0x{:04X}", arg0.to_u32()),
Self::ResolvedOffset(ResolvedOffset {
target: Ok(arg0), ..
}) => arg0.fmt(f),
Self::ResolvedOffset(arg0) => arg0.target.fmt(f),
Self::Record(arg0) => (arg0 as &(dyn SomeTable<'a> + 'a)).fmt(f),
Self::Array(arg0) => arg0.fmt(f),
Self::Unknown => write!(f, "no repr available"),
}
}
}
impl<'a, 'b> std::fmt::Debug for DebugPrintTable<'a, 'b> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut debug_struct = f.debug_struct(self.0.type_name());
for field in self.0.iter() {
debug_struct.field(field.name, &field.value);
}
debug_struct.finish()
}
}
impl<'a> Debug for dyn SomeTable<'a> + 'a {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
DebugPrintTable(self).fmt(f)
}
}
impl<'a> Debug for dyn SomeString<'a> + 'a {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "\"")?;
for c in self.iter_chars() {
write!(f, "{c}")?
}
write!(f, "\"")
}
}
impl<'a, 'b> std::fmt::Debug for DebugPrintArray<'a, 'b> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut debug_list = f.debug_list();
let mut idx = 0;
while let Some(item) = self.0.get(idx) {
idx += 1;
debug_list.entry(&item);
}
debug_list.finish()
}
}
impl<'a> Debug for dyn SomeArray<'a> + 'a {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
DebugPrintArray(self).fmt(f)
}
}
impl std::fmt::Display for OffsetType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{:+}", self.to_u32())
}
}
// used to give us an auto-impl of Debug
impl<'a> SomeTable<'a> for RecordResolver<'a> {
fn type_name(&self) -> &str {
self.name
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
(self.get_field)(idx, self.data)
}
}
impl<'a> From<u8> for FieldType<'a> {
fn from(src: u8) -> FieldType<'a> {
FieldType::U8(src)
}
}
impl<'a> From<i8> for FieldType<'a> {
fn from(src: i8) -> FieldType<'a> {
FieldType::I8(src)
}
}
impl<'a> From<u16> for FieldType<'a> {
fn from(src: u16) -> FieldType<'a> {
FieldType::U16(src)
}
}
impl<'a> From<i16> for FieldType<'a> {
fn from(src: i16) -> FieldType<'a> {
FieldType::I16(src)
}
}
impl<'a> From<u32> for FieldType<'a> {
fn from(src: u32) -> FieldType<'a> {
FieldType::U32(src)
}
}
impl<'a> From<i32> for FieldType<'a> {
fn from(src: i32) -> FieldType<'a> {
FieldType::I32(src)
}
}
impl<'a> From<Uint24> for FieldType<'a> {
fn from(src: Uint24) -> FieldType<'a> {
FieldType::U24(src)
}
}
impl<'a> From<Tag> for FieldType<'a> {
fn from(src: Tag) -> FieldType<'a> {
FieldType::Tag(src)
}
}
impl<'a> From<FWord> for FieldType<'a> {
fn from(src: FWord) -> FieldType<'a> {
FieldType::FWord(src)
}
}
impl<'a> From<UfWord> for FieldType<'a> {
fn from(src: UfWord) -> FieldType<'a> {
FieldType::UfWord(src)
}
}
impl<'a> From<Fixed> for FieldType<'a> {
fn from(src: Fixed) -> FieldType<'a> {
FieldType::Fixed(src)
}
}
impl<'a> From<F2Dot14> for FieldType<'a> {
fn from(src: F2Dot14) -> FieldType<'a> {
FieldType::F2Dot14(src)
}
}
impl<'a> From<LongDateTime> for FieldType<'a> {
fn from(src: LongDateTime) -> FieldType<'a> {
FieldType::LongDateTime(src)
}
}
impl<'a> From<MajorMinor> for FieldType<'a> {
fn from(src: MajorMinor) -> FieldType<'a> {
FieldType::MajorMinor(src)
}
}
impl<'a> From<Version16Dot16> for FieldType<'a> {
fn from(src: Version16Dot16) -> FieldType<'a> {
FieldType::Version16Dot16(src)
}
}
impl<'a> From<GlyphId16> for FieldType<'a> {
fn from(src: GlyphId16) -> FieldType<'a> {
FieldType::GlyphId16(src)
}
}
impl<'a> From<NameId> for FieldType<'a> {
fn from(src: NameId) -> FieldType<'a> {
FieldType::NameId(src)
}
}
impl<'a> From<RecordResolver<'a>> for FieldType<'a> {
fn from(src: RecordResolver<'a>) -> Self {
FieldType::Record(src)
}
}
impl<'a, T: SomeArray<'a> + 'a> From<T> for FieldType<'a> {
fn from(src: T) -> Self {
FieldType::Array(Box::new(src))
}
}
impl From<Offset16> for OffsetType {
fn from(src: Offset16) -> OffsetType {
OffsetType::Offset16(src.to_u32() as u16)
}
}
impl From<Offset24> for OffsetType {
fn from(src: Offset24) -> OffsetType {
OffsetType::Offset24(Uint24::new(src.to_u32()))
}
}
impl From<Offset32> for OffsetType {
fn from(src: Offset32) -> OffsetType {
OffsetType::Offset32(src.to_u32())
}
}
impl<'a> From<Offset16> for FieldType<'a> {
fn from(src: Offset16) -> FieldType<'a> {
FieldType::BareOffset(src.into())
}
}
impl<'a> From<Offset24> for FieldType<'a> {
fn from(src: Offset24) -> FieldType<'a> {
FieldType::BareOffset(src.into())
}
}
impl<'a> From<Offset32> for FieldType<'a> {
fn from(src: Offset32) -> FieldType<'a> {
FieldType::BareOffset(src.into())
}
}
impl<T: Into<OffsetType> + Clone> From<Nullable<T>> for OffsetType {
fn from(src: Nullable<T>) -> Self {
src.offset().clone().into()
}
}
Codebase Browser
chromium