Struct InMemoryGraph 

pub struct InMemoryGraph { /* private fields */ }

An RDF graph stored entirely in memory.

The graph is backed by oxrdf::Graph and enriched with prefix handling, base IRI support, blank node generation, and optional SPARQL querying via an Oxigraph [Store].

Implementations

impl InMemoryGraph

pub fn new() -> Self

Creates an empty graph.

pub fn len(&self) -> usize

Returns the number of triples in the graph.

pub fn quads(&self) -> impl Iterator<Item = Quad> + '_

Returns an iterator over all triples as quads in the default graph.

pub fn is_empty(&self) -> bool

Returns true if the graph contains no triples.

pub fn merge_from_reader<R: Read>( &mut self, reader: &mut R, source_name: &str, format: &RDFFormat, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<(), InMemoryGraphError>

Merges RDF data from a reader into the current graph.

The parsing behavior depends on RDFFormat and ReaderMode. Prefixes and base IRI are merged when available.

Parameters

• reader - Input stream containing RDF data
• source_name - Name used for error reporting
• format - RDF serialization format
• base - Optional base IRI for resolving relative IRIs
• reader_mode - Controls error handling (strict or lax)

Errors

Returns an error if parsing fails in strict mode or if I/O errors occur.

pub fn merge_prefixes( &mut self, prefixmap: PrefixMap, ) -> Result<(), InMemoryGraphError>

Merges a prefix map into the graph’s prefix map.

Parameters

• prefixmap - The prefix map to merge

Errors

Returns an error if merging fails due to conflicting prefixes.

pub fn from_reader<R: Read>( read: &mut R, source_name: &str, format: &RDFFormat, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<InMemoryGraph, InMemoryGraphError>

Builds a new graph from a reader.

This is a convenience constructor that creates an empty graph and merges data from the reader.

Parameters

• read - Input stream containing RDF data
• source_name - Name used for error reporting
• format - RDF serialization format
• base - Optional base IRI for resolving relative IRIs
• reader_mode - Controls error handling (strict or lax)

Errors

Returns an error if parsing fails.

pub fn resolve(&self, str: &str) -> Result<OxNamedNode, InMemoryGraphError>

Resolves a CURIE or prefixed name into a full IRI.

Uses the graph’s prefix map to expand the prefixed form.

Parameters

• str - The CURIE or prefixed name to resolve (e.g., “ex:Alice”)

Errors

Returns an error if the prefix is not defined or if the string format is invalid.

pub fn show_blanknode(&self, bn: &OxBlankNode) -> String

Formats a blank node for display with color.

Returns a green-colored string representation.

Parameters

• bn - The blank node to format

pub fn show_literal(&self, lit: &OxLiteral) -> String

Formats a literal for display with color.

Returns a red-colored string representation.

Parameters

• lit - The literal to format

pub fn from_str( data: &str, format: &RDFFormat, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<InMemoryGraph, InMemoryGraphError>

Builds a graph from a string.

Parameters

• data - RDF data as a string
• format - RDF serialization format
• base - Optional base IRI for resolving relative IRIs
• reader_mode - Controls error handling (strict or lax)

Errors

Returns an error if parsing fails.

pub fn add_triple_ref<'a, S, P, O>( &mut self, subj: S, pred: P, obj: O, ) -> Result<(), InMemoryGraphError>

where S: Into<OxSubjectRef<'a>>, P: Into<NamedNodeRef<'a>>, O: Into<TermRef<'a>>,

Adds a triple using borrowed references.

This method avoids cloning the triple components by working with references.

Parameters

• subj - Triple subject (named node or blank node)
• pred - Triple predicate (named node)
• obj - Triple object (term)

Errors

This method currently always returns Ok(()).

impl InMemoryGraph

pub fn merge_from_path<P: AsRef<Path>>( &mut self, path: P, format: &RDFFormat, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<(), InMemoryGraphError>

Merges RDF data from a filesystem path.

Opens the file and delegates to merge_from_reader.

Parameters

• path - Path to the RDF file
• format - RDF serialization format
• base - Optional base IRI for resolving relative IRIs
• reader_mode - Controls error handling (strict or lax)

Errors

Returns an error if the file cannot be opened or if parsing fails.

pub fn from_path<P: AsRef<Path>>( path: P, format: &RDFFormat, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<InMemoryGraph, InMemoryGraphError>

Builds a graph from a filesystem path.

Creates a new empty graph and merges data from the file.

Parameters

• path - Path to the RDF file
• format - RDF serialization format
• base - Optional base IRI for resolving relative IRIs
• reader_mode - Controls error handling (strict or lax)

Errors

Returns an error if the file cannot be opened or if parsing fails.

pub fn parse_data( data: &str, format: &RDFFormat, folder: &Path, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<InMemoryGraph, InMemoryGraphError>

Parses data from a relative path within a folder.

Convenience method that joins the data file name with the folder path.

Parameters

• data - Relative file name within the folder
• format - RDF serialization format
• folder - Base directory path
• base - Optional base IRI for resolving relative IRIs
• reader_mode - Controls error handling (strict or lax)

Errors

Returns an error if the file cannot be opened or if parsing fails.

impl InMemoryGraph

pub fn prefixmap(&self) -> &PrefixMap

Returns a reference to the prefix map.

Trait Implementations

impl AsyncRDF for InMemoryGraph

fn get_predicates_subject<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 OxSubject, ) -> Pin<Box<dyn Future<Output = Result<HashSet<OxNamedNode>, InMemoryGraphError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns all predicates associated with a given subject.

Parameters

• subject - The subject node to query

Errors

This method currently always returns Ok.

fn get_objects_for_subject_predicate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, subject: &'life1 OxSubject, pred: &'life2 OxNamedNode, ) -> Pin<Box<dyn Future<Output = Result<HashSet<OxTerm>, InMemoryGraphError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Returns all objects for a given subject-predicate pair.

Parameters

• subject - The subject node
• pred - The predicate node

Errors

This method currently always returns Ok.

fn get_subjects_for_object_predicate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, object: &'life1 OxTerm, pred: &'life2 OxNamedNode, ) -> Pin<Box<dyn Future<Output = Result<HashSet<OxSubject>, InMemoryGraphError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Returns all subjects for a given object-predicate pair.

Parameters

• object - The object term
• pred - The predicate node

Errors

This method currently always returns Ok.

type IRI = NamedNode

The type representing an Internationalized Resource Identifier (IRI).

type BNode = BlankNode

The type representing an RDF blank node.

type Literal = Literal

The type representing an RDF literal value.

type Subject = NamedOrBlankNode

The type representing an RDF subject.

type Term = Term

The type representing any RDF term.

type Err = InMemoryGraphError

The error type returned by trait operations.

impl BuildRDF for InMemoryGraph

Implementation of the BuildRDF trait for constructing and modifying RDF graphs.

This implementation provides methods to build RDF graphs programmatically by adding prefixes, base IRIs, blank nodes, triples, and types. It also supports serialization to various RDF formats.

fn add_base(&mut self, base: &Option<IriS>) -> Result<(), Self::Err>

Sets the base IRI for the graph.

The base IRI is used to resolve relative IRIs during parsing and serialization.

Parameters

• base - Optional base IRI to set

fn add_prefix(&mut self, alias: &str, iri: &IriS) -> Result<(), Self::Err>

Adds a prefix mapping to the graph’s prefix map.

Prefix mappings are used to abbreviate IRIs in qualified form (CURIEs).

Parameters

• alias - The prefix alias (e.g., “ex”, “foaf”)
• iri - The full IRI that the alias represents

Errors

Returns an error if the prefix cannot be added to the prefix map.

fn add_prefix_map(&mut self, prefix_map: PrefixMap) -> Result<(), Self::Err>

Replaces the entire prefix map with a new one.

Parameters

• prefix_map - The new prefix map to use

fn add_bnode(&mut self) -> Result<Self::BNode, Self::Err>

Generates a new unique blank node.

Each call to this method increments an internal counter to ensure uniqueness.

Errors

Returns an error if the blank node counter overflows (extremely unlikely).

fn add_triple<S, P, O>( &mut self, subj: S, pred: P, obj: O, ) -> Result<(), Self::Err>

where S: Into<Self::Subject>, P: Into<Self::IRI>, O: Into<Self::Term>,

Adds a triple to the graph.

Parameters

• subj - The subject of the triple
• pred - The predicate of the triple
• obj - The object of the triple

fn remove_triple<S, P, O>( &mut self, subj: S, pred: P, obj: O, ) -> Result<(), Self::Err>

where S: Into<Self::Subject>, P: Into<Self::IRI>, O: Into<Self::Term>,

Removes a triple from the graph.

Parameters

• subj - The subject of the triple to remove
• pred - The predicate of the triple to remove
• obj - The object of the triple to remove

fn add_type<S, T>(&mut self, node: S, type_: T) -> Result<(), Self::Err>

where S: Into<Self::Subject>, T: Into<Self::Term>,

Adds an rdf:type assertion to the graph.

This is a convenience method that adds a triple with rdf:type as the predicate.

Parameters

• node - The subject that has the type
• type_ - The type (class) of the subject

fn empty() -> Self

Creates a new empty graph.

Returns

A new InMemoryGraph with no triples, prefixes, or base IRI.

fn serialize<W: Write>( &self, format: &RDFFormat, write: &mut W, ) -> Result<(), Self::Err>

Serializes the graph to a writer in the specified RDF format.

All prefixes defined in the graph’s prefix map are included in the serialization.

Parameters

• format - The RDF serialization format to use
• write - The writer to serialize to

Errors

Returns an error if serialization fails or if the writer encounters an I/O error.

impl Clone for InMemoryGraph

fn clone(&self) -> InMemoryGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InMemoryGraph

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

Formats the value using the given formatter.

impl Default for InMemoryGraph

fn default() -> InMemoryGraph

Returns the “default value” for a type.

impl FocusRDF for InMemoryGraph

Implementation of the FocusRDF trait for managing a focus term.

The focus term is used to track a specific RDF term of interest during graph operations. This can be useful for navigation, querying, or maintaining context during traversals.

fn set_focus(&mut self, focus: &Self::Term)

Sets the focus term for this graph.

Parameters

• focus - The term to set as the current focus

fn get_focus(&self) -> Option<&Self::Term>

Returns the current focus term, if one is set.

Returns

• Some(&Term) - If a focus term has been set
• None - If no focus term is currently set

fn get_focus_as_term(&self) -> Result<&Self::Term, RDFError>

Retrieves the current focus node as a term, failing if no focus is set.

fn get_focus_as_subject(&self) -> Result<Self::Subject, RDFError>

Retrieves the current focus node as a subject, failing if not set or not a valid subject.

fn get_path_for( &mut self, subject: &Self::Term, predicate: &Self::IRI, ) -> Result<Option<SHACLPath>, RDFError>

Parses and retrieves a SHACL path from a subject-predicate pair.

impl NeighsRDF for InMemoryGraph

Implementation of the NeighsRDF trait for navigating graph neighbors.

This implementation provides methods to iterate over triples in the graph, optionally filtered by subject, predicate, or object patterns.

fn triples(&self) -> Result<impl Iterator<Item = Self::Triple>, Self::Err>

Returns an iterator over all triples in the graph.

Returns

An iterator that yields owned triples.

fn triples_matching<S, P, O>( &self, subject: &S, predicate: &P, object: &O, ) -> Result<impl Iterator<Item = Self::Triple> + '_, Self::Err>

where S: Matcher<Self::Subject>, P: Matcher<Self::IRI>, O: Matcher<Self::Term>,

Returns an iterator over triples matching a pattern.

Uses the appropriate oxrdf index based on which positions are concrete vs wildcard, giving O(k) complexity instead of a full O(n) table scan.

Parameters

• subject - Pattern matcher for the subject
• predicate - Pattern matcher for the predicate
• object - Pattern matcher for the object

Returns

An iterator that yields triples matching all three patterns.

fn contains<S, P, O>( &self, subject: &S, predicate: &P, object: &O, ) -> Result<bool, Self::Err>

where S: Matcher<Self::Subject>, P: Matcher<Self::IRI>, O: Matcher<Self::Term>,

Checks whether the graph contains at least one triple matching the pattern.

fn triples_with_subject( &self, subject: &Self::Subject, ) -> Result<impl Iterator<Item = Self::Triple> + '_, Self::Err>

Returns all triples with the specified subject.

fn triples_with_subject_predicate( &self, subject: &Self::Subject, predicate: &Self::IRI, ) -> Result<impl Iterator<Item = Self::Triple> + '_, Self::Err>

Returns all triples with the specified subject and predicate.

fn triples_with_predicate( &self, predicate: &Self::IRI, ) -> Result<impl Iterator<Item = Self::Triple> + '_, Self::Err>

Returns all triples with the specified predicate.

fn triples_with_predicate_object( &self, predicate: &Self::IRI, object: &Self::Term, ) -> Result<impl Iterator<Item = Self::Triple> + '_, Self::Err>

Returns all triples with the specified predicate and object.

fn triples_with_object( &self, object: &Self::Term, ) -> Result<impl Iterator<Item = Self::Triple> + '_, Self::Err>

Returns all triples with the specified object.

fn incoming_arcs( &self, object: &Self::Term, ) -> Result<HashMap<<Self as Rdf>::IRI, HashSet<<Self as Rdf>::Subject>>, Self::Err>

Returns all incoming arcs (predicates and subjects) pointing to an object.

fn outgoing_arcs( &self, subject: &Self::Subject, ) -> Result<HashMap<<Self as Rdf>::IRI, HashSet<<Self as Rdf>::Term>>, Self::Err>

Returns all outgoing arcs (predicates and objects) from a subject.

fn outgoing_arcs_from_list( &self, subject: &Self::Subject, preds: &[Self::IRI], ) -> Result<(HashMap<<Self as Rdf>::IRI, HashSet<<Self as Rdf>::Term>>, Vec<<Self as Rdf>::IRI>), Self::Err>

Returns filtered outgoing arcs and remainder predicates.

fn shacl_instances_of<O>( &self, cls: &O, ) -> Result<impl Iterator<Item = Self::Subject>, Self::Err>

where O: Matcher<Self::Term>,

Returns all subjects that are instances of the specified class.

fn reifiers_of_triple( &self, triple: &Self::Triple, ) -> Result<impl Iterator<Item = Self::Subject>, Self::Err>

Returns all subjects that reify the specified triple.

fn object_for( &self, subject: &Self::Term, predicate: &Self::IRI, ) -> Result<Option<Object>, RDFError>

Returns the first object for the given subject-predicate pair.

fn objects_for_shacl_path( &self, subject: &Self::Term, path: &SHACLPath, ) -> Result<HashSet<Self::Term>, RDFError>

Returns all objects reachable by following a SHACL property path.

fn objects_for( &self, subject: &Self::Term, predicate: &Self::IRI, ) -> Result<HashSet<Self::Term>, RDFError>

Returns all objects for the given subject-predicate pair.

fn subjects_for( &self, predicate: &Self::IRI, object: &Self::Term, ) -> Result<HashSet<Self::Term>, RDFError>

Returns all subjects for the given predicate-object pair.

impl Rdf for InMemoryGraph

Implementation of the core Rdf trait.

This implementation provides the fundamental RDF operations including type definitions, prefix resolution, and term qualification (converting full IRIs to prefixed names).

fn resolve_prefix_local( &self, prefix: &str, local: &str, ) -> Result<IriS, PrefixMapError>

Resolves a prefix and local name to a full IRI.

Parameters

• prefix - The namespace prefix (e.g., “foaf”)
• local - The local name (e.g., “Person”)

Returns

The full IRI (e.g., “http://xmlns.com/foaf/0.1/Person”)

Errors

Returns an error if the prefix is not defined in the prefix map.

fn qualify_iri(&self, node: &Self::IRI) -> String

Converts a full IRI to a qualified (prefixed) name if possible.

If the IRI matches a known namespace prefix, it returns a shortened form (e.g., “foaf:Person”). Otherwise, it returns the full IRI.

Parameters

• node - The named node to qualify

Returns

A string representation, either prefixed or full IRI.

fn qualify_subject(&self, subj: &OxSubject) -> String

Converts a subject (named node or blank node) to a qualified string.

Named nodes are qualified using the prefix map. Blank nodes are formatted with color for display.

Parameters

• subj - The subject to qualify

Returns

A string representation of the subject.

fn qualify_term(&self, term: &OxTerm) -> String

Converts an RDF term (named node, blank node, or literal) to a qualified string.

Different term types are formatted differently:

• Named nodes: qualified using prefix map
• Blank nodes: formatted with green color
• Literals: formatted with red color
• RDF-star triples: not yet supported

Parameters

• term - The term to qualify

Returns

A string representation of the term.

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

Returns a reference to the graph’s prefix map.

Returns

Some(&PrefixMap) containing all defined namespace prefixes.

type IRI = NamedNode

The IRI type for this RDF implementation.

type BNode = BlankNode

The blank node type for this RDF implementation.

type Literal = Literal

The literal type for representing data values.

type Subject = NamedOrBlankNode

The subject type for this RDF implementation.

type Term = Term

The term type representing any RDF component.

type Triple = Triple

The triple type representing RDF statements.

type Err = InMemoryGraphError

The error type for fallible operations.

fn numeric_value(&self, term: &Self::Term) -> Option<Decimal>

Extracts the numeric value from a term, if it represents a number.

fn term_as_literal(term: &Self::Term) -> Result<Self::Literal, RDFError>

Converts a term to a literal.

fn term_as_sliteral(term: &Self::Term) -> Result<ConcreteLiteral, RDFError>

Attempts to convert a term into a concrete literal.

fn term_as_subject(term: &Self::Term) -> Result<Self::Subject, RDFError>

Converts a term to a subject.

fn subject_as_term(subj: &Self::Subject) -> Self::Term

Converts a subject to a term.

fn triple_as_term(triple: &Self::Triple) -> Self::Term

Converts a triple to a term (RDF-star support).

fn iris_as_term(iri: &IriS) -> Self::Term

Converts an IriS to a term.

fn term_as_iri(term: &Self::Term) -> Result<Self::IRI, RDFError>

Converts a term to an IRI.

fn iri_or_bnode_as_term(ib: &IriOrBlankNode) -> Self::Term

Converts an IRI or blank node to a term.

fn term_as_bnode(term: &Self::Term) -> Result<Self::BNode, RDFError>

Converts a term to a blank node.

fn term_as_iris(term: &Self::Term) -> Result<IriS, RDFError>

Converts a term to an IriS.

fn term_as_object(term: &Self::Term) -> Result<Object, RDFError>

Converts a term to an Object.

fn object_as_term(object: &Object) -> Self::Term

Converts an Object to a term.

fn subject_as_node(subject: &Self::Subject) -> Result<Object, RDFError>

Converts a subject to an Object.

fn term_as_lang(term: &Self::Term) -> Result<Lang, RDFError>

Extracts a language tag from a term.

fn compare( &self, term1: &Self::Term, term2: &Self::Term, ) -> Result<Ordering, RDFError>

Compares two terms according to SPARQL ordering semantics.

fn equals(&self, term1: &Self::Term, term2: &Self::Term) -> bool

Checks if two terms are equal according to SPARQL semantics.

impl Serialize for InMemoryGraph

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.