Struct hcklib::core::Core

pub struct Core<'a, L> { /* fields omitted */ }

The main processing loop

Implementations

impl<'a, L> Core<'a, L> where
    L: LineParser<'a>, 

pub fn new(
    config: &'a CoreConfig<'_>,
    fields: &'a [FieldRange],
    line_parser: L,
    line_buffer: &'a mut LineBuffer
) -> Self

Create a new “core” the can be used to parse multiple inputs

pub fn hck_input<P, W>(
    &mut self,
    input: HckInput<P>,
    output: W,
    header: Option<Vec<u8>>
) -> Result<(), Error> where
    P: AsRef<Path>,
    W: Write, 

pub fn hck_bytes<W>(&mut self, bytes: &[u8], output: W) -> Result<(), Error> where
    W: Write, 

Iterate over the lines in a slice of bytes.

The input slice of bytes is assumed to end in a newline.

pub fn hck_bytes_fast<W: Write>(
    &mut self,
    bytes: &[u8],
    output: W
) -> Result<(), Error>

Fast mode iteration over lines in a slice of bytes.

This expects the seperator to be a single byte and the newline to be a singel byte.

Instead of seaching for linebreaks, then splitting up the line on the sep, fast mode looks for either sep or newline at the same time, so instead of two passes over the bytes we only make one pass.

pub fn hck_reader_fast<R: Read, W: Write>(
    &mut self,
    reader: R,
    output: W
) -> Result<(), Error>

Fast mode iteration over lines in a reader.

This expects the separator to be a single byte and the newline to be a single byte.

Instead of seaching for linebreaks, then splitting up the line on the sep, fast mode looks for either sep or newline at the same time, so instead of two passes over the bytes we only make one pass.

pub fn hck_reader<R: Read, W: Write>(
    &mut self,
    reader: R,
    output: W
) -> Result<(), Error>

Process lines from a reader.