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 into_oxi_graph(&self, graph: impl TryInto<Term>) -> Result<Quad, ()>

pub fn into_oxi(&self, graph: Option<GraphName>) -> Result<Quad, ()>

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 duplicate 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 From<MyQuad<'static>> for MyTerm<'static>

fn from(value: MyQuad<'static>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for MyQuad<'a>

fn eq(&self, other: &Self) -> 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<'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

where Self: Sized,

Consume this quad, returning its subject.

fn to_p(self) -> Self::Term

where Self: Sized,

Consume this quad, returning its predicate.

fn to_o(self) -> Self::Term

where Self: Sized,

Consume this quad, returning its object.

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

where Self: Sized,

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]

where Self: Sized,

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

impl Triple<MyTerm<'static>, MyTerm<'static>, MyTerm<'static>> for MyQuad<'static>

fn new( subject: impl Into<MyTerm<'static>>, predicate: impl Into<MyTerm<'static>>, object: impl Into<MyTerm<'static>>, ) -> Self

Constructs a new RDF triple from the given components.

fn subj(&self) -> &MyTerm<'static>

Returns a reference to the subject of this triple.

fn pred(&self) -> &MyTerm<'static>

Returns a reference to the predicate of this triple.

fn obj(&self) -> &MyTerm<'static>

Returns a reference to the object of this triple.

fn into_components(self) -> (MyTerm<'static>, MyTerm<'static>, MyTerm<'static>)

Consumes the triple and returns its components as a tuple.

fn into_subject(self) -> S

Consumes the triple and returns only the subject.

fn into_predicate(self) -> P

Consumes the triple and returns only the predicate.

fn into_object(self) -> O

Consumes the triple and returns only the object.

impl<'b, 'a> TryFrom<&'b MyQuad<'a>> for Quad

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'b MyQuad<'a>) -> Result<Self, Self::Error>

Performs the conversion.