Struct ParseContext 

pub struct ParseContext<'doc> { /* private fields */ }

Context for parsing Eure documents.

Encapsulates the document, current node, and variant path state. Similar to DocumentConstructor for writing, but for reading.

Implementations

impl<'doc> ParseContext<'doc>

pub fn new(doc: &'doc EureDocument, node_id: NodeId) -> Self

Create a new parse context at the given node.

pub fn with_union_tag_mode( doc: &'doc EureDocument, node_id: NodeId, mode: UnionTagMode, ) -> Self

Create a new parse context with the specified union tag mode.

pub fn with_flatten_ctx( doc: &'doc EureDocument, node_id: NodeId, flatten_ctx: FlattenContext, mode: UnionTagMode, ) -> Self

Create a context with a flatten context (for flatten parsing).

When a flatten context is present:

• deny_unknown_fields() and deny_unknown_extensions() become no-ops
• All field/extension accesses are recorded in the shared FlattenContext

pub fn flatten_ctx(&self) -> Option<&FlattenContext>

Get the flatten context, if present.

pub fn is_flattened(&self) -> bool

Check if this context is flattened (has a flatten context).

When flattened, deny_unknown_fields() and deny_unknown_extensions() are no-ops.

pub fn parser_scope(&self) -> Option<ParserScope>

Get the parser scope, if in a flatten context.

Returns Some(ParserScope::Record) if from rec.flatten(), Some(ParserScope::Extension) if from ext.flatten_ext(), None if not in a flatten context.

pub fn node_id(&self) -> NodeId

Get the current node ID.

pub fn node(&self) -> &'doc Node

Get the current node.

pub fn flatten(&self) -> Self

Create a flattened version of this context for shared access tracking.

When you need both record parsing and extension parsing to share access tracking (so deny_unknown_* works correctly), use this method to create a shared context first.

Example

// Both record and extension parsers share the same AccessedSet
let ctx = ctx.flatten();
// ... parse extensions with ctx.parse_ext(...) ...
let mut rec = ctx.parse_record()?;
// ... parse fields ...
rec.deny_unknown_fields()?;  // Validates both fields and extensions

pub fn union_tag_mode(&self) -> UnionTagMode

Get the union tag mode.

pub fn parse<T: ParseDocument<'doc>>(&self) -> Result<T, T::Error>

Parse the current node as type T.

pub fn parse_with<T: DocumentParser<'doc>>( &self, parser: T, ) -> Result<T::Output, T::Error>

pub fn parse_union<T, E>( &self, repr: VariantRepr, ) -> Result<UnionParser<'doc, '_, T, E>, E>

where E: From<ParseError>,

Get a union parser for the current node with the specified variant representation.

Returns error if $variant extension has invalid type or syntax.

Arguments

• repr - The variant representation to use. Use VariantRepr::default() for Untagged.

pub fn parse_record(&self) -> Result<RecordParser<'doc>, ParseError>

Parse the current node as a record.

Returns error if variant path is not empty.

pub fn parse_tuple(&self) -> Result<TupleParser<'doc>, ParseError>

Parse the current node as a tuple.

Returns error if variant path is not empty.

pub fn parse_primitive(&self) -> Result<&'doc PrimitiveValue, ParseError>

Parse the current node as a primitive value.

Returns error if variant path is not empty.

pub fn parse_ext<T>(&self, name: &str) -> Result<T, T::Error>

where T: ParseDocument<'doc>, T::Error: From<ParseError>,

Get a required extension field.

Returns ParseErrorKind::MissingExtension if the extension is not present.

pub fn parse_ext_with<T>( &self, name: &str, parser: T, ) -> Result<T::Output, T::Error>

where T: DocumentParser<'doc>, T::Error: From<ParseError>,

Get a required extension field with a custom parser.

pub fn parse_ext_optional<T>(&self, name: &str) -> Result<Option<T>, T::Error>

where T: ParseDocument<'doc>, T::Error: From<ParseError>,

Get an optional extension field.

Returns Ok(None) if the extension is not present.

pub fn parse_ext_optional_with<T>( &self, name: &str, parser: T, ) -> Result<Option<T::Output>, T::Error>

where T: DocumentParser<'doc>, T::Error: From<ParseError>,

Get an optional extension field with a custom parser.

Returns Ok(None) if the extension is not present.

pub fn ext(&self, name: &str) -> Result<ParseContext<'doc>, ParseError>

Get the parse context for an extension field without parsing it.

Use this when you need access to the extension’s NodeId or want to defer parsing. Returns ParseErrorKind::MissingExtension if the extension is not present.

pub fn ext_optional(&self, name: &str) -> Option<ParseContext<'doc>>

Get the parse context for an optional extension field without parsing it.

Use this when you need access to the extension’s NodeId or want to defer parsing. Returns None if the extension is not present.

pub fn deny_unknown_extensions(&self) -> Result<(), ParseError>

Finish parsing with Deny policy (error if unknown extensions exist).

Flatten behavior: If this context is in a flatten chain (has flatten_ctx), this is a no-op. Only root parsers validate.

pub fn unknown_extensions( &self, ) -> impl Iterator<Item = (&'doc Identifier, ParseContext<'doc>)> + '_

Get an iterator over unknown extensions (for custom handling).

Returns (identifier, context) pairs for extensions that haven’t been accessed.

pub fn flatten_ext(&self) -> ParseContext<'doc>

Create a flatten context for child parsers in Extension scope.

This creates a FlattenContext initialized with the current accessed extensions, and returns a ParseContext that children can use. Children created from this context will:

• Add their accessed extensions to the shared FlattenContext
• Have deny_unknown_extensions() be a no-op

The root parser should call deny_unknown_extensions() after all children are done.

pub fn is_null(&self) -> bool

Check if the current node is null.

Trait Implementations

impl<'doc> Clone for ParseContext<'doc>

fn clone(&self) -> ParseContext<'doc>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'doc> Debug for ParseContext<'doc>

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

Formats the value using the given formatter.