Struct grdf::btree_dataset::BTreeGraph

pub struct BTreeGraph<S = Term, P = S, O = S> { /* private fields */ }

Graph implementation based on BTreeMap and BTreeSet.

Implementations

impl<S, P, O> BTreeGraph<S, P, O>

pub fn new() -> Self

Create a new empty BTreeGraph.

impl<S: Ord, P: Ord, O: Ord> BTreeGraph<S, P, O>

pub fn from_graph<G: SizedGraph<Subject = S, Predicate = P, Object = O>>(
    g: G
) -> BTreeGraph<S, P, O>

Create a new BTreeGraph from another graph by consuming its triples.

pub fn insert(&mut self, triple: Triple<S, P, O>)

pub fn absorb<G: SizedGraph<Subject = S, Predicate = P, Object = O>>(
    &mut self,
    other: G
)

impl<S, P, O> BTreeGraph<S, P, O>

pub fn triples(&self) -> Iter<'_, S, P, O>

pub fn subjects(&self) -> Subjects<'_, S, P, O>

pub fn predicates(&self, subject: &S) -> Predicates<'_, P, O> where
    S: Ord, 

pub fn objects(&self, subject: &S, predicate: &P) -> Objects<'_, O> where
    S: Ord,
    P: Ord, 

pub fn contains(&self, Triple: Triple<&S, &P, &O>) -> bool where
    S: Ord,
    P: Ord,
    O: Ord, 

pub fn into_triples(self) -> IntoIter<S, P, O>

pub fn into_subjects(self) -> IntoSubjects<S, P, O>

pub fn into_predicates(self, subject: &S) -> IntoPredicates<P, O> where
    S: Ord, 

pub fn into_objects(self, subject: &S, predicate: &P) -> IntoObjects<O> where
    S: Ord,
    P: Ord, 

Trait Implementations

impl<S: Debug, P: Debug, O: Debug> Debug for BTreeGraph<S, P, O>

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

Formats the value using the given formatter.

impl<S, P, O> Default for BTreeGraph<S, P, O>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Ord, P: Ord, O: Ord> Extend<Triple<S, P, O>> for BTreeGraph<S, P, O>

fn extend<I: IntoIterator<Item = Triple<S, P, O>>>(&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<S: Ord, P: Ord, O: Ord> FromIterator<Triple<S, P, O>> for BTreeGraph<S, P, O>

fn from_iter<I: IntoIterator<Item = Triple<S, P, O>>>(iter: I) -> Self

Creates a value from an iterator.

impl<S: Ord, P: Ord, O: Ord> Graph for BTreeGraph<S, P, O>

type Subject = S

type Predicate = P

type Object = O

type Objects<'a>
where
    Self: 'a,
    O: 'a = Objects<'a, O>

Objects iterator.

type Predicates<'a>
where
    Self: 'a,
    P: 'a,
    O: 'a = Predicates<'a, P, O>

Subject predicates iterator.

type Subjects<'a>
where
    Self: 'a,
    S: 'a,
    P: 'a,
    O: 'a = Subjects<'a, S, P, O>

Graph subjects iterator.

type Triples<'a>
where
    Self: 'a,
    S: 'a,
    P: 'a,
    O: 'a = Iter<'a, S, P, O>

Triple iterators.

fn triples<'a>(&'a self) -> Iter<'a, S, P, O> where
    S: 'a,
    P: 'a,
    O: 'a, 

fn subjects<'a>(&'a self) -> Subjects<'a, S, P, O> where
    S: 'a,
    P: 'a,
    O: 'a, 

Iterate through all the subjects of the graph.

fn predicates<'a>(&'a self, subject: &S) -> Predicates<'a, P, O> where
    P: 'a,
    O: 'a, 

Iterate through all the predicates associated to the given subject.

fn objects<'a>(&'a self, subject: &S, predicate: &P) -> Objects<'a, O> where
    O: 'a, 

Iterate through all the objects associated to the given subject and predicate.

fn contains(&self, triple: Triple<&S, &P, &O>) -> bool

Checks if the given triple is defined in the graph.

impl<S, P, O> Hash for BTreeGraph<S, P, O> where
    S: Ord + Hash,
    P: Ord + Hash,
    O: Ord + Hash, 

fn hash<__HSPO>(&self, __state: &mut __HSPO) where
    __HSPO: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a, S, P, O> IntoIterator for &'a BTreeGraph<S, P, O>

type IntoIter = Iter<'a, S, P, O>

Which kind of iterator are we turning this into?

type Item = Triple<&'a S, &'a P, &'a O>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S: Clone + Ord, P: Clone + Ord, O: Ord> IntoIterator for BTreeGraph<S, P, O>

type IntoIter = IntoIter<S, P, O>

Which kind of iterator are we turning this into?

type Item = Triple<S, P, O>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S: Ord, P: Ord, O: Ord> MutableGraph for BTreeGraph<S, P, O>

fn insert(&mut self, triple: Triple<S, P, O>)

Insert the given triple into the graph.

fn absorb<G: SizedGraph<Subject = S, Predicate = P, Object = O>>(
    &mut self,
    other: G
)

Absorb the given other graph.

impl<S, P, O> Ord for BTreeGraph<S, P, O> where
    S: Ord,
    P: Ord,
    O: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<S, P, O> PartialEq<BTreeGraph<S, P, O>> for BTreeGraph<S, P, O> where
    S: Ord,
    P: Ord,
    O: Ord, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<S, P, O> PartialOrd<BTreeGraph<S, P, O>> for BTreeGraph<S, P, O> where
    S: Ord,
    P: Ord,
    O: Ord, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<S: Clone + Ord, P: Clone + Ord, O: Ord> SizedGraph for BTreeGraph<S, P, O>

type IntoObjects = IntoObjects<O>

Consuming objects iterator.

type IntoPredicates = IntoPredicates<P, O>

Consuming predicates iterator.

type IntoSubjects = IntoSubjects<S, P, O>

Consuming subjects iterator.

type IntoTriples = IntoIter<S, P, O>

Consuming triples iterator.

fn into_triples(self) -> IntoIter<S, P, O>

Consumes the graph and returns an iterator over its triples.

fn into_subjects(self) -> IntoSubjects<S, P, O>

Consumes the graph and returns an iterator over its subjects.

fn into_predicates(self, subject: &S) -> IntoPredicates<P, O>

Consumes the graph and returns an iterator over the predicates of the given subject.

fn into_objects(self, subject: &S, predicate: &P) -> IntoObjects<O>

Consumes the graph and returns an iterator over the objects of the given subject and predicate.

impl<S, P, O> Eq for BTreeGraph<S, P, O> where
    S: Ord,
    P: Ord,
    O: Ord,