Struct NsTerm

pub struct NsTerm<'a> { /* private fields */ }

A Term produced by a Namespace.

The raison d’être of this type, compared to IriRef<&str>, is that it stored the IRI in two parts (namespace and suffix), so that the namespace can be reused by multiple distinct terms.

It makes sense for Namespaces, whose terms all have the same prefix.

Implementations

impl<'a> NsTerm<'a>

pub const fn new_unchecked(ns: IriRef<&'a str>, suffix: &'a str) -> Self

Make an NsTerm without checking that it produces a valid IRI.

pub fn iriref(&self) -> IriRef<MownStr<'_>>

Return an IriRef representing this term.

pub fn to_iriref(self) -> IriRef<MownStr<'a>>

Return an IriRef representing this term.

Trait Implementations

impl<'a> Clone for NsTerm<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for NsTerm<'a>

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

Formats the value using the given formatter.

impl Display for NsTerm<'_>

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

Formats the value using the given formatter.

impl<'a> Mul<NsTerm<'a>> for &'a str

type Output = SimpleTerm<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: NsTerm<'a>) -> Self::Output

Performs the * operation.

impl<'a> Mul<NsTerm<'a>> for Any

type Output = DatatypeMatcher<MownStr<'a>>

The resulting type after applying the * operator.

fn mul(self, rhs: NsTerm<'a>) -> Self::Output

Performs the * operation.

impl<'a, T: Term> PartialEq<T> for NsTerm<'a>

fn eq(&self, other: &T) -> 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> Term for NsTerm<'a>

type BorrowTerm<'x> = &'x NsTerm<'a> where 'a: 'x

A type of Term that can be borrowed from this type (i.e. that can be obtained from a simple reference to this type). It is used in particular for accessing constituents of quoted tripes (Term::triple) or for sharing this term with a function that expects T: Term (rather than &T) using Term::borrow_term.

fn kind(&self) -> TermKind

Return the kind of RDF term that this Term represents.

fn iri(&self) -> Option<IriRef<MownStr<'_>>>

If kind returns TermKind::Iri, return this IRI. Otherwise return None.

fn borrow_term(&self) -> Self::BorrowTerm<'_>

Get something implementing Term from a simple reference to self, representing the same RDF term as self.

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

Check whether self and other represent the same RDF term.

fn is_iri(&self) -> bool

Return true if this Term is an IRI, i.e. if kind retuns TermKind::Iri.

fn is_blank_node(&self) -> bool

Return true if this Term is a blank node, i.e. if kind retuns TermKind::BlankNode.

fn is_literal(&self) -> bool

Return true if this Term is a literal, i.e. if kind retuns TermKind::Literal.

fn is_variable(&self) -> bool

Return true if this Term is a variable, i.e. if kind retuns TermKind::Variable.

fn is_atom(&self) -> bool

Return true if this Term is an atomic term, i.e. an IRI, a blank node, a literal or a variable.

fn is_triple(&self) -> bool

Return true if this Term is an RDF-star quoted triple, i.e. if kind retuns TermKind::Triple.

fn bnode_id(&self) -> Option<BnodeId<MownStr<'_>>>

If kind returns TermKind::BlankNode, return the locally unique label of this blank node. Otherwise return None.

fn lexical_form(&self) -> Option<MownStr<'_>>

If kind returns TermKind::Literal, return the lexical form of this literal. Otherwise return None.

fn datatype(&self) -> Option<IriRef<MownStr<'_>>>

If kind returns TermKind::Literal, return the datatype IRI of this literal. Otherwise return None.

fn language_tag(&self) -> Option<LanguageTag<MownStr<'_>>>

If kind returns TermKind::Literal, and if this literal is a language-tagged string, return its language tag. Otherwise return None.

fn variable(&self) -> Option<VarName<MownStr<'_>>>

If kind returns TermKind::Variable, return the name of this variable. Otherwise return None.

fn triple(&self) -> Option<[Self::BorrowTerm<'_>; 3]>

If kind returns TermKind::Triple, return this triple. Otherwise return None.

fn to_triple(self) -> Option<[Self; 3]>

where Self: Sized,

If kind returns TermKind::Triple, return this triple, consuming this term. Otherwise return None.

fn constituents<'s>( &'s self, ) -> Box<dyn Iterator<Item = Self::BorrowTerm<'s>> + 's>

Iter over all the constituents of this term.

fn to_constituents<'a>(self) -> Box<dyn Iterator<Item = Self> + 'a>

where Self: Clone + 'a,

Iter over all the constiutents of this term, consuming it.

fn atoms<'s>(&'s self) -> Box<dyn Iterator<Item = Self::BorrowTerm<'s>> + 's>

Iter over all the atomic constituents of this term.

fn to_atoms<'a>(self) -> Box<dyn Iterator<Item = Self> + 'a>

where Self: Sized + 'a,

Iter over all the atomic constituents of this term, consuming it.

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

where T: Term,

Compare two terms:

fn hash<H: Hasher>(&self, state: &mut H)

Compute an implementation-independant hash of this RDF term.

fn into_term<T: FromTerm>(self) -> T

where Self: Sized,

Convert this term in another type.

fn try_into_term<T: TryFromTerm>(self) -> Result<T, T::Error>

where Self: Sized,

Try to convert this term into another type.

fn as_simple(&self) -> SimpleTerm<'_>

Copies this term into a SimpleTerm, borrowing as much as possible from self (calling SimpleTerm::from_term_ref).

impl<'a> Copy for NsTerm<'a>

impl<'a> Eq for NsTerm<'a>