Enum sophia_term::Term

pub enum Term<TD> where
    TD: TermData,  {
    Iri(Iri<TD>),
    BNode(BlankNode<TD>),
    Literal(Literal<TD>),
    Variable(Variable<TD>),
}

Generic type for RDF terms.

See module documentation for more detail.

Variants

Iri(Iri<TD>)

An IRI referencing a resource.

BNode(BlankNode<TD>)

A blank node.

Also known as existentially quantified variable.

Literal(Literal<TD>)

An RDF literal.

Variable(Variable<TD>)

A universally quantified variable like in SPARQL or Notation3.

Implementations

impl<T> Term<T> where
    T: TermData, 

pub fn write_fmt<W>(&self, w: &mut W) -> Result where
    W: Write, 

Writes the term to the fmt::Write using the NTriples syntax.

This means the IRI is in angled brackets and no prefix is used.

pub fn write_io<W>(&self, w: &mut W) -> Result<()> where
    W: Write, 

Writes the term to the io::Write using the N3 syntax.

impl<T> Term<T> where
    T: TermData, 

pub fn new_iri<U>(iri: U) -> Result<Term<T>> where
    U: AsRef<str>,
    T: From<U>, 

Return a new IRI term from the given text.

May fail if txt is not a valid IRI.

pub fn new_iri_suffixed<U, V>(ns: U, suffix: V) -> Result<Term<T>> where
    U: AsRef<str>,
    V: AsRef<str>,
    T: From<U> + From<V>, 

Return a new IRI term from the two given parts (prefix and suffix).

May fail if the concatenation of ns and suffix does not produce a valid IRI.

pub fn new_bnode<U>(id: U) -> Result<Term<T>> where
    U: AsRef<str>,
    T: From<U>, 

Return a new blank node term with the given bnode ID.

Currently, this may never fail; however it returns a result for homogeneity with other constructor methods, and because future versions may be more picky regarding bnode IDs.

pub fn new_literal_lang<U, V>(txt: U, lang: V) -> Result<Self> where
    V: AsRef<str>,
    T: From<U> + From<V>, 

Return a new literal term with the given value and language tag.

May fail if the language tag is not a valid BCP47 language tag.

pub fn new_literal_dt<U, V>(txt: U, dt: V) -> Result<Self> where
    T: From<U>,
    V: TryInto<Iri<T>>,
    TermError: From<<V as TryInto<Iri<T>>>::Error>, 

Return a new literal term with the given value and datatype.

May fail if dt is not an IRI.

pub fn new_variable<U>(name: U) -> Result<Term<T>> where
    U: AsRef<str>,
    T: From<U>, 

Return a new variable term with the given name.

May fail if name is not a valid variable name.

pub fn as_ref(&self) -> Term<&T>

Borrow the inner contents of the term.

pub fn as_ref_str(&self) -> Term<&str>

Borrow the inner contents of the term as &str.

pub fn map<F, TD2>(self, f: F) -> Term<TD2> where
    F: FnMut(T) -> TD2,
    TD2: TermData, 

Create a new term by applying f to the TermData of self.

pub fn map_into<TD2>(self) -> Term<TD2> where
    T: Into<TD2>,
    TD2: TermData, 

Maps the term using the Into trait.

pub fn clone_map<'a, U, F>(&'a self, factory: F) -> Term<U> where
    U: TermData,
    F: FnMut(&'a str) -> U, 

Clone self while transforming the inner TermData with the given factory.

This is done in one step in contrast to calling clone().map(factory).

pub fn clone_into<'src, U>(&'src self) -> Term<U> where
    U: TermData + From<&'src str>, 

Apply clone_map() using the Into trait.

pub fn normalized(&self, policy: Normalization) -> MownTerm<'_>

Return a term equivalent to this one, with all IRIs (if any) internally represented with all its data in ns, and an empty suffix.

Performances

The returned term will borrow data from this one as much as possible, but strings may be allocated in case a concatenation is required.

pub fn new_iri_unchecked<U>(iri: U) -> Term<T> where
    T: From<U>, 

Create a new IRI-term from a given IRI without checking its validity.

Pre-conditions

This function conducts no checks if the resulting IRI is valid. This is a contract that is generally assumed. Breaking it could result in unexpected behavior.

However, in debug builds assertions that perform checks are enabled.

pub fn new_iri_suffixed_unchecked<U, V>(ns: U, suffix: V) -> Term<T> where
    T: From<U> + From<V>, 

Create a new IRI-term from a given namespace and suffix.

Pre-conditions

It is expected that

• the resulting IRI is valid per RFC3987,
• suffix is not the empty string (otherwise, new_iri_unchecked should be used instead).

This is a contract that is generally assumed. Breaking it could result in unexpected behavior. However in debug mode, assertions that perform checks are enabled.

pub fn new_bnode_unchecked<U>(id: U) -> Term<T> where
    U: AsRef<str>,
    T: From<U>, 

Return a new blank node term.

Pre-condition

This function requires that id is a valid bnode ID.

pub fn new_literal_lang_unchecked<U, V>(txt: U, lang: V) -> Self where
    V: AsRef<str>,
    T: From<U> + From<V>, 

Return a literal term.

Pre-condition

This function requires that lang is a valid language tag. In debug mode this constraint is asserted.

pub fn new_literal_dt_unchecked<U, V>(txt: U, dt: V) -> Self where
    T: From<U>,
    V: TryInto<Iri<T>>,
    <V as TryInto<Iri<T>>>::Error: Debug, 

Return a typed literal term.

Panics

Panics if dt cannot be converted into an IRI.

pub fn new_variable_unchecked<U>(name: U) -> Term<T> where
    U: AsRef<str>,
    T: From<U>, 

Return a new variable term.

Pre-condition

This function requires that name is a valid variable name.

Trait Implementations

impl<TD: Clone> Clone for Term<TD> where
    TD: TermData, 

fn clone(&self) -> Term<TD>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TD: Copy> Copy for Term<TD> where
    TD: TermData, 

impl<TD> CopyTerm for Term<TD> where
    TD: TermData + for<'x> From<&'x str>, 

fn copy<T: ?Sized>(term: &T) -> Self where
    T: TTerm, 

Copy term into an instance of this type.

impl<TD: Debug> Debug for Term<TD> where
    TD: TermData, 

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

Formats the value using the given formatter.

impl<T> Display for Term<T> where
    T: TermData, 

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

Formats the value using the given formatter.

impl<TD: Eq> Eq for Term<TD> where
    TD: TermData, 

impl<TD> From<BlankNode<TD>> for Term<TD> where
    TD: TermData, 

fn from(bn: BlankNode<TD>) -> Self

Performs the conversion.

impl<TD> From<Iri<TD>> for Term<TD> where
    TD: TermData, 

fn from(iri: Iri<TD>) -> Self

Performs the conversion.

impl<TD> From<Literal<TD>> for Term<TD> where
    TD: TermData, 

fn from(lit: Literal<TD>) -> Self

Performs the conversion.

impl<T: ?Sized, TD> From<NativeLiteral<T, Box<str>>> for Term<TD> where
    T: DataType,
    TD: TermData + From<Box<str>> + From<&'static str>, 

fn from(other: NativeLiteral<T>) -> Self

Performs the conversion.

impl<TD> From<String> for Term<TD> where
    TD: TermData + From<Box<str>> + From<&'static str>, 

fn from(txt: String) -> Self

Performs the conversion.

impl<TD> From<Variable<TD>> for Term<TD> where
    TD: TermData, 

fn from(var: Variable<TD>) -> Self

Performs the conversion.

impl<TD> Hash for Term<TD> where
    TD: TermData, 

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

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<TD: Ord> Ord for Term<TD> where
    TD: TermData, 

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

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<TD, TE: ?Sized> PartialEq<TE> for Term<TD> where
    TD: TermData,
    TE: TTerm, 

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<TD, TE: ?Sized> PartialOrd<TE> for Term<TD> where
    TD: TermData,
    TE: TTerm, 

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

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

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

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

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

#[must_use]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<'a, 'b, TD> Resolve<&'a Term<TD>, Term<MownStr<'a>>> for IriParsed<'b> where
    TD: TermData, 

fn resolve(&self, other: &'a Term<TD>) -> MownTerm<'a>

Resolve IRIs and the IRIs of typed literals.

Performance

May allocate an intermediate IRI if an IRI is suffixed.

impl<TD> StructuralEq for Term<TD> where
    TD: TermData, 

impl<T: TermData> TTerm for Term<T>

fn kind(&self) -> TermKind

Returns the kind of this term (IRI, literal, blank node, variable).

fn value_raw(&self) -> RawValue<'_>

Return the "value" of this term, possibly split in two substrings. The second part might only be non-empty if this term is an IRI reference.

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

Return the datatype IRI of this term if it is a literal.

fn language(&self) -> Option<&str>

Return the language tag of this term if it is a language-tagged literal.

fn as_dyn(&self) -> &dyn TTerm

This method ensures that all implementations of TTerm can be turned into a trait object.

fn value(&self) -> MownStr<'_>

Return the "value" of this term, which depends on its kind: * for an IRI reference, its value; * for a literal, its lexical value; * for a blank node, its local identifier; * for a variable, its name.

fn is_absolute(&self) -> bool

All terms are absolute, except for: * relative IRI references, * literals whose datatype is a relative IRI reference.

impl<'a, T, U> TryFrom<&'a Term<U>> for Variable<T> where
    T: TermData + From<&'a str>,
    U: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: &'a Term<U>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, U> TryFrom<&'a Term<U>> for BlankNode<T> where
    T: TermData + From<&'a str>,
    U: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: &'a Term<U>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, U> TryFrom<&'a Term<U>> for Iri<T> where
    T: TermData + From<&'a str>,
    U: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: &'a Term<U>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, U> TryFrom<&'a Term<U>> for Literal<T> where
    T: TermData + From<&'a str>,
    U: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: &'a Term<U>) -> Result<Self, Self::Error>

Performs the conversion.

impl<TD> TryFrom<Term<TD>> for Variable<TD> where
    TD: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: Term<TD>) -> Result<Self, Self::Error>

Performs the conversion.

impl<TD> TryFrom<Term<TD>> for BlankNode<TD> where
    TD: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: Term<TD>) -> Result<Self, Self::Error>

Performs the conversion.

impl<TD> TryFrom<Term<TD>> for Iri<TD> where
    TD: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: Term<TD>) -> Result<Self, Self::Error>

Performs the conversion.

impl<TD> TryFrom<Term<TD>> for Literal<TD> where
    TD: TermData, 

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(term: Term<TD>) -> Result<Self, Self::Error>

Performs the conversion.