// THIS FILE IS AUTOGENERATED.
// Any changes to this file will be overwritten.
// For more information about how codegen works, see font-codegen/README.md
#[allow(unused_imports)]
use crate::codegen_prelude::*;
/// [cmap](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#overview)
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct CmapMarker {
encoding_records_byte_len: usize,
}
impl CmapMarker {
fn version_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn num_tables_byte_range(&self) -> Range<usize> {
let start = self.version_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn encoding_records_byte_range(&self) -> Range<usize> {
let start = self.num_tables_byte_range().end;
start..start + self.encoding_records_byte_len
}
}
impl TopLevelTable for Cmap<'_> {
/// `cmap`
const TAG: Tag = Tag::new(b"cmap");
}
impl<'a> FontRead<'a> for Cmap<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
let num_tables: u16 = cursor.read()?;
let encoding_records_byte_len = (num_tables as usize)
.checked_mul(EncodingRecord::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(encoding_records_byte_len);
cursor.finish(CmapMarker {
encoding_records_byte_len,
})
}
}
/// [cmap](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#overview)
pub type Cmap<'a> = TableRef<'a, CmapMarker>;
impl<'a> Cmap<'a> {
/// Table version number (0).
pub fn version(&self) -> u16 {
let range = self.shape.version_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Number of encoding tables that follow.
pub fn num_tables(&self) -> u16 {
let range = self.shape.num_tables_byte_range();
self.data.read_at(range.start).unwrap()
}
pub fn encoding_records(&self) -> &'a [EncodingRecord] {
let range = self.shape.encoding_records_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap<'a> {
fn type_name(&self) -> &str {
"Cmap"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("version", self.version())),
1usize => Some(Field::new("num_tables", self.num_tables())),
2usize => Some(Field::new(
"encoding_records",
traversal::FieldType::array_of_records(
stringify!(EncodingRecord),
self.encoding_records(),
self.offset_data(),
),
)),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
/// [Encoding Record](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#encoding-records-and-encodings)
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct EncodingRecord {
/// Platform ID.
pub platform_id: BigEndian<PlatformId>,
/// Platform-specific encoding ID.
pub encoding_id: BigEndian<u16>,
/// Byte offset from beginning of the [`Cmap`] table to the subtable for this
/// encoding.
pub subtable_offset: BigEndian<Offset32>,
}
impl EncodingRecord {
/// Platform ID.
pub fn platform_id(&self) -> PlatformId {
self.platform_id.get()
}
/// Platform-specific encoding ID.
pub fn encoding_id(&self) -> u16 {
self.encoding_id.get()
}
/// Byte offset from beginning of the [`Cmap`] table to the subtable for this
/// encoding.
pub fn subtable_offset(&self) -> Offset32 {
self.subtable_offset.get()
}
/// Byte offset from beginning of the [`Cmap`] table to the subtable for this
/// encoding.
///
/// The `data` argument should be retrieved from the parent table
/// By calling its `offset_data` method.
pub fn subtable<'a>(&self, data: FontData<'a>) -> Result<CmapSubtable<'a>, ReadError> {
self.subtable_offset().resolve(data)
}
}
impl FixedSize for EncodingRecord {
const RAW_BYTE_LEN: usize =
PlatformId::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + Offset32::RAW_BYTE_LEN;
}
#[cfg(feature = "traversal")]
impl<'a> SomeRecord<'a> for EncodingRecord {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
RecordResolver {
name: "EncodingRecord",
get_field: Box::new(move |idx, _data| match idx {
0usize => Some(Field::new("platform_id", self.platform_id())),
1usize => Some(Field::new("encoding_id", self.encoding_id())),
2usize => Some(Field::new(
"subtable_offset",
FieldType::offset(self.subtable_offset(), self.subtable(_data)),
)),
_ => None,
}),
data,
}
}
}
/// <https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#platform-ids>
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
#[allow(clippy::manual_non_exhaustive)]
pub enum PlatformId {
#[default]
Unicode = 0,
Macintosh = 1,
ISO = 2,
Windows = 3,
Custom = 4,
#[doc(hidden)]
/// If font data is malformed we will map unknown values to this variant
Unknown,
}
impl PlatformId {
/// Create from a raw scalar.
///
/// This will never fail; unknown values will be mapped to the `Unknown` variant
pub fn new(raw: u16) -> Self {
match raw {
0 => Self::Unicode,
1 => Self::Macintosh,
2 => Self::ISO,
3 => Self::Windows,
4 => Self::Custom,
_ => Self::Unknown,
}
}
}
impl font_types::Scalar for PlatformId {
type Raw = <u16 as font_types::Scalar>::Raw;
fn to_raw(self) -> Self::Raw {
(self as u16).to_raw()
}
fn from_raw(raw: Self::Raw) -> Self {
let t = <u16>::from_raw(raw);
Self::new(t)
}
}
#[cfg(feature = "traversal")]
impl<'a> From<PlatformId> for FieldType<'a> {
fn from(src: PlatformId) -> FieldType<'a> {
(src as u16).into()
}
}
/// The different cmap subtable formats.
#[derive(Clone)]
pub enum CmapSubtable<'a> {
Format0(Cmap0<'a>),
Format2(Cmap2<'a>),
Format4(Cmap4<'a>),
Format6(Cmap6<'a>),
Format8(Cmap8<'a>),
Format10(Cmap10<'a>),
Format12(Cmap12<'a>),
Format13(Cmap13<'a>),
Format14(Cmap14<'a>),
}
impl<'a> CmapSubtable<'a> {
///Return the `FontData` used to resolve offsets for this table.
pub fn offset_data(&self) -> FontData<'a> {
match self {
Self::Format0(item) => item.offset_data(),
Self::Format2(item) => item.offset_data(),
Self::Format4(item) => item.offset_data(),
Self::Format6(item) => item.offset_data(),
Self::Format8(item) => item.offset_data(),
Self::Format10(item) => item.offset_data(),
Self::Format12(item) => item.offset_data(),
Self::Format13(item) => item.offset_data(),
Self::Format14(item) => item.offset_data(),
}
}
/// Format number is set to 0.
pub fn format(&self) -> u16 {
match self {
Self::Format0(item) => item.format(),
Self::Format2(item) => item.format(),
Self::Format4(item) => item.format(),
Self::Format6(item) => item.format(),
Self::Format8(item) => item.format(),
Self::Format10(item) => item.format(),
Self::Format12(item) => item.format(),
Self::Format13(item) => item.format(),
Self::Format14(item) => item.format(),
}
}
}
impl<'a> FontRead<'a> for CmapSubtable<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let format: u16 = data.read_at(0usize)?;
match format {
Cmap0Marker::FORMAT => Ok(Self::Format0(FontRead::read(data)?)),
Cmap2Marker::FORMAT => Ok(Self::Format2(FontRead::read(data)?)),
Cmap4Marker::FORMAT => Ok(Self::Format4(FontRead::read(data)?)),
Cmap6Marker::FORMAT => Ok(Self::Format6(FontRead::read(data)?)),
Cmap8Marker::FORMAT => Ok(Self::Format8(FontRead::read(data)?)),
Cmap10Marker::FORMAT => Ok(Self::Format10(FontRead::read(data)?)),
Cmap12Marker::FORMAT => Ok(Self::Format12(FontRead::read(data)?)),
Cmap13Marker::FORMAT => Ok(Self::Format13(FontRead::read(data)?)),
Cmap14Marker::FORMAT => Ok(Self::Format14(FontRead::read(data)?)),
other => Err(ReadError::InvalidFormat(other.into())),
}
}
}
#[cfg(feature = "traversal")]
impl<'a> CmapSubtable<'a> {
fn dyn_inner<'b>(&'b self) -> &'b dyn SomeTable<'a> {
match self {
Self::Format0(table) => table,
Self::Format2(table) => table,
Self::Format4(table) => table,
Self::Format6(table) => table,
Self::Format8(table) => table,
Self::Format10(table) => table,
Self::Format12(table) => table,
Self::Format13(table) => table,
Self::Format14(table) => table,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for CmapSubtable<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.dyn_inner().fmt(f)
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for CmapSubtable<'a> {
fn type_name(&self) -> &str {
self.dyn_inner().type_name()
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
self.dyn_inner().get_field(idx)
}
}
impl Format<u16> for Cmap0Marker {
const FORMAT: u16 = 0;
}
/// [cmap Format 0](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-0-byte-encoding-table): Byte encoding table
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap0Marker {
glyph_id_array_byte_len: usize,
}
impl Cmap0Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn glyph_id_array_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + self.glyph_id_array_byte_len
}
}
impl<'a> FontRead<'a> for Cmap0<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u16>();
let glyph_id_array_byte_len = (256_usize)
.checked_mul(u8::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(glyph_id_array_byte_len);
cursor.finish(Cmap0Marker {
glyph_id_array_byte_len,
})
}
}
/// [cmap Format 0](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-0-byte-encoding-table): Byte encoding table
pub type Cmap0<'a> = TableRef<'a, Cmap0Marker>;
impl<'a> Cmap0<'a> {
/// Format number is set to 0.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// This is the length in bytes of the subtable.
pub fn length(&self) -> u16 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u16 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// An array that maps character codes to glyph index values.
pub fn glyph_id_array(&self) -> &'a [u8] {
let range = self.shape.glyph_id_array_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap0<'a> {
fn type_name(&self) -> &str {
"Cmap0"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("glyph_id_array", self.glyph_id_array())),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap0<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
impl Format<u16> for Cmap2Marker {
const FORMAT: u16 = 2;
}
/// [cmap Format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-2-high-byte-mapping-through-table): High-byte mapping through table
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap2Marker {
sub_header_keys_byte_len: usize,
}
impl Cmap2Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn sub_header_keys_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + self.sub_header_keys_byte_len
}
}
impl<'a> FontRead<'a> for Cmap2<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u16>();
let sub_header_keys_byte_len = (256_usize)
.checked_mul(u16::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(sub_header_keys_byte_len);
cursor.finish(Cmap2Marker {
sub_header_keys_byte_len,
})
}
}
/// [cmap Format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-2-high-byte-mapping-through-table): High-byte mapping through table
pub type Cmap2<'a> = TableRef<'a, Cmap2Marker>;
impl<'a> Cmap2<'a> {
/// Format number is set to 2.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// This is the length in bytes of the subtable.
pub fn length(&self) -> u16 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u16 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array that maps high bytes to subHeaders: value is subHeader
/// index × 8.
pub fn sub_header_keys(&self) -> &'a [BigEndian<u16>] {
let range = self.shape.sub_header_keys_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap2<'a> {
fn type_name(&self) -> &str {
"Cmap2"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("sub_header_keys", self.sub_header_keys())),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap2<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
/// Part of [Cmap2]
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct SubHeader {
/// First valid low byte for this SubHeader.
pub first_code: BigEndian<u16>,
/// Number of valid low bytes for this SubHeader.
pub entry_count: BigEndian<u16>,
/// See text below.
pub id_delta: BigEndian<i16>,
/// See text below.
pub id_range_offset: BigEndian<u16>,
}
impl SubHeader {
/// First valid low byte for this SubHeader.
pub fn first_code(&self) -> u16 {
self.first_code.get()
}
/// Number of valid low bytes for this SubHeader.
pub fn entry_count(&self) -> u16 {
self.entry_count.get()
}
/// See text below.
pub fn id_delta(&self) -> i16 {
self.id_delta.get()
}
/// See text below.
pub fn id_range_offset(&self) -> u16 {
self.id_range_offset.get()
}
}
impl FixedSize for SubHeader {
const RAW_BYTE_LEN: usize =
u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + i16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
}
#[cfg(feature = "traversal")]
impl<'a> SomeRecord<'a> for SubHeader {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
RecordResolver {
name: "SubHeader",
get_field: Box::new(move |idx, _data| match idx {
0usize => Some(Field::new("first_code", self.first_code())),
1usize => Some(Field::new("entry_count", self.entry_count())),
2usize => Some(Field::new("id_delta", self.id_delta())),
3usize => Some(Field::new("id_range_offset", self.id_range_offset())),
_ => None,
}),
data,
}
}
}
impl Format<u16> for Cmap4Marker {
const FORMAT: u16 = 4;
}
/// [cmap Format 4](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-4-segment-mapping-to-delta-values): Segment mapping to delta values
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap4Marker {
end_code_byte_len: usize,
start_code_byte_len: usize,
id_delta_byte_len: usize,
id_range_offsets_byte_len: usize,
glyph_id_array_byte_len: usize,
}
impl Cmap4Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn seg_count_x2_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn search_range_byte_range(&self) -> Range<usize> {
let start = self.seg_count_x2_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn entry_selector_byte_range(&self) -> Range<usize> {
let start = self.search_range_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn range_shift_byte_range(&self) -> Range<usize> {
let start = self.entry_selector_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn end_code_byte_range(&self) -> Range<usize> {
let start = self.range_shift_byte_range().end;
start..start + self.end_code_byte_len
}
fn reserved_pad_byte_range(&self) -> Range<usize> {
let start = self.end_code_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn start_code_byte_range(&self) -> Range<usize> {
let start = self.reserved_pad_byte_range().end;
start..start + self.start_code_byte_len
}
fn id_delta_byte_range(&self) -> Range<usize> {
let start = self.start_code_byte_range().end;
start..start + self.id_delta_byte_len
}
fn id_range_offsets_byte_range(&self) -> Range<usize> {
let start = self.id_delta_byte_range().end;
start..start + self.id_range_offsets_byte_len
}
fn glyph_id_array_byte_range(&self) -> Range<usize> {
let start = self.id_range_offsets_byte_range().end;
start..start + self.glyph_id_array_byte_len
}
}
impl<'a> FontRead<'a> for Cmap4<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u16>();
let seg_count_x2: u16 = cursor.read()?;
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u16>();
let end_code_byte_len = (transforms::half(seg_count_x2))
.checked_mul(u16::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(end_code_byte_len);
cursor.advance::<u16>();
let start_code_byte_len = (transforms::half(seg_count_x2))
.checked_mul(u16::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(start_code_byte_len);
let id_delta_byte_len = (transforms::half(seg_count_x2))
.checked_mul(i16::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(id_delta_byte_len);
let id_range_offsets_byte_len = (transforms::half(seg_count_x2))
.checked_mul(u16::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(id_range_offsets_byte_len);
let glyph_id_array_byte_len =
cursor.remaining_bytes() / u16::RAW_BYTE_LEN * u16::RAW_BYTE_LEN;
cursor.advance_by(glyph_id_array_byte_len);
cursor.finish(Cmap4Marker {
end_code_byte_len,
start_code_byte_len,
id_delta_byte_len,
id_range_offsets_byte_len,
glyph_id_array_byte_len,
})
}
}
/// [cmap Format 4](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-4-segment-mapping-to-delta-values): Segment mapping to delta values
pub type Cmap4<'a> = TableRef<'a, Cmap4Marker>;
impl<'a> Cmap4<'a> {
/// Format number is set to 4.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// This is the length in bytes of the subtable.
pub fn length(&self) -> u16 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u16 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// 2 × segCount.
pub fn seg_count_x2(&self) -> u16 {
let range = self.shape.seg_count_x2_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Maximum power of 2 less than or equal to segCount, times 2
/// ((2**floor(log2(segCount))) * 2, where “**” is an
/// exponentiation operator)
pub fn search_range(&self) -> u16 {
let range = self.shape.search_range_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Log2 of the maximum power of 2 less than or equal to numTables
/// (log2(searchRange/2), which is equal to floor(log2(segCount)))
pub fn entry_selector(&self) -> u16 {
let range = self.shape.entry_selector_byte_range();
self.data.read_at(range.start).unwrap()
}
/// segCount times 2, minus searchRange ((segCount * 2) -
/// searchRange)
pub fn range_shift(&self) -> u16 {
let range = self.shape.range_shift_byte_range();
self.data.read_at(range.start).unwrap()
}
/// End characterCode for each segment, last=0xFFFF.
pub fn end_code(&self) -> &'a [BigEndian<u16>] {
let range = self.shape.end_code_byte_range();
self.data.read_array(range).unwrap()
}
/// Start character code for each segment.
pub fn start_code(&self) -> &'a [BigEndian<u16>] {
let range = self.shape.start_code_byte_range();
self.data.read_array(range).unwrap()
}
/// Delta for all character codes in segment.
pub fn id_delta(&self) -> &'a [BigEndian<i16>] {
let range = self.shape.id_delta_byte_range();
self.data.read_array(range).unwrap()
}
/// Offsets into glyphIdArray or 0
pub fn id_range_offsets(&self) -> &'a [BigEndian<u16>] {
let range = self.shape.id_range_offsets_byte_range();
self.data.read_array(range).unwrap()
}
/// Glyph index array (arbitrary length)
pub fn glyph_id_array(&self) -> &'a [BigEndian<u16>] {
let range = self.shape.glyph_id_array_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap4<'a> {
fn type_name(&self) -> &str {
"Cmap4"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("seg_count_x2", self.seg_count_x2())),
4usize => Some(Field::new("search_range", self.search_range())),
5usize => Some(Field::new("entry_selector", self.entry_selector())),
6usize => Some(Field::new("range_shift", self.range_shift())),
7usize => Some(Field::new("end_code", self.end_code())),
8usize => Some(Field::new("start_code", self.start_code())),
9usize => Some(Field::new("id_delta", self.id_delta())),
10usize => Some(Field::new("id_range_offsets", self.id_range_offsets())),
11usize => Some(Field::new("glyph_id_array", self.glyph_id_array())),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap4<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
impl Format<u16> for Cmap6Marker {
const FORMAT: u16 = 6;
}
/// [cmap Format 6](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-6-trimmed-table-mapping): Trimmed table mapping
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap6Marker {
glyph_id_array_byte_len: usize,
}
impl Cmap6Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn first_code_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn entry_count_byte_range(&self) -> Range<usize> {
let start = self.first_code_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn glyph_id_array_byte_range(&self) -> Range<usize> {
let start = self.entry_count_byte_range().end;
start..start + self.glyph_id_array_byte_len
}
}
impl<'a> FontRead<'a> for Cmap6<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u16>();
let entry_count: u16 = cursor.read()?;
let glyph_id_array_byte_len = (entry_count as usize)
.checked_mul(u16::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(glyph_id_array_byte_len);
cursor.finish(Cmap6Marker {
glyph_id_array_byte_len,
})
}
}
/// [cmap Format 6](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-6-trimmed-table-mapping): Trimmed table mapping
pub type Cmap6<'a> = TableRef<'a, Cmap6Marker>;
impl<'a> Cmap6<'a> {
/// Format number is set to 6.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// This is the length in bytes of the subtable.
pub fn length(&self) -> u16 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u16 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// First character code of subrange.
pub fn first_code(&self) -> u16 {
let range = self.shape.first_code_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Number of character codes in subrange.
pub fn entry_count(&self) -> u16 {
let range = self.shape.entry_count_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array of glyph index values for character codes in the range.
pub fn glyph_id_array(&self) -> &'a [BigEndian<u16>] {
let range = self.shape.glyph_id_array_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap6<'a> {
fn type_name(&self) -> &str {
"Cmap6"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("first_code", self.first_code())),
4usize => Some(Field::new("entry_count", self.entry_count())),
5usize => Some(Field::new("glyph_id_array", self.glyph_id_array())),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap6<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
impl Format<u16> for Cmap8Marker {
const FORMAT: u16 = 8;
}
/// [cmap Format 8](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-8-mixed-16-bit-and-32-bit-coverage): mixed 16-bit and 32-bit coverage
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap8Marker {
is32_byte_len: usize,
groups_byte_len: usize,
}
impl Cmap8Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn reserved_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.reserved_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn is32_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + self.is32_byte_len
}
fn num_groups_byte_range(&self) -> Range<usize> {
let start = self.is32_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn groups_byte_range(&self) -> Range<usize> {
let start = self.num_groups_byte_range().end;
start..start + self.groups_byte_len
}
}
impl<'a> FontRead<'a> for Cmap8<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u32>();
cursor.advance::<u32>();
let is32_byte_len = (8192_usize)
.checked_mul(u8::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(is32_byte_len);
let num_groups: u32 = cursor.read()?;
let groups_byte_len = (num_groups as usize)
.checked_mul(SequentialMapGroup::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(groups_byte_len);
cursor.finish(Cmap8Marker {
is32_byte_len,
groups_byte_len,
})
}
}
/// [cmap Format 8](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-8-mixed-16-bit-and-32-bit-coverage): mixed 16-bit and 32-bit coverage
pub type Cmap8<'a> = TableRef<'a, Cmap8Marker>;
impl<'a> Cmap8<'a> {
/// Subtable format; set to 8.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Byte length of this subtable (including the header)
pub fn length(&self) -> u32 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u32 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Tightly packed array of bits (8K bytes total) indicating
/// whether the particular 16-bit (index) value is the start of a
/// 32-bit character code
pub fn is32(&self) -> &'a [u8] {
let range = self.shape.is32_byte_range();
self.data.read_array(range).unwrap()
}
/// Number of groupings which follow
pub fn num_groups(&self) -> u32 {
let range = self.shape.num_groups_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array of SequentialMapGroup records.
pub fn groups(&self) -> &'a [SequentialMapGroup] {
let range = self.shape.groups_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap8<'a> {
fn type_name(&self) -> &str {
"Cmap8"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("is32", self.is32())),
4usize => Some(Field::new("num_groups", self.num_groups())),
5usize => Some(Field::new(
"groups",
traversal::FieldType::array_of_records(
stringify!(SequentialMapGroup),
self.groups(),
self.offset_data(),
),
)),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap8<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
/// Used in [Cmap8] and [Cmap12]
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct SequentialMapGroup {
/// First character code in this group; note that if this group is
/// for one or more 16-bit character codes (which is determined
/// from the is32 array), this 32-bit value will have the high
/// 16-bits set to zero
pub start_char_code: BigEndian<u32>,
/// Last character code in this group; same condition as listed
/// above for the startCharCode
pub end_char_code: BigEndian<u32>,
/// Glyph index corresponding to the starting character code
pub start_glyph_id: BigEndian<u32>,
}
impl SequentialMapGroup {
/// First character code in this group; note that if this group is
/// for one or more 16-bit character codes (which is determined
/// from the is32 array), this 32-bit value will have the high
/// 16-bits set to zero
pub fn start_char_code(&self) -> u32 {
self.start_char_code.get()
}
/// Last character code in this group; same condition as listed
/// above for the startCharCode
pub fn end_char_code(&self) -> u32 {
self.end_char_code.get()
}
/// Glyph index corresponding to the starting character code
pub fn start_glyph_id(&self) -> u32 {
self.start_glyph_id.get()
}
}
impl FixedSize for SequentialMapGroup {
const RAW_BYTE_LEN: usize = u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN;
}
#[cfg(feature = "traversal")]
impl<'a> SomeRecord<'a> for SequentialMapGroup {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
RecordResolver {
name: "SequentialMapGroup",
get_field: Box::new(move |idx, _data| match idx {
0usize => Some(Field::new("start_char_code", self.start_char_code())),
1usize => Some(Field::new("end_char_code", self.end_char_code())),
2usize => Some(Field::new("start_glyph_id", self.start_glyph_id())),
_ => None,
}),
data,
}
}
}
impl Format<u16> for Cmap10Marker {
const FORMAT: u16 = 10;
}
/// [cmap Format 10](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-10-trimmed-array): Tr
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap10Marker {
glyph_id_array_byte_len: usize,
}
impl Cmap10Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn reserved_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.reserved_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn start_char_code_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn num_chars_byte_range(&self) -> Range<usize> {
let start = self.start_char_code_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn glyph_id_array_byte_range(&self) -> Range<usize> {
let start = self.num_chars_byte_range().end;
start..start + self.glyph_id_array_byte_len
}
}
impl<'a> FontRead<'a> for Cmap10<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u32>();
cursor.advance::<u32>();
cursor.advance::<u32>();
cursor.advance::<u32>();
let glyph_id_array_byte_len =
cursor.remaining_bytes() / u16::RAW_BYTE_LEN * u16::RAW_BYTE_LEN;
cursor.advance_by(glyph_id_array_byte_len);
cursor.finish(Cmap10Marker {
glyph_id_array_byte_len,
})
}
}
/// [cmap Format 10](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-10-trimmed-array): Tr
pub type Cmap10<'a> = TableRef<'a, Cmap10Marker>;
impl<'a> Cmap10<'a> {
/// Subtable format; set to 10.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Byte length of this subtable (including the header)
pub fn length(&self) -> u32 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u32 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// First character code covered
pub fn start_char_code(&self) -> u32 {
let range = self.shape.start_char_code_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Number of character codes covered
pub fn num_chars(&self) -> u32 {
let range = self.shape.num_chars_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array of glyph indices for the character codes covered
pub fn glyph_id_array(&self) -> &'a [BigEndian<u16>] {
let range = self.shape.glyph_id_array_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap10<'a> {
fn type_name(&self) -> &str {
"Cmap10"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("start_char_code", self.start_char_code())),
4usize => Some(Field::new("num_chars", self.num_chars())),
5usize => Some(Field::new("glyph_id_array", self.glyph_id_array())),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap10<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
impl Format<u16> for Cmap12Marker {
const FORMAT: u16 = 12;
}
/// [cmap Format 12](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-12-segmented-coverage): Segmented coverage
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap12Marker {
groups_byte_len: usize,
}
impl Cmap12Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn reserved_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.reserved_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn num_groups_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn groups_byte_range(&self) -> Range<usize> {
let start = self.num_groups_byte_range().end;
start..start + self.groups_byte_len
}
}
impl<'a> FontRead<'a> for Cmap12<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u32>();
cursor.advance::<u32>();
let num_groups: u32 = cursor.read()?;
let groups_byte_len = (num_groups as usize)
.checked_mul(SequentialMapGroup::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(groups_byte_len);
cursor.finish(Cmap12Marker { groups_byte_len })
}
}
/// [cmap Format 12](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-12-segmented-coverage): Segmented coverage
pub type Cmap12<'a> = TableRef<'a, Cmap12Marker>;
impl<'a> Cmap12<'a> {
/// Subtable format; set to 12.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Byte length of this subtable (including the header)
pub fn length(&self) -> u32 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u32 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Number of groupings which follow
pub fn num_groups(&self) -> u32 {
let range = self.shape.num_groups_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array of SequentialMapGroup records.
pub fn groups(&self) -> &'a [SequentialMapGroup] {
let range = self.shape.groups_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap12<'a> {
fn type_name(&self) -> &str {
"Cmap12"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("num_groups", self.num_groups())),
4usize => Some(Field::new(
"groups",
traversal::FieldType::array_of_records(
stringify!(SequentialMapGroup),
self.groups(),
self.offset_data(),
),
)),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap12<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
impl Format<u16> for Cmap13Marker {
const FORMAT: u16 = 13;
}
/// [cmap Format 13](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-13-many-to-one-range-mappings): Many-to-one range mappings
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap13Marker {
groups_byte_len: usize,
}
impl Cmap13Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn reserved_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.reserved_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn language_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn num_groups_byte_range(&self) -> Range<usize> {
let start = self.language_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn groups_byte_range(&self) -> Range<usize> {
let start = self.num_groups_byte_range().end;
start..start + self.groups_byte_len
}
}
impl<'a> FontRead<'a> for Cmap13<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u16>();
cursor.advance::<u32>();
cursor.advance::<u32>();
let num_groups: u32 = cursor.read()?;
let groups_byte_len = (num_groups as usize)
.checked_mul(ConstantMapGroup::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(groups_byte_len);
cursor.finish(Cmap13Marker { groups_byte_len })
}
}
/// [cmap Format 13](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-13-many-to-one-range-mappings): Many-to-one range mappings
pub type Cmap13<'a> = TableRef<'a, Cmap13Marker>;
impl<'a> Cmap13<'a> {
/// Subtable format; set to 13.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Byte length of this subtable (including the header)
pub fn length(&self) -> u32 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// For requirements on use of the language field, see “Use of
/// the language field in 'cmap' subtables” in this document.
pub fn language(&self) -> u32 {
let range = self.shape.language_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Number of groupings which follow
pub fn num_groups(&self) -> u32 {
let range = self.shape.num_groups_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array of ConstantMapGroup records.
pub fn groups(&self) -> &'a [ConstantMapGroup] {
let range = self.shape.groups_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap13<'a> {
fn type_name(&self) -> &str {
"Cmap13"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new("language", self.language())),
3usize => Some(Field::new("num_groups", self.num_groups())),
4usize => Some(Field::new(
"groups",
traversal::FieldType::array_of_records(
stringify!(ConstantMapGroup),
self.groups(),
self.offset_data(),
),
)),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap13<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
/// Part of [Cmap13]
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct ConstantMapGroup {
/// First character code in this group
pub start_char_code: BigEndian<u32>,
/// Last character code in this group
pub end_char_code: BigEndian<u32>,
/// Glyph index to be used for all the characters in the group’s
/// range.
pub glyph_id: BigEndian<u32>,
}
impl ConstantMapGroup {
/// First character code in this group
pub fn start_char_code(&self) -> u32 {
self.start_char_code.get()
}
/// Last character code in this group
pub fn end_char_code(&self) -> u32 {
self.end_char_code.get()
}
/// Glyph index to be used for all the characters in the group’s
/// range.
pub fn glyph_id(&self) -> u32 {
self.glyph_id.get()
}
}
impl FixedSize for ConstantMapGroup {
const RAW_BYTE_LEN: usize = u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN + u32::RAW_BYTE_LEN;
}
#[cfg(feature = "traversal")]
impl<'a> SomeRecord<'a> for ConstantMapGroup {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
RecordResolver {
name: "ConstantMapGroup",
get_field: Box::new(move |idx, _data| match idx {
0usize => Some(Field::new("start_char_code", self.start_char_code())),
1usize => Some(Field::new("end_char_code", self.end_char_code())),
2usize => Some(Field::new("glyph_id", self.glyph_id())),
_ => None,
}),
data,
}
}
}
impl Format<u16> for Cmap14Marker {
const FORMAT: u16 = 14;
}
/// [cmap Format 14](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-14-unicode-variation-sequences): Unicode Variation Sequences
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct Cmap14Marker {
var_selector_byte_len: usize,
}
impl Cmap14Marker {
fn format_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u16::RAW_BYTE_LEN
}
fn length_byte_range(&self) -> Range<usize> {
let start = self.format_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn num_var_selector_records_byte_range(&self) -> Range<usize> {
let start = self.length_byte_range().end;
start..start + u32::RAW_BYTE_LEN
}
fn var_selector_byte_range(&self) -> Range<usize> {
let start = self.num_var_selector_records_byte_range().end;
start..start + self.var_selector_byte_len
}
}
impl<'a> FontRead<'a> for Cmap14<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
cursor.advance::<u16>();
cursor.advance::<u32>();
let num_var_selector_records: u32 = cursor.read()?;
let var_selector_byte_len = (num_var_selector_records as usize)
.checked_mul(VariationSelector::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(var_selector_byte_len);
cursor.finish(Cmap14Marker {
var_selector_byte_len,
})
}
}
/// [cmap Format 14](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#format-14-unicode-variation-sequences): Unicode Variation Sequences
pub type Cmap14<'a> = TableRef<'a, Cmap14Marker>;
impl<'a> Cmap14<'a> {
/// Subtable format. Set to 14.
pub fn format(&self) -> u16 {
let range = self.shape.format_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Byte length of this subtable (including this header)
pub fn length(&self) -> u32 {
let range = self.shape.length_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Number of variation Selector Records
pub fn num_var_selector_records(&self) -> u32 {
let range = self.shape.num_var_selector_records_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array of VariationSelector records.
pub fn var_selector(&self) -> &'a [VariationSelector] {
let range = self.shape.var_selector_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for Cmap14<'a> {
fn type_name(&self) -> &str {
"Cmap14"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("format", self.format())),
1usize => Some(Field::new("length", self.length())),
2usize => Some(Field::new(
"num_var_selector_records",
self.num_var_selector_records(),
)),
3usize => Some(Field::new(
"var_selector",
traversal::FieldType::array_of_records(
stringify!(VariationSelector),
self.var_selector(),
self.offset_data(),
),
)),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for Cmap14<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
/// Part of [Cmap14]
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct VariationSelector {
/// Variation selector
pub var_selector: BigEndian<Uint24>,
/// Offset from the start of the [`Cmap14`] subtable to Default UVS
/// Table. May be NULL.
pub default_uvs_offset: BigEndian<Nullable<Offset32>>,
/// Offset from the start of the [`Cmap14`] subtable to Non-Default
/// UVS Table. May be NULL.
pub non_default_uvs_offset: BigEndian<Nullable<Offset32>>,
}
impl VariationSelector {
/// Variation selector
pub fn var_selector(&self) -> Uint24 {
self.var_selector.get()
}
/// Offset from the start of the [`Cmap14`] subtable to Default UVS
/// Table. May be NULL.
pub fn default_uvs_offset(&self) -> Nullable<Offset32> {
self.default_uvs_offset.get()
}
/// Offset from the start of the [`Cmap14`] subtable to Default UVS
/// Table. May be NULL.
///
/// The `data` argument should be retrieved from the parent table
/// By calling its `offset_data` method.
pub fn default_uvs<'a>(&self, data: FontData<'a>) -> Option<Result<DefaultUvs<'a>, ReadError>> {
self.default_uvs_offset().resolve(data)
}
/// Offset from the start of the [`Cmap14`] subtable to Non-Default
/// UVS Table. May be NULL.
pub fn non_default_uvs_offset(&self) -> Nullable<Offset32> {
self.non_default_uvs_offset.get()
}
/// Offset from the start of the [`Cmap14`] subtable to Non-Default
/// UVS Table. May be NULL.
///
/// The `data` argument should be retrieved from the parent table
/// By calling its `offset_data` method.
pub fn non_default_uvs<'a>(
&self,
data: FontData<'a>,
) -> Option<Result<NonDefaultUvs<'a>, ReadError>> {
self.non_default_uvs_offset().resolve(data)
}
}
impl FixedSize for VariationSelector {
const RAW_BYTE_LEN: usize =
Uint24::RAW_BYTE_LEN + Offset32::RAW_BYTE_LEN + Offset32::RAW_BYTE_LEN;
}
#[cfg(feature = "traversal")]
impl<'a> SomeRecord<'a> for VariationSelector {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
RecordResolver {
name: "VariationSelector",
get_field: Box::new(move |idx, _data| match idx {
0usize => Some(Field::new("var_selector", self.var_selector())),
1usize => Some(Field::new(
"default_uvs_offset",
FieldType::offset(self.default_uvs_offset(), self.default_uvs(_data)),
)),
2usize => Some(Field::new(
"non_default_uvs_offset",
FieldType::offset(self.non_default_uvs_offset(), self.non_default_uvs(_data)),
)),
_ => None,
}),
data,
}
}
}
/// [Default UVS table](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#default-uvs-table)
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct DefaultUvsMarker {
ranges_byte_len: usize,
}
impl DefaultUvsMarker {
fn num_unicode_value_ranges_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u32::RAW_BYTE_LEN
}
fn ranges_byte_range(&self) -> Range<usize> {
let start = self.num_unicode_value_ranges_byte_range().end;
start..start + self.ranges_byte_len
}
}
impl<'a> FontRead<'a> for DefaultUvs<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
let num_unicode_value_ranges: u32 = cursor.read()?;
let ranges_byte_len = (num_unicode_value_ranges as usize)
.checked_mul(UnicodeRange::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(ranges_byte_len);
cursor.finish(DefaultUvsMarker { ranges_byte_len })
}
}
/// [Default UVS table](https://docs.microsoft.com/en-us/typography/opentype/spec/cmap#default-uvs-table)
pub type DefaultUvs<'a> = TableRef<'a, DefaultUvsMarker>;
impl<'a> DefaultUvs<'a> {
/// Number of Unicode character ranges.
pub fn num_unicode_value_ranges(&self) -> u32 {
let range = self.shape.num_unicode_value_ranges_byte_range();
self.data.read_at(range.start).unwrap()
}
/// Array of UnicodeRange records.
pub fn ranges(&self) -> &'a [UnicodeRange] {
let range = self.shape.ranges_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for DefaultUvs<'a> {
fn type_name(&self) -> &str {
"DefaultUvs"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new(
"num_unicode_value_ranges",
self.num_unicode_value_ranges(),
)),
1usize => Some(Field::new(
"ranges",
traversal::FieldType::array_of_records(
stringify!(UnicodeRange),
self.ranges(),
self.offset_data(),
),
)),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for DefaultUvs<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
/// [Non-Default UVS table](https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#non-default-uvs-table)
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct NonDefaultUvsMarker {
uvs_mapping_byte_len: usize,
}
impl NonDefaultUvsMarker {
fn num_uvs_mappings_byte_range(&self) -> Range<usize> {
let start = 0;
start..start + u32::RAW_BYTE_LEN
}
fn uvs_mapping_byte_range(&self) -> Range<usize> {
let start = self.num_uvs_mappings_byte_range().end;
start..start + self.uvs_mapping_byte_len
}
}
impl<'a> FontRead<'a> for NonDefaultUvs<'a> {
fn read(data: FontData<'a>) -> Result<Self, ReadError> {
let mut cursor = data.cursor();
let num_uvs_mappings: u32 = cursor.read()?;
let uvs_mapping_byte_len = (num_uvs_mappings as usize)
.checked_mul(UvsMapping::RAW_BYTE_LEN)
.ok_or(ReadError::OutOfBounds)?;
cursor.advance_by(uvs_mapping_byte_len);
cursor.finish(NonDefaultUvsMarker {
uvs_mapping_byte_len,
})
}
}
/// [Non-Default UVS table](https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#non-default-uvs-table)
pub type NonDefaultUvs<'a> = TableRef<'a, NonDefaultUvsMarker>;
impl<'a> NonDefaultUvs<'a> {
pub fn num_uvs_mappings(&self) -> u32 {
let range = self.shape.num_uvs_mappings_byte_range();
self.data.read_at(range.start).unwrap()
}
pub fn uvs_mapping(&self) -> &'a [UvsMapping] {
let range = self.shape.uvs_mapping_byte_range();
self.data.read_array(range).unwrap()
}
}
#[cfg(feature = "traversal")]
impl<'a> SomeTable<'a> for NonDefaultUvs<'a> {
fn type_name(&self) -> &str {
"NonDefaultUvs"
}
fn get_field(&self, idx: usize) -> Option<Field<'a>> {
match idx {
0usize => Some(Field::new("num_uvs_mappings", self.num_uvs_mappings())),
1usize => Some(Field::new(
"uvs_mapping",
traversal::FieldType::array_of_records(
stringify!(UvsMapping),
self.uvs_mapping(),
self.offset_data(),
),
)),
_ => None,
}
}
}
#[cfg(feature = "traversal")]
impl<'a> std::fmt::Debug for NonDefaultUvs<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(self as &dyn SomeTable<'a>).fmt(f)
}
}
/// Part of [Cmap14]
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct UvsMapping {
/// Base Unicode value of the UVS
pub unicode_value: BigEndian<Uint24>,
/// Glyph ID of the UVS
pub glyph_id: BigEndian<u16>,
}
impl UvsMapping {
/// Base Unicode value of the UVS
pub fn unicode_value(&self) -> Uint24 {
self.unicode_value.get()
}
/// Glyph ID of the UVS
pub fn glyph_id(&self) -> u16 {
self.glyph_id.get()
}
}
impl FixedSize for UvsMapping {
const RAW_BYTE_LEN: usize = Uint24::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
}
#[cfg(feature = "traversal")]
impl<'a> SomeRecord<'a> for UvsMapping {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
RecordResolver {
name: "UvsMapping",
get_field: Box::new(move |idx, _data| match idx {
0usize => Some(Field::new("unicode_value", self.unicode_value())),
1usize => Some(Field::new("glyph_id", self.glyph_id())),
_ => None,
}),
data,
}
}
}
/// Part of [Cmap14]
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct UnicodeRange {
/// First value in this range
pub start_unicode_value: BigEndian<Uint24>,
/// Number of additional values in this range
pub additional_count: u8,
}
impl UnicodeRange {
/// First value in this range
pub fn start_unicode_value(&self) -> Uint24 {
self.start_unicode_value.get()
}
/// Number of additional values in this range
pub fn additional_count(&self) -> u8 {
self.additional_count
}
}
impl FixedSize for UnicodeRange {
const RAW_BYTE_LEN: usize = Uint24::RAW_BYTE_LEN + u8::RAW_BYTE_LEN;
}
#[cfg(feature = "traversal")]
impl<'a> SomeRecord<'a> for UnicodeRange {
fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> {
RecordResolver {
name: "UnicodeRange",
get_field: Box::new(move |idx, _data| match idx {
0usize => Some(Field::new(
"start_unicode_value",
self.start_unicode_value(),
)),
1usize => Some(Field::new("additional_count", self.additional_count())),
_ => None,
}),
data,
}
}
}
Codebase Browser
chromium