Struct sophia_term::literal::Literal

pub struct Literal<TD: TermData> { /* fields omitted */ }

An RDF literal.

Each literals has a lexical value, i.e. a text, and a datatype.

Language tagged literals

Language-tagged literals have the type rdf:langString and an additional language-tag.

The tags conform to BCP47.

Datatypes

Datatypes in RDF have a lexical scope and a value scope. Transformation between them is done by the lexical-to-value mapping of a datatype. If the text of a typed literal is not in the value space of its datatype, literal is called ill-typed or malformed. However, RDF specification explicitly requires implementations to accept those literals. In the end such malformed literals lead to logical inconsistency in a graph.

Implementations

impl<TD> Literal<TD> where
    TD: TermData, 

pub fn new_lang<U, V>(txt: U, tag: V) -> Result<Self> where
    V: AsRef<str>,
    TD: From<U> + From<V>, 

Return a new language-tagged literal.

Error

If tag is not a valid language-tag according to BCP47 an error is raised.

pub fn new_dt<U, V>(txt: U, dt: Iri<V>) -> Self where
    TD: From<U> + From<V>,
    V: TermData, 

Return a new literal with an arbitrary datatype.

Neither is checked if dt refers to a known datatype nor if txt is ill-type and not in the lexical space of dt. This is intended as the RDF specification requires implementations to accept ill-typed literals.

pub fn new_lang_unchecked<U, V>(txt: U, tag: V) -> Self where
    V: AsRef<str>,
    TD: From<U> + From<V>, 

Return a new language-tagged literal.

Pre-condition

tag must be a valid language-tag according to BCP47. In debug mode this is asserted.

pub fn as_ref(&self) -> Literal<&TD>

Borrow the inner contents of the literal.

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

Borrow the inner contents of the literal as &str.

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

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

pub fn map_into<TD2>(self) -> Literal<TD2> where
    TD: Into<TD2>,
    TD2: TermData, 

Maps the literal using the Into trait.

pub fn clone_map<'a, U, F>(&'a self, factory: F) -> Literal<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) -> Literal<U> where
    U: TermData + From<&'src str>, 

Apply clone_map() using the Into trait.

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

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

Performances

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

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

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

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

Writes the literal to the io::Write using the NTriples syntax.

pub fn txt(&self) -> &TD

Returns the literal's lexical value.

pub fn dt(&self) -> Iri<&str>

Return an IRI borrowing the literals datatype.

Note: A language-tagged literal has always the type rdf:langString.

pub fn lang(&self) -> Option<&TD>

Return the language-tag of the literal if it has one.

pub fn eq_txt<U>(&self, other: Literal<U>) -> bool where
    U: TermData, 

Check if both literals have the same lexical value.

Trait Implementations

impl<TD: Clone + TermData> Clone for Literal<TD>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TD: Copy + TermData> Copy for Literal<TD>

impl<TD: Debug + TermData> Debug for Literal<TD>

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

Formats the value using the given formatter.

impl<TD> Display for Literal<TD> where
    TD: TermData, 

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

Formats the value using the given formatter.

impl<T: TermData> Eq for Literal<T>

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

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

Performs the conversion.

impl<'a, T: ?Sized> From<NativeLiteral<T, &'a str>> for Literal<&'a str> where
    T: DataType, 

fn from(other: NativeLiteral<T, &'a str>) -> Literal<&'a str>

Performs the conversion.

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

fn from(other: NativeLiteral<T>) -> Literal<TD>

Performs the conversion.

impl<TD> Hash for Literal<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: TermData> Ord for Literal<TD>

fn cmp(&self, other: &Literal<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 Literal<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 Literal<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 Literal<TD>, Literal<MownStr<'a>>> for IriParsed<'b> where
    TD: TermData, 

fn resolve(&self, other: &'a Literal<TD>) -> Literal<MownStr<'a>>

Resolve the data type's IRI if it is relative.

Note that this only affects datatyped literals; language-tagged literals are absolute by construction.

Performance

May allocate an intermediate IRI if other.dt() is suffixed.

impl<TD: TermData> TTerm for Literal<TD>

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<TD> TryCopyTerm for Literal<TD> where
    TD: TermData + for<'x> From<&'x str>, 

type Error = TermError

The error type produced when failing to copy a given term

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

Try to copy term into an instance of this type.

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 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.