Struct Document 

pub struct Document<'src> { /* private fields */ }

A document represents the top-level block element in AsciiDoc. It consists of an optional document header and either a) one or more sections preceded by an optional preamble or b) a sequence of top-level blocks only.

The document can be configured using a document header. The header is not a block itself, but contributes metadata to the document, such as the document title and document attributes.

The Document structure is a self-contained package of the original content that was parsed and the data structures that describe that parsed content. The API functions on this struct can be used to understand the parse results.

Implementations

impl<'src> Document<'src>

pub fn header(&self) -> &Header<'_>

Return the document header.

pub fn doctitle(&self) -> Option<&str>

Return the document title (the level-0 = Title), if there was one.

pub fn show_doctitle(&self) -> bool

Return whether the document title should be displayed (as an <h1>).

This reflects the effective showtitle/notitle attribute state: an embedded document shows its title only when showtitle is set.

pub fn toc_mode(&self) -> TocMode

Return where (and whether) this document’s table of contents is generated, resolved from the toc attribute.

pub fn toc_levels(&self) -> usize

Return the depth of section levels included in this document’s table of contents, resolved from the toclevels attribute (default 2).

pub fn toc_title(&self) -> &str

Return the title of this document’s table of contents, resolved from the toc-title attribute (default Table of Contents).

pub fn toc_class(&self) -> &str

Return the CSS class applied to this document’s table of contents container, resolved from the toc-class attribute (default toc).

pub fn warnings(&self) -> Iter<'_, Warning<'_>>

Return an iterator over any warnings found during parsing.

pub fn span(&self) -> Span<'_>

Return a Span describing the entire document source.

pub fn source_map(&self) -> &SourceMap

Return the source map that tracks original file locations.

pub fn catalog(&self) -> &Catalog

Return the document catalog for accessing referenceable elements.

pub fn resolve_references( &mut self, resolver: &dyn ReferenceResolver, renderer: &dyn InlineSubstitutionRenderer, ) -> Vec<ReferenceWarning>

Resolve the document’s deferred cross-references using a caller-supplied ReferenceResolver and InlineSubstitutionRenderer.

This is the entry point for multi-document workflows: parse each document with Parser::parse_deferred, then call this with a resolver that resolves targets against whatever combined index the caller has built (this crate does not merge catalogs). The resolver binds the “from” document, so a single shared resolver can be parametrized per call site.

Resolution is non-destructive and may be repeated (e.g. for incremental builds or multiple output targets): the original target text is retained, so re-resolving is always possible.

Each call is a full, independent resolution sweep. Every cross-reference is re-resolved against resolver, overwriting any result from a previous pass, and the returned ReferenceWarnings reflect only what this resolver could not resolve — a prior pass having resolved a target does not suppress a warning here. Consequently, resolving with a resolver that knows fewer targets than an earlier pass (for example, calling this after Parser::parse has already auto-resolved against the document’s own catalog) will re-report those now-unknown targets as unresolved. Multi-document pipelines should therefore start from Parser::parse_deferred, which does not auto-resolve.

Trait Implementations

impl Debug for Document<'_>

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

Formats the value using the given formatter.

impl<'src> Eq for Document<'src>

impl<'src> IsBlock<'src> for Document<'src>

fn content_model(&self) -> ContentModel

Returns the ContentModel for this block.

fn raw_context(&self) -> CowStr<'src>

Returns the raw (uninterpreted) context for this block.

fn nested_blocks(&'src self) -> Iter<'src, Block<'src>>

Returns an iterator over the nested blocks contained within this block.

fn title_source(&'src self) -> Option<Span<'src>>

Returns the source text for the title for this block, if present.

fn title(&self) -> Option<&str>

Returns the rendered title for this block, if present.

fn anchor(&'src self) -> Option<Span<'src>>

Returns the anchor for this block, if present.

fn anchor_reftext(&'src self) -> Option<Span<'src>>

Returns the reference text for this block’s anchor, if present.

fn attrlist(&'src self) -> Option<&'src Attrlist<'src>>

Returns the attribute list for this block, if present.

fn rendered_content(&'src self) -> Option<&'src str>

Returns the rendered content for this block, if any.

fn resolved_context(&'src self) -> CowStr<'src>

Returns the resolved context for this block.

fn declared_style(&'src self) -> Option<&'src str>

Returns the declared (uninterpreted) style for this block.

fn nested_blocks_mut(&mut self) -> &mut [Block<'src>]

Returns a mutable slice of the nested blocks contained within this block.

fn content_mut(&mut self) -> Option<&mut Content<'src>>

Returns a mutable reference to this block’s own resolvable content — its body, section title, or description-list term — if any.

fn id(&'src self) -> Option<&'src str>

Returns the ID for this block, if present.

fn roles(&'src self) -> Vec<&'src str>

Returns any role attributes that were found.

fn options(&'src self) -> Vec<&'src str>

Returns any option attributes that were found.

fn has_option<N: AsRef<str>>(&'src self, name: N) -> bool

Returns true if this block has the named option.

fn caption(&self) -> Option<&str>

Returns the caption prefix for this block, if it has one.

fn number(&self) -> Option<usize>

Returns the automatically assigned number for this block, if it has one.

fn substitution_group(&'src self) -> SubstitutionGroup

Returns the default substitution group that is applied unless you customize the substitutions for a particular element.

impl<'src> PartialEq for Document<'src>

fn eq(&self, other: &Document<'src>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'src> StructuralPartialEq for Document<'src>