Struct Graph 

pub struct Graph { /* private fields */ }

RDF graph representation

A graph is a collection of RDF triples. This implementation uses a BTreeSet for efficient storage and retrieval.

Implementations

impl Graph

pub fn new() -> Self

Create a new empty graph

pub fn from_triples<I>(triples: I) -> Self

where I: IntoIterator<Item = Triple>,

Create a graph from an iterator of triples

pub fn add_triple(&mut self, triple: Triple) -> bool

Add a triple to the graph

pub fn add_triple_str( &mut self, subject: &str, predicate: &str, object: &str, ) -> Result<bool>

Add a triple to the graph using string components

pub fn remove_triple(&mut self, triple: &Triple) -> bool

Remove a triple from the graph

pub fn contains_triple(&self, triple: &Triple) -> bool

Check if a triple exists in the graph

pub fn query_triples( &self, subject: Option<&Subject>, predicate: Option<&Predicate>, object: Option<&Object>, ) -> Vec<Triple>

Query triples matching the given pattern

None values act as wildcards matching any term.

pub fn triples(&self) -> Vec<Triple>

Get all triples as a vector

pub fn iter_triples(&self) -> impl Iterator<Item = &Triple>

Iterate over all triples

pub fn insert(&mut self, triple: Triple) -> bool

Alias for add_triple for compatibility

pub fn iter(&self) -> impl Iterator<Item = &Triple>

Iterate over all triples (alias for iter_triples)

pub fn contains(&self, triple: &Triple) -> bool

Check if a triple exists in the graph (alias for contains_triple)

pub fn subjects(&self) -> BTreeSet<Subject>

Get all subjects in the graph

pub fn predicates(&self) -> BTreeSet<Predicate>

Get all predicates in the graph

pub fn objects(&self) -> BTreeSet<Object>

Get all objects in the graph

pub fn merge(&mut self, other: &Graph)

Merge another graph into this one

pub fn union(&self, other: &Graph) -> Graph

Create a new graph containing the union of this graph and another

pub fn intersection(&self, other: &Graph) -> Graph

Create a new graph containing the intersection of this graph and another

pub fn difference(&self, other: &Graph) -> Graph

Create a new graph containing triples in this graph but not in the other

pub fn clear(&mut self)

Clear all triples from the graph

pub fn len(&self) -> usize

Get the number of triples in the graph

pub fn is_empty(&self) -> bool

Check if the graph is empty

pub fn is_isomorphic_to(&self, other: &Graph) -> bool

Check if the graph is isomorphic to another graph

This is a simplified check that doesn’t handle blank node isomorphism properly. For proper blank node isomorphism, a more sophisticated algorithm would be needed.

pub fn par_insert_batch(&mut self, triples: Vec<Triple>) -> Result<usize>

Insert triples in parallel batches

This method uses parallel processing to insert a large collection of triples efficiently. It automatically batches the triples and processes them across multiple CPU cores.

pub fn par_remove_batch(&mut self, triples: Vec<Triple>) -> Result<usize>

Remove triples in parallel batches

This method uses parallel processing to remove a large collection of triples efficiently. It automatically batches the triples and processes them across multiple CPU cores.

pub fn par_query_batch( &self, queries: Vec<(Option<Subject>, Option<Predicate>, Option<Object>)>, ) -> Result<Vec<Vec<Triple>>>

Query triples in parallel batches

This method performs multiple queries in parallel, returning all matching triples. Each query pattern is processed concurrently for improved performance.

pub fn par_transform<F>(&mut self, transform_fn: F) -> Result<(usize, usize)>

where F: Fn(&Triple) -> Option<Triple> + Send + Sync + 'static,

Apply a transformation function to all triples in parallel

This method applies a transformation function to each triple in the graph in parallel. The function can return None to remove a triple or Some(triple) to replace it.

pub fn par_iter(&self) -> impl ParallelIterator<Item = &Triple>

Create a parallel iterator over the graph’s triples

This allows for parallel processing of triples using rayon’s parallel iterator traits.

pub fn par_count_patterns( &self, patterns: Vec<(Option<Subject>, Option<Predicate>, Option<Object>)>, ) -> Vec<usize>

Count triples matching patterns in parallel

This method counts the number of triples matching each pattern in parallel.

pub fn par_unique_terms( &self, ) -> (BTreeSet<Subject>, BTreeSet<Predicate>, BTreeSet<Object>)

Find unique values for a given position in parallel

This method finds all unique subjects, predicates, or objects in parallel.

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.

impl Default for Graph

fn default() -> Self

Returns the “default value” for a type.

impl Extend<Triple> for Graph

fn extend<I: IntoIterator<Item = Triple>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<Triple> for Graph

fn from_iter<I: IntoIterator<Item = Triple>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> IntoIterator for &'a Graph

type Item = &'a Triple

The type of the elements being iterated over.

type IntoIter = GraphIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Graph

type Item = Triple

The type of the elements being iterated over.

type IntoIter = IntoIter<Triple>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Graph

fn eq(&self, other: &Graph) -> 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 Eq for Graph

impl StructuralPartialEq for Graph