Struct ConcurrentGraph 

pub struct ConcurrentGraph { /* private fields */ }

Thread-safe concurrent graph for multi-threaded access

This struct wraps the Graph in an Arc<RwLock<_>> to provide safe concurrent access across multiple threads. It implements reader-writer semantics where multiple readers can access the graph simultaneously, but only one writer can modify it at a time.

Implementations

impl ConcurrentGraph

pub fn new() -> Self

Create a new empty concurrent graph

pub fn from_graph(graph: Graph) -> Self

Create a concurrent graph from an existing graph

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

Add a triple to the graph (thread-safe)

pub fn add_triples(&self, triples: Vec<Triple>) -> usize

Add multiple triples atomically

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

Remove a triple from the graph (thread-safe)

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

Check if a triple exists in the graph (thread-safe read)

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

Query triples matching the given pattern (thread-safe read)

pub fn len(&self) -> usize

Get the number of triples (thread-safe read)

pub fn is_empty(&self) -> bool

Check if the graph is empty (thread-safe read)

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

Get all triples as a vector (thread-safe read)

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

Merge another graph into this one (thread-safe)

pub fn merge_concurrent(&self, other: &ConcurrentGraph)

Merge another concurrent graph into this one (thread-safe)

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

Create a union with another graph (thread-safe read)

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

Create an intersection with another graph (thread-safe read)

pub fn clear(&self)

Clear all triples from the graph (thread-safe)

pub fn with_read<F, R>(&self, f: F) -> R

where F: FnOnce(&Graph) -> R,

Execute a read operation with access to the underlying graph

pub fn with_write<F, R>(&self, f: F) -> R

where F: FnOnce(&mut Graph) -> R,

Execute a write operation with access to the underlying graph

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

Parallel batch insert (thread-safe)

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

Parallel batch remove (thread-safe)

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

Parallel batch query (thread-safe read)

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

Get subjects concurrently

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

Get predicates concurrently

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

Get objects concurrently

Trait Implementations

impl Clone for ConcurrentGraph

fn clone(&self) -> ConcurrentGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConcurrentGraph

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

Formats the value using the given formatter.

impl Default for ConcurrentGraph

fn default() -> Self

Returns the “default value” for a type.