asciidork-parser 0.34.0

Asciidork parser
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::fmt::{Debug, Formatter};

use crate::internal::*;

pub struct ParseResult<'arena> {
  pub document: Document<'arena>,
  pub warnings: Vec<Diagnostic>,
  pub(crate) attr_defs: BumpVec<'arena, AttrDef>,
  pub include_resolver: Option<Box<dyn IncludeResolver>>,
  #[cfg(feature = "attr_ref_observation")]
  pub attr_ref_observer: Option<Box<dyn AttrRefObserver>>,
  lexer: Lexer<'arena>,
}

impl ParseResult<'_> {
  pub fn line_number_with_offset(&self, loc: SourceLocation) -> (u32, u32) {
    self.lexer.line_number_with_offset(loc)
  }

  pub fn source_file_at(&self, idx: u16) -> &SourceFile {
    self.lexer.source_file_at(idx)
  }

  pub fn take_include_resolver_as<T: 'static>(&mut self) -> Option<T> {
    let resolver = self.include_resolver.take()?;
    let any_resolver = resolver as Box<dyn std::any::Any>;
    Some(*any_resolver.downcast::<T>().unwrap())
  }

  #[cfg(feature = "attr_ref_observation")]
  pub fn take_attr_ref_observer_as<T: 'static>(&mut self) -> Option<T> {
    let observer = self.attr_ref_observer.take()?;
    let any_observer = observer as Box<dyn std::any::Any>;
    Some(*any_observer.downcast::<T>().unwrap())
  }
}

impl<'arena> From<Parser<'arena>> for ParseResult<'arena> {
  fn from(parser: Parser<'arena>) -> Self {
    ParseResult {
      document: parser.document,
      warnings: parser.errors.into_inner(),
      attr_defs: parser.ctx.attr_defs,
      include_resolver: parser.include_resolver,
      #[cfg(feature = "attr_ref_observation")]
      attr_ref_observer: parser.attr_ref_observer,
      lexer: parser.lexer,
    }
  }
}

impl Debug for ParseResult<'_> {
  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
    f.debug_struct("ParseResult")
      .field("document", &self.document)
      .field("warnings", &self.warnings)
      .finish()
  }
}