Struct MyQuad

pub struct MyQuad<'a> {
    pub subject: MyTerm<'a>,
    pub predicate: MyTerm<'a>,
    pub object: MyTerm<'a>,
    pub span: Range<usize>,
}

Fields

subject: MyTerm<'a>

predicate: MyTerm<'a>

object: MyTerm<'a>

span: Range<usize>

Implementations

impl<'a> MyQuad<'a>

pub fn to_owned(&self) -> MyQuad<'static>

Trait Implementations

impl<'a> Clone for MyQuad<'a>

fn clone(&self) -> MyQuad<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for MyQuad<'a>

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

Formats the value using the given formatter.

impl<'a> Display for MyQuad<'a>

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

Formats the value using the given formatter.

impl<'a> Quad for MyQuad<'a>

type Term = MyTerm<'a>

The type of Term used by this quad when borrowing it

fn s(&self) -> QBorrowTerm<'_, Self>

The subject of this quad.

fn p(&self) -> QBorrowTerm<'_, Self>

The predicate of this quad.

fn o(&self) -> QBorrowTerm<'_, Self>

The object of this quad.

fn g(&self) -> GraphName<QBorrowTerm<'_, Self>>

The graph name of this quad.

fn to_spog(self) -> Spog<Self::Term>

Consume this quad, returning all its components.

fn spog( &self, ) -> ([<Self::Term as Term>::BorrowTerm<'_>; 3], Option<<Self::Term as Term>::BorrowTerm<'_>>)

The four components of this quad, as a quad of borrowed terms.

fn to_s(self) -> Self::Term

Consume this quad, returning its subject.

fn to_p(self) -> Self::Term

Consume this quad, returning its predicate.

fn to_o(self) -> Self::Term

Consume this quad, returning its object.

fn to_g(self) -> Option<Self::Term>

Consume this quad, returning its graph name.

fn matched_by<S, P, O, G>(&self, sm: S, pm: P, om: O, gm: G) -> bool

where S: TermMatcher, P: TermMatcher, O: TermMatcher, G: GraphNameMatcher,

Checks that the constituents terms of this quad match the respective matchers.

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

where T: Quad,

Check whether other is term-wise equal (using Term::eq) to self.

fn eq_spog<S, P, O, G>(&self, s: S, p: P, o: O, g: Option<G>) -> bool

where S: Term, P: Term, O: Term, G: Term,

Check whether the quad (s, p, o) is term-wise equal (using Term::eq) to self.

fn into_triple(self) -> [Self::Term; 3]

Convert this quad to a Triple (dropping the graph name)