use crate::dataset::*;
use crate::*;
use std::fmt;
#[derive(Debug, Default)]
pub struct Graph {
dataset: Dataset,
}
impl Graph {
pub fn new() -> Self {
Self::default()
}
fn graph(&self) -> GraphView<'_> {
self.dataset.graph(GraphNameRef::DefaultGraph)
}
fn graph_mut(&mut self) -> GraphViewMut<'_> {
self.dataset.graph_mut(GraphNameRef::DefaultGraph)
}
pub fn iter(&self) -> Iter<'_> {
Iter {
inner: self.graph().iter(),
}
}
pub fn triples_for_subject<'a, 'b>(
&'a self,
subject: impl Into<SubjectRef<'b>>,
) -> impl Iterator<Item = TripleRef<'a>> + 'a {
self.graph()
.triples_for_interned_subject(self.dataset.encoded_subject(subject))
}
pub fn objects_for_subject_predicate<'a, 'b>(
&'a self,
subject: impl Into<SubjectRef<'b>>,
predicate: impl Into<NamedNodeRef<'b>>,
) -> impl Iterator<Item = TermRef<'a>> + 'a {
self.graph().objects_for_interned_subject_predicate(
self.dataset.encoded_subject(subject),
self.dataset.encoded_named_node(predicate),
)
}
pub fn object_for_subject_predicate<'a, 'b>(
&'a self,
subject: impl Into<SubjectRef<'b>>,
predicate: impl Into<NamedNodeRef<'b>>,
) -> Option<TermRef<'a>> {
self.graph()
.objects_for_subject_predicate(subject, predicate)
.next()
}
pub fn predicates_for_subject_object<'a, 'b>(
&'a self,
subject: impl Into<SubjectRef<'b>>,
object: impl Into<TermRef<'b>>,
) -> impl Iterator<Item = NamedNodeRef<'a>> + 'a {
self.graph().predicates_for_interned_subject_object(
self.dataset.encoded_subject(subject),
self.dataset.encoded_term(object),
)
}
pub fn triples_for_predicate<'a, 'b>(
&'a self,
predicate: impl Into<NamedNodeRef<'b>>,
) -> impl Iterator<Item = TripleRef<'a>> + 'a {
self.graph()
.triples_for_interned_predicate(self.dataset.encoded_named_node(predicate))
}
pub fn subjects_for_predicate_object<'a, 'b>(
&'a self,
predicate: impl Into<NamedNodeRef<'b>>,
object: impl Into<TermRef<'b>>,
) -> impl Iterator<Item = SubjectRef<'a>> + 'a {
self.graph().subjects_for_interned_predicate_object(
self.dataset.encoded_named_node(predicate),
self.dataset.encoded_term(object),
)
}
pub fn subject_for_predicate_object<'a, 'b>(
&'a self,
predicate: impl Into<NamedNodeRef<'b>>,
object: impl Into<TermRef<'b>>,
) -> Option<SubjectRef<'a>> {
self.graph().subject_for_predicate_object(predicate, object)
}
pub fn triples_for_object<'a, 'b>(
&'a self,
object: impl Into<TermRef<'b>>,
) -> impl Iterator<Item = TripleRef<'a>> + 'a {
self.graph()
.triples_for_interned_object(self.dataset.encoded_term(object))
}
pub fn contains<'a>(&self, triple: impl Into<TripleRef<'a>>) -> bool {
self.graph().contains(triple)
}
pub fn len(&self) -> usize {
self.dataset.len()
}
pub fn is_empty(&self) -> bool {
self.dataset.is_empty()
}
pub fn insert<'a>(&mut self, triple: impl Into<TripleRef<'a>>) -> bool {
self.graph_mut().insert(triple)
}
pub fn remove<'a>(&mut self, triple: impl Into<TripleRef<'a>>) -> bool {
self.graph_mut().remove(triple)
}
pub fn clear(&mut self) {
self.dataset.clear()
}
pub fn canonicalize(&mut self) {
self.dataset.canonicalize()
}
}
impl PartialEq for Graph {
fn eq(&self, other: &Self) -> bool {
self.dataset == other.dataset
}
}
impl Eq for Graph {}
impl<'a> IntoIterator for &'a Graph {
type Item = TripleRef<'a>;
type IntoIter = Iter<'a>;
fn into_iter(self) -> Iter<'a> {
self.iter()
}
}
impl FromIterator<Triple> for Graph {
fn from_iter<I: IntoIterator<Item = Triple>>(iter: I) -> Self {
let mut g = Self::new();
g.extend(iter);
g
}
}
impl<'a, T: Into<TripleRef<'a>>> FromIterator<T> for Graph {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let mut g = Self::new();
g.extend(iter);
g
}
}
impl Extend<Triple> for Graph {
fn extend<I: IntoIterator<Item = Triple>>(&mut self, iter: I) {
self.graph_mut().extend(iter)
}
}
impl<'a, T: Into<TripleRef<'a>>> Extend<T> for Graph {
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
self.graph_mut().extend(iter)
}
}
impl fmt::Display for Graph {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.graph().fmt(f)
}
}
pub struct Iter<'a> {
inner: GraphViewIter<'a>,
}
impl<'a> Iterator for Iter<'a> {
type Item = TripleRef<'a>;
fn next(&mut self) -> Option<TripleRef<'a>> {
self.inner.next()
}
}