Struct Graph 

pub struct Graph { /* private fields */ }

An in-memory RDF Graph

A graph is a set of RDF triples representing a collection of statements. This implementation uses a HashSet for efficient insertion, removal, and lookup operations with O(1) average-case performance.

Examples

use oxirs_core::model::{Graph, Triple, NamedNode, Literal};

// Create a new empty graph
let mut graph = Graph::new();

// Create some triples
let triple1 = Triple::new(
    NamedNode::new("http://example.org/alice").expect("valid IRI"),
    NamedNode::new("http://example.org/name").expect("valid IRI"),
    Literal::new("Alice"),
);

let triple2 = Triple::new(
    NamedNode::new("http://example.org/alice").expect("valid IRI"),
    NamedNode::new("http://example.org/age").expect("valid IRI"),
    Literal::new("30"),
);

// Insert triples into the graph
graph.insert(triple1.clone());
graph.insert(triple2);

// Check if graph contains a triple
assert_eq!(graph.len(), 2);
assert!(graph.contains(&triple1));

Performance Characteristics

• Insertion: O(1) average case
• Removal: O(1) average case
• Lookup: O(1) average case
• Memory: Each triple stored once (set semantics)

Implementations

impl Graph

pub fn new() -> Self

Creates a new empty graph

Examples

use oxirs_core::model::Graph;

let graph = Graph::new();
assert_eq!(graph.len(), 0);
assert!(graph.is_empty());

pub fn with_capacity(capacity: usize) -> Self

Creates a new graph with the specified initial capacity

This can improve performance when you know approximately how many triples the graph will contain, as it avoids unnecessary reallocations.

Arguments

• capacity - The initial capacity for the underlying hash set

Examples

use oxirs_core::model::Graph;

// Create a graph optimized for ~1000 triples
let graph = Graph::with_capacity(1000);
assert_eq!(graph.len(), 0);

pub fn from_triples(triples: Vec<Triple>) -> Self

Creates a graph from a vector of triples

Duplicates are automatically removed as graphs maintain set semantics.

Arguments

• triples - A vector of triples to insert into the graph

Examples

use oxirs_core::model::{Graph, Triple, NamedNode, Literal};

let triples = vec![
    Triple::new(
        NamedNode::new("http://example.org/alice").expect("valid IRI"),
        NamedNode::new("http://example.org/name").expect("valid IRI"),
        Literal::new("Alice"),
    ),
    Triple::new(
        NamedNode::new("http://example.org/bob").expect("valid IRI"),
        NamedNode::new("http://example.org/name").expect("valid IRI"),
        Literal::new("Bob"),
    ),
];

let graph = Graph::from_triples(triples);
assert_eq!(graph.len(), 2);

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

Inserts a triple into the graph

Returns true if the triple was not already present, false otherwise.

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

Removes a triple from the graph

Returns true if the triple was present, false otherwise.

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

Returns true if the graph contains the specified triple

pub fn len(&self) -> usize

Returns the number of triples in the graph

pub fn is_empty(&self) -> bool

Returns true if the graph contains no triples

pub fn clear(&mut self)

Clears the graph, removing all triples

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

Returns an iterator over all triples in the graph

pub fn iter_ref(&self) -> impl Iterator<Item = TripleRef<'_>>

Returns an iterator over all triples in the graph as references

pub fn triples_for_pattern<'a>( &'a self, subject: Option<&'a Subject>, predicate: Option<&'a Predicate>, object: Option<&'a Object>, ) -> impl Iterator<Item = &'a Triple>

Finds all triples matching the given pattern

None values in the pattern act as wildcards.

pub fn triples_for_subject<'a>( &'a self, subject: &'a Subject, ) -> impl Iterator<Item = &'a Triple>

Finds all triples with the given subject

pub fn triples_for_predicate<'a>( &'a self, predicate: &'a Predicate, ) -> impl Iterator<Item = &'a Triple>

Finds all triples with the given predicate

pub fn triples_for_object<'a>( &'a self, object: &'a Object, ) -> impl Iterator<Item = &'a Triple>

Finds all triples with the given object

pub fn triples_for_subject_predicate<'a>( &'a self, subject: &'a Subject, predicate: &'a Predicate, ) -> impl Iterator<Item = &'a Triple>

Finds all triples with the given subject and predicate

pub fn extend<I>(&mut self, triples: I)

where I: IntoIterator<Item = Triple>,

Extends the graph with triples from an iterator

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&Triple) -> bool,

Retains only the triples specified by the predicate

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

Creates the union of this graph with another graph

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

Creates the intersection of this graph with another graph

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

Creates the difference of this graph with another graph

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

Returns true if this graph is a subset of another graph

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

Returns true if this graph is a superset of another graph

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

Returns true if this graph is disjoint from another graph

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<T: IntoIterator<Item = Triple>>(&mut self, iter: T)

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<T: IntoIterator<Item = Triple>>(iter: T) -> 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 = Iter<'a, Triple>

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