Enum Term 

pub enum Term {
    NamedNode(IriBuf),
    Literal(Literal),
    BlankNode(BlankNode),
    TripleTerm(Arc<Triple>),
}

https://www.w3.org/TR/rdf11-concepts/#section-triples

Variants

NamedNode(IriBuf)

Literal(Literal)

BlankNode(BlankNode)

TripleTerm(Arc<Triple>)

Implementations

impl Term

pub fn into_iri(self) -> Result<IriBuf, TermError>

pub fn into_literal(self) -> Result<Literal, TermError>

pub fn into_blank_node(self) -> Result<BlankNode, TermError>

pub fn into_triple_term(self) -> Result<Arc<Triple>, TermError>

pub fn to_iri(&self) -> Result<&IriBuf, TermError>

pub fn to_literal(&self) -> Result<&Literal, TermError>

pub fn to_blank_node(&self) -> Result<&BlankNode, TermError>

pub fn to_triple_term(&self) -> Result<&Arc<Triple>, TermError>

pub fn is_named_node(&self) -> bool

pub fn is_blank_node(&self) -> bool

pub fn is_literal(&self) -> bool

pub fn is_triple_term(&self) -> bool

pub fn ground(&self) -> bool

Checks whether term is ground as defined by RDF Concepts and Abstract Syntax

A term is ground if it is not a blank node or a triple term containing a blank node.

Example

use taganak_core::terms::Term;
use std::sync::Arc;

let nn: Arc<Term> = Arc::new("<https://example.com/foo>".try_into().unwrap());
let bn: Arc<Term> = Arc::new("_:b1".try_into().unwrap());
let li: Arc<Term> = Arc::new(r#""Something""#.try_into().unwrap());

assert_eq!(nn.ground(), true);
assert_eq!(li.ground(), true);
assert_eq!(bn.ground(), false);

Trait Implementations

impl Clone for Term

fn clone(&self) -> Term

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Term

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

Formats the value using the given formatter.

impl Display for Term

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

Formats the value using the given formatter.

impl GraphORMField for Term

fn orm_triples( &self, subject: Option<&Term>, predicate: Option<&Term>, ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError>

Serialise into triples

async fn orm_field_from_graph( graph: impl GraphView, subject: &Term, predicate: &Term, object: Option<&Term>, ) -> Result<Term, GraphORMError>

where Term: Sized,

Deserialise a field from a graph.

impl Hash for Term

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

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Term

fn eq(&self, other: &Term) -> 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 TryFrom<&str> for Term

fn try_from(value: &str) -> Result<Term, <Term as TryFrom<&str>>::Error>

Examples

use language_tags::LanguageTag;
use taganak_core::terms::{Iri, Literal, Term};

let t1: Term = "<https://example.com/foo#bar>".try_into().unwrap();
let t2: Term = r#""Schildkröte"@de"#.try_into().unwrap();

assert_eq!(t1, Term::NamedNode(Iri::new("https://example.com/foo#bar".to_string()).unwrap()));
assert_eq!(t2, Term::Literal(Literal::new("Schildkröte".to_string(), None, Some(LanguageTag::parse("de").unwrap()), None).unwrap()));

type Error = TermError

The type returned in the event of a conversion error.

impl TryFrom<String> for Term

type Error = TermError

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Term, <Term as TryFrom<String>>::Error>

Performs the conversion.

impl Eq for Term

impl StructuralPartialEq for Term