Enum Term 

pub enum Term {
    NamedNode(NamedNode),
    BlankNode(BlankNode),
    Literal(Literal),
    Variable(Variable),
    QuotedTriple(Box<QuotedTriple>),
}

Union type for all RDF terms

This enum can hold any type of RDF term and is used when the specific type is not known at compile time. It supports the full RDF 1.2 specification including RDF-star quoted triples.

Examples

use oxirs_core::model::{Term, NamedNode, Literal, BlankNode, Variable};

// Create different types of terms
let named_node = Term::NamedNode(NamedNode::new("http://example.org/resource").unwrap());
let literal = Term::Literal(Literal::new("Hello World"));
let blank_node = Term::BlankNode(BlankNode::new("b1").unwrap());
let variable = Term::Variable(Variable::new("x").unwrap());

// Check term types
assert!(named_node.is_named_node());
assert!(literal.is_literal());
assert!(blank_node.is_blank_node());
assert!(variable.is_variable());

Variants

• NamedNode: An IRI reference (e.g., <http://example.org/resource>)
• BlankNode: An anonymous node (e.g., _:b1)
• Literal: A literal value with optional datatype and language tag
• Variable: A query variable (e.g., ?x)
• [QuotedTriple]: A quoted triple for RDF-star support

Variants

NamedNode(NamedNode)

A named node (IRI reference)

Represents a resource identified by an IRI according to RFC 3987. Used for subjects, predicates, and objects in RDF triples.

BlankNode(BlankNode)

A blank node (anonymous resource)

Represents an anonymous resource that can be used as a subject or object but not as a predicate. Blank nodes have local scope within a graph.

Literal(Literal)

A literal value

Represents a data value with an optional datatype and language tag. Can only be used as objects in RDF triples.

Variable(Variable)

A query variable

Represents a variable in SPARQL queries or graph patterns. Variables are prefixed with ‘?’ or ‘$’ in SPARQL syntax.

QuotedTriple(Box<QuotedTriple>)

A quoted triple (RDF-star)

Represents a triple that can itself be used as a subject or object in another triple, enabling statement-level metadata.

Implementations

impl Term

pub fn is_named_node(&self) -> bool

Returns true if this term is a named node (IRI reference)

Examples

use oxirs_core::model::{Term, NamedNode, Literal};

let named_node = Term::NamedNode(NamedNode::new("http://example.org/resource").unwrap());
let literal = Term::Literal(Literal::new("Hello"));

assert!(named_node.is_named_node());
assert!(!literal.is_named_node());

pub fn is_blank_node(&self) -> bool

Returns true if this term is a blank node

Examples

use oxirs_core::model::{Term, BlankNode, Literal};

let blank_node = Term::BlankNode(BlankNode::new("b1").unwrap());
let literal = Term::Literal(Literal::new("Hello"));

assert!(blank_node.is_blank_node());
assert!(!literal.is_blank_node());

pub fn is_literal(&self) -> bool

Returns true if this term is a literal value

Examples

use oxirs_core::model::{Term, NamedNode, Literal};

let literal = Term::Literal(Literal::new("Hello"));
let named_node = Term::NamedNode(NamedNode::new("http://example.org/resource").unwrap());

assert!(literal.is_literal());
assert!(!named_node.is_literal());

pub fn is_variable(&self) -> bool

Returns true if this term is a query variable

Examples

use oxirs_core::model::{Term, Variable, Literal};

let variable = Term::Variable(Variable::new("x").unwrap());
let literal = Term::Literal(Literal::new("Hello"));

assert!(variable.is_variable());
assert!(!literal.is_variable());

pub fn is_quoted_triple(&self) -> bool

Returns true if this term is a quoted triple (RDF-star)

Examples

use oxirs_core::model::{Term, Literal};

let literal = Term::Literal(Literal::new("Hello"));

assert!(!literal.is_quoted_triple());
// Note: Creating QuotedTriple examples requires more complex setup

pub fn as_named_node(&self) -> Option<&NamedNode>

Returns the named node if this term is a named node

pub fn as_blank_node(&self) -> Option<&BlankNode>

Returns the blank node if this term is a blank node

pub fn as_literal(&self) -> Option<&Literal>

Returns the literal if this term is a literal

pub fn as_variable(&self) -> Option<&Variable>

Returns the variable if this term is a variable

pub fn as_quoted_triple(&self) -> Option<&QuotedTriple>

Returns the quoted triple if this term is a quoted triple

pub fn from_subject(subject: &Subject) -> Term

Convert a Subject to a Term

pub fn from_predicate(predicate: &Predicate) -> Term

Convert a Predicate to a Term

pub fn from_object(object: &Object) -> Term

Convert an Object to a Term

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Term

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Term

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

Formats the value using the given formatter.

impl<'a> From<&'a Term> for TermRef<'a>

fn from(term: &'a Term) -> Self

Converts to this type from the input type.

impl From<BlankNode> for Term

fn from(node: BlankNode) -> Self

Converts to this type from the input type.

impl From<GroundTerm> for Term

fn from(term: GroundTerm) -> Self

Converts to this type from the input type.

impl From<Literal> for Term

fn from(literal: Literal) -> Self

Converts to this type from the input type.

impl From<NamedNode> for Term

fn from(node: NamedNode) -> Self

Converts to this type from the input type.

impl From<NamedOrBlankNode> for Term

fn from(node: NamedOrBlankNode) -> Self

Converts to this type from the input type.

impl From<Object> for Term

fn from(object: Object) -> Self

Converts to this type from the input type.

impl From<Predicate> for Term

fn from(predicate: Predicate) -> Self

Converts to this type from the input type.

impl From<Subject> for Term

fn from(subject: Subject) -> Self

Converts to this type from the input type.

impl From<Term> for Object

fn from(term: Term) -> Self

Converts to this type from the input type.

impl From<Variable> for Term

fn from(variable: Variable) -> Self

Converts to this type from the input type.

impl Hash for Term

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Term

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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 PartialOrd for Term

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

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl RdfTerm for Term

fn as_str(&self) -> &str

Returns the string representation of this term

fn is_named_node(&self) -> bool

Returns true if this is a named node (IRI)

fn is_blank_node(&self) -> bool

Returns true if this is a blank node

fn is_literal(&self) -> bool

Returns true if this is a literal

fn is_variable(&self) -> bool

Returns true if this is a variable

fn is_quoted_triple(&self) -> bool

Returns true if this is a quoted triple (RDF-star)

impl Serialize for Term

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Term> for GroundTerm

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Term> for Predicate

type Error = OxirsError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Term> for Subject

type Error = OxirsError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl ZeroCopySerialize for Term

fn serialize_to<W: Write>(&self, writer: &mut W) -> Result<()>

Serialize to a writer

fn serialized_size(&self) -> usize

Get the serialized size in bytes

fn serialize_to_bytes(&self, buf: &mut BytesMut)

Serialize to a byte buffer

impl Eq for Term

impl StructuralPartialEq for Term