Struct BorrowedAllocator 

pub struct BorrowedAllocator<'a> {
    arena: &'a Arena,
    interner: Interner<'a>,
}

Arena-backed builder for borrowed::AozoraNode<'a> and its payload types.

Owns an Interner keyed off the supplied Arena; both string content and per-variant payloads land in the arena, so dropping the arena tears the entire AST down in one step (no per-node Drop runs, no Box::drop traffic).

Fields

arena: &'a Arena

interner: Interner<'a>

Implementations

impl<'a> BorrowedAllocator<'a>

pub fn with_capacity(arena: &'a Arena, interner_capacity: usize) -> Self

New allocator with a fresh interner sized to interner_capacity. Capacity is rounded up to the next power of two by the interner.

pub fn new(arena: &'a Arena) -> Self

Construct with the interner’s default initial capacity (64 → 64 after power-of-two rounding).

pub fn arena(&self) -> &'a Arena

Borrow the underlying arena. Useful for callers that need to emit an arena-allocated normalised text alongside the AST.

pub fn into_interner(self) -> Interner<'a>

Finish allocation and return the interner so the caller can inspect its dedup counters (cache hits, table hits, allocs, average probe length). The interner’s &'a arena reference continues to keep the interned strings alive.

pub fn content_plain(&mut self, s: &str) -> Content<'a>

Build a plain-text body content. Empty input canonicalises to Segments(&[]) (the legacy owned shape did the same).

pub fn content_segments(&mut self, segs: &[Segment<'a>]) -> Content<'a>

Build a body content from a sequence of segments. Empty input → Segments(&[]); all-Text input collapses into a single concatenated Plain (interned).

pub fn seg_text(&mut self, s: &str) -> Segment<'a>

Segment::Text(s) — interns the string.

pub fn seg_gaiji(&self, g: &'a Gaiji<'a>) -> Segment<'a>

Segment::Gaiji(g) — wraps a payload built via Self::make_gaiji.

pub fn seg_annotation(&self, a: &'a Annotation<'a>) -> Segment<'a>

Segment::Annotation(a) — wraps a payload built via Self::make_annotation.

pub fn make_gaiji( &mut self, description: &str, ucs: Option<Resolved>, mencode: Option<&str>, ) -> &'a Gaiji<'a>

Build a Gaiji payload. Use Self::seg_gaiji to wrap as a segment, or Self::gaiji to wrap as a node.

pub fn make_annotation( &mut self, raw: &str, kind: AnnotationKind, ) -> &'a Annotation<'a>

Build an Annotation payload. Use Self::seg_annotation to wrap as a segment, or Self::annotation to wrap as a node.

raw carries the borrowed::NonEmptyStr invariant.

Panics

Panics if raw is empty. Phase 3 emits annotation only after at least one byte landed in the bracket body.

pub fn ruby( &self, base: Content<'a>, reading: Content<'a>, delim_explicit: bool, ) -> AozoraNode<'a>

AozoraNode::Ruby(Ruby { base, reading, delim_explicit }).

base and reading carry the borrowed::NonEmpty invariant. Phase 3 only emits Ruby once both are non-empty, so this expect is a contract-check; an empty payload here signals a classifier bug.

Panics

Panics if base or reading is empty. Phase 3 emit-sites classify only after the body is populated, so the panic represents a pipeline-internal bug — the borrowed::NonEmpty payload encodes this invariant at the type level.

pub fn bouten( &self, kind: BoutenKind, target: Content<'a>, position: BoutenPosition, ) -> AozoraNode<'a>

AozoraNode::Bouten(Bouten { kind, target, position }).

target carries the borrowed::NonEmpty invariant — Phase 3 resolves the forward reference before emitting.

Panics

Panics if target is empty. The forward-reference resolver in Phase 3 always lands a non-empty target before emit; an empty payload here signals a classifier bug.

pub fn tate_chu_yoko(&self, text: Content<'a>) -> AozoraNode<'a>

AozoraNode::TateChuYoko(TateChuYoko { text }).

text carries the borrowed::NonEmpty invariant.

Panics

Panics if text is empty.

pub fn gaiji(&self, g: &'a Gaiji<'a>) -> AozoraNode<'a>

AozoraNode::Gaiji(g).

pub fn indent(&self, i: Indent) -> AozoraNode<'a>

AozoraNode::Indent(i).

pub fn align_end(&self, a: AlignEnd) -> AozoraNode<'a>

AozoraNode::AlignEnd(a).

pub fn warichu(&self, upper: Content<'a>, lower: Content<'a>) -> AozoraNode<'a>

AozoraNode::Warichu(Warichu { upper, lower }).

pub fn keigakomi(&self, k: Keigakomi) -> AozoraNode<'a>

AozoraNode::Keigakomi(k).

pub fn page_break(&self) -> AozoraNode<'a>

AozoraNode::PageBreak.

pub fn section_break(&self, k: SectionKind) -> AozoraNode<'a>

AozoraNode::SectionBreak(k).

pub fn aozora_heading( &self, kind: AozoraHeadingKind, text: Content<'a>, ) -> AozoraNode<'a>

AozoraNode::AozoraHeading(AozoraHeading { kind, text }).

text carries the borrowed::NonEmpty invariant.

Panics

Panics if text is empty.

pub fn heading_hint(&mut self, level: u8, target: &str) -> AozoraNode<'a>

AozoraNode::HeadingHint(HeadingHint { level, target }).

target carries the borrowed::NonEmptyStr invariant.

Panics

Panics if target is empty. Phase 3 emits the hint only after the forward-reference target lands non-empty; an empty payload here signals a classifier bug.

pub fn sashie( &mut self, file: &str, caption: Option<Content<'a>>, ) -> AozoraNode<'a>

AozoraNode::Sashie(Sashie { file, caption }).

file carries the borrowed::NonEmptyStr invariant.

Panics

Panics if file is empty.

pub fn kaeriten(&mut self, mark: &str) -> AozoraNode<'a>

AozoraNode::Kaeriten(Kaeriten { mark }).

mark carries the borrowed::NonEmptyStr invariant.

Panics

Panics if mark is empty.

pub fn annotation(&self, a: &'a Annotation<'a>) -> AozoraNode<'a>

AozoraNode::Annotation(a).

pub fn double_ruby(&self, content: Content<'a>) -> AozoraNode<'a>

AozoraNode::DoubleRuby(DoubleRuby { content }).

content carries the borrowed::NonEmpty invariant — Phase 3 pre-filters 《《》》 with empty body into plain text so this path is never reached with an empty payload.

Panics

Panics if content is empty. Phase 3’s pre-filter is the gate; an empty payload here signals a classifier bug.

pub fn container(&self, c: Container) -> AozoraNode<'a>

AozoraNode::Container(c).

Trait Implementations

impl<'a> Debug for BorrowedAllocator<'a>

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

Formats the value using the given formatter.