Struct Engine 

pub struct Engine<S: Sink> { /* private fields */ }

The rendering engine: feed it HTML and it writes the PDF into a Sink.

use sghtmltopdf::{Engine, EngineOptions, MemorySink};

let mut engine = Engine::new(EngineOptions::default(), MemorySink::new());
for chunk in [&b"<!DOCTYPE html><h1>Title</h1>"[..], b"<p>Body</p>"] {
    engine.feed(chunk)?;
}
let pdf: Vec<u8> = engine.finish()?;

In Mode::Batch the PDF is written during finish. In Mode::Streaming each page is written into the sink as soon as its layout is final, during feed.

Rendering recurses as deep as the document, so run it on a thread with a large enough stack, for example through with_render_stack.

Implementations

impl<S: Sink> Engine<S>

pub fn new(options: EngineOptions, sink: S) -> Self

Create an engine that writes into sink. Nothing is read or written until the first feed.

pub fn feed(&mut self, chunk: &[u8]) -> Result<(), EngineError<S::Error>>

Feed one chunk of HTML bytes. May be called any number of times.

Under Mode::Streaming it returns an error if a <style> tag after <body> is detected once fed. Mode::Batch does no such check, merely accumulating the DOM and doing no real work until finish. Under Mode::Streaming, the top-level elements directly under <body> that have become final are processed here.

pub fn finish(self) -> Result<S::Output, EngineError<S::Error>>

Do all the remaining work and write to sink.

Under Mode::Batch everything is processed at once, after the DOM is final. Under Mode::Streaming, every top-level element not yet processed (including the last one, which was being held back) is processed, and then StreamingPdfWriter::finish writes the font embedding, xref and trailer.