Struct RDFParse 

pub struct RDFParse<RDF>
where
    RDF: FocusRDF,
{ /* private fields */ }

Execution context for RDF parsing operations.

Holds the RDF graph and provides methods to execute parsers against it. Automatically handles focus management and provides conveniences for common RDF access patterns (properties, lists, type checking).

Implementations

impl<RDF> RDFParse<RDF>

where RDF: FocusRDF,

pub fn new(rdf: RDF) -> Self

Creates a new parsing context wrapping the RDF graph.

pub fn with_focus(rdf: RDF, focus_iri: &IriS) -> Self

Creates a context and immediately sets the focus to the given IRI.

pub fn prefixmap(&self) -> Option<PrefixMap>

Returns the prefix map of the underlying graph.

pub fn current_focus(&self) -> Option<&RDF::Term>

Gets the current focus node, if set.

pub fn set_focus(&mut self, focus: &RDF::Term)

Sets the focus node to a specific term.

pub fn set_focus_iri(&mut self, iri: &IriS)

Sets the focus node from an IRI.

pub fn restore_focus(&mut self)

Restores the focus to the initial focus when the context was created.

pub fn rdf(&self) -> &RDF

Returns a reference to the underlying RDF graph.

pub fn rdf_mut(&mut self) -> &mut RDF

pub fn run<P, T>(&mut self, parser: P) -> Result<T, RDFError>

where P: RDFNodeParse<RDF, Output = T>,

Executes any parser against the current context.

This is the universal entry point - accepts any parser implementing RDFNodeParse, from simple property extractors to complex compositions.

Type Parameters

• P - The parser type
• T - The output type of the parser

pub fn run_from<P, T>( &mut self, start_node: &IriS, parser: P, ) -> Result<T, RDFError>

where P: RDFNodeParse<RDF, Output = T>,

Executes a parser starting from a specific node (ignores current focus).

Temporarily sets focus to start_node, executes the parser, then restores the previous focus.

pub fn get_property_values( &mut self, pred: IriS, ) -> Result<HashSet<RDF::Term>, RDFError>

Gets all values of a property from the current focus node.

Equivalent to ctx.run(ValuesPropertyParser::new(pred)).

pub fn get_property(&mut self, pred: IriS) -> Result<RDF::Term, RDFError>

Gets a single value of a property.

pub fn get_type(&mut self) -> Result<RDF::Term, RDFError>

Gets the rdf:type of the current focus node.

pub fn has_type(&mut self, expected: IriS) -> Result<(), RDFError>

Checks if the current focus has the given type.

pub fn parse_list(&mut self) -> Result<Vec<RDF::Term>, RDFError>

where RDF: FocusRDF,

Parses an RDF list starting at the current focus.

pub fn get_list_property( &mut self, pred: IriS, ) -> Result<Vec<RDF::Term>, RDFError>

where RDF: FocusRDF,

Parses an RDF list pointed to by a property.

pub fn find_instances_of( &mut self, type_iri: IriS, ) -> Result<Vec<RDF::Subject>, RDFError>

where RDF: FocusRDF,

Finds all instances of a given type in the entire graph.

This is a graph-wide query, not focus-dependent.

pub fn find_single_instance( &mut self, type_iri: IriS, ) -> Result<RDF::Subject, RDFError>

where RDF: FocusRDF,

Finds exactly one instance of a type (fails if not exactly one).

pub fn check<F>(&mut self, predicate: F, name: &str) -> Result<(), RDFError>

where F: Fn(&RDF::Term) -> bool,

Validates current focus against a predicate.