Struct CompiledGrammar 

pub struct CompiledGrammar { /* private fields */ }

A grammar compiled against a tokenizer — the result of preprocessing performed by super::GrammarCompiler.

Cheap to clone: the inner state is shared via Arc, matching the C++ pimpl shared_ptr semantics.

Implementations

impl CompiledGrammar

pub fn from_impl(pimpl: Arc<CompiledGrammarImpl>) -> Self

Wrap an already-built CompiledGrammarImpl.

pub fn grammar(&self) -> &GrammarData

The associated optimized grammar.

pub fn grammar_arc(&self) -> Arc<GrammarData>

Shared-pointer access to the optimized grammar — used to seed a lazily-constructed MaskGenerator.

pub fn tokenizer_info(&self) -> &TokenizerInfo

The associated tokenizer info.

pub fn decomposition(&self) -> &GrammarDecomposition

The WGRAMMAR static/dynamic decomposition (Tier 3c) — the compile-time split of every rule body into fixed scaffolding spans (with precomputed literal bytes) and dynamic value-slot spans.

Computed once during compilation. A scheduler / matcher can consult it — before the first decode step — to learn the grammar’s static/dynamic structure without any per-token work. Each Segment::Static span is exactly a forced-byte run Tier 3b would otherwise rediscover lazily; the genuine WGRAMMAR delta is doing this at compile time.

pub fn get_or_compute_mask( &self, canonical: ParserState, is_root: bool, ) -> Arc<AdaptiveTokenMask>

Get the adaptive token mask for a canonical parser state, computing and caching it on first access (the XGrammar-2 JIT lazy path).

canonical MUST be the canonical cache key — rule_start_pos = -1, sub_element_id/repeat_count/partial_codepoint = 0, sequence_id = body_expr_id — exactly the tuple the eager port used. is_root is whether canonical.rule_id is the grammar root (the root rule has no uncertain tokens).

The returned Arc is byte-identical to what the old eager compile produced: same MaskGenerator, same canonical key.

pub fn memory_size_bytes(&self) -> usize

Approximate memory usage in bytes. Port of CompiledGrammar::MemorySizeBytes.

pub fn compile_top_k_masks(&self, k: usize) -> usize

OVERLAPPED MASK GENERATION (Tier 2, “configurable JIT”).

Eagerly compute the k most-expensive adaptive-token masks, populating the lazy JIT cache before the matcher needs them. Uses at most the compiler’s max_threads, including the caller, and joins all workers before returning. Metrale Engine calls this synchronously before prompt prefill; no GPU overlap is implied.

COST RANKING. A state’s mask cost is dominated by the breadth of its first-character scan: every distinct first byte the state can accept seeds an EarleyParser walk over the matching slice of the sorted vocabulary. We therefore rank reachable scanable states by their char-range edge count (a cheap, monotonic proxy for that breadth) and warm the top k.

Returns the number of masks actually computed (<= k, and <= the number of reachable scanable states). k == 0, or an empty vocabulary, computes nothing. Idempotent: a state already in the cache is recomputed cheaply via get_or_compute_mask’s fast path and still counts toward the return value.

pub fn inner(&self) -> &Arc<CompiledGrammarImpl>

Shared-pointer access to the inner state — used by the matcher.

Trait Implementations

impl Clone for CompiledGrammar

fn clone(&self) -> CompiledGrammar

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompiledGrammar

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.