Struct ParseAccumulator 

pub(crate) struct ParseAccumulator<'a> {

    pub(crate) header: HeaderState,
    pub(crate) state: State,
    pub(crate) composites_depth: u32,
    pub(crate) direction: DirectionState,
    pub(crate) finish: FinishState,
    pub(crate) font_name: Cow<'a, str>,
    pub(crate) full_name: Cow<'a, str>,
    pub(crate) family_name: Cow<'a, str>,
    pub(crate) weight: Cow<'a, str>,
    pub(crate) encoding_scheme: Cow<'a, str>,
    pub(crate) italic_angle: f32,
    pub(crate) is_fixed_pitch: bool,
    pub(crate) font_bbox: BBox,
    pub(crate) font_bbox_presence: Presence,
    pub(crate) underline_position: f32,
    pub(crate) underline_thickness: f32,
    pub(crate) cap_height: f32,
    pub(crate) x_height: f32,
    pub(crate) ascender: f32,
    pub(crate) descender: f32,
    pub(crate) chars: Vec<CharacterMetric<'a>>,
    pub(crate) kerns: Vec<KerningPair<'a>>,
}

Fields

header: HeaderState

state: State

composites_depth: u32

direction: DirectionState

finish: FinishState

font_name: Cow<'a, str>

full_name: Cow<'a, str>

family_name: Cow<'a, str>

weight: Cow<'a, str>

encoding_scheme: Cow<'a, str>

italic_angle: f32

is_fixed_pitch: bool

font_bbox: BBox

font_bbox_presence: Presence

underline_position: f32

underline_thickness: f32

cap_height: f32

x_height: f32

ascender: f32

descender: f32

chars: Vec<CharacterMetric<'a>>

kerns: Vec<KerningPair<'a>>

Implementations

impl<'a> ParseAccumulator<'a>

pub(crate) fn new() -> Self

pub(crate) fn parse_line( &mut self, raw: &'a str, lineno: usize, ) -> Result<(), ParseError>

pub(crate) fn finish(self) -> Result<FontMetrics<'a>, ParseError>

pub(crate) fn skip_block_line(&mut self, kw: &str) -> bool

pub(crate) fn parse_header_line( &mut self, kw: &str, rest: &str, lineno: usize, ) -> Result<bool, ParseError>

pub(crate) fn is_done(&self) -> bool

pub(crate) fn parse_body_line( &mut self, line: &'a str, kw: &str, rest: &'a str, lineno: usize, ) -> Result<(), ParseError>

pub(crate) fn start_char_metrics( &mut self, rest: &str, lineno: usize, ) -> Result<(), ParseError>

pub(crate) fn start_kern_pairs( &mut self, rest: &str, lineno: usize, ) -> Result<(), ParseError>

pub(crate) fn start_direction( &mut self, rest: &str, lineno: usize, ) -> Result<(), ParseError>