Enum Object 

pub enum Object {
    Iri(IriS),
    BlankNode(String),
    Literal(ConcreteLiteral),
    Triple {
        subject: Box<IriOrBlankNode>,
        predicate: IriS,
        object: Box<Object>,
    },
}

Represents an RDF object value in the object position of a triple.

In RDF, the object is the third component of a triple (subject-predicate-object) and can be one of four types:

• IRI: A resource identified by an Internationalized Resource Identifier
• Blank Node: An anonymous resource without a global identifier
• Literal: A concrete value (string, number, date, etc.) with optional datatype/language
• Triple (RDF-star): A quoted triple that can be nested as an object

Variants

Iri(IriS)

An IRI (Internationalized Resource Identifier) representing a named resource.

BlankNode(String)

A blank node (anonymous resource) identified by a local label.

Literal(ConcreteLiteral)

A literal value with a datatype and optional language tag.

Triple

An RDF-star quoted triple that can be used as an object.

Fields

• subject: The subject of the nested triple (IRI or blank node)
• predicate: The predicate of the nested triple (IRI)
• object: The object of the nested triple (recursively an Object)

Fields

subject: Box<IriOrBlankNode>

predicate: IriS

object: Box<Object>

Implementations

impl Object

Constructors methods

pub fn iri(iri: IriS) -> Object

Creates an IRI object from an IriS instance.

Parameters

• iri: The IRI to wrap as an object

pub fn bnode(str: String) -> Object

Creates a blank node object from a string identifier.

Parameters

• str: The blank node identifier

pub fn literal(lit: ConcreteLiteral) -> Object

Creates a literal object from a concrete literal value.

Parameters

• lit: The concrete literal to wrap as an object

pub fn str(str: &str) -> Object

Creates a string literal object from a string slice.

Parameters

• str: The string value for the literal

pub fn boolean(b: bool) -> Object

Creates a boolean literal object.

Parameters

• b: The boolean value

impl Object

Accessors methods

pub fn length(&self) -> usize

• For IRIs: the length of the IRI string
• For blank nodes: the length of the identifier
• For literals: the length of the lexical form
• For triples: the sum of all component lengths

pub fn numeric_value(&self) -> Option<NumericLiteral>

Extracts the numeric value if this is a numeric literal.

Returns

• Some(NumericLiteral) if this is a numeric literal (integer, decimal, float, double)
• None if this is not a literal or not a numeric type

pub fn datatype(&self) -> Option<IriRef>

Returns the datatype IRI of this object if it’s a literal.

Returns

• Some(IriRef) if this is a literal
• None if this is an IRI, blank node, or triple

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

Returns the language tag if this is a language-tagged string literal.

Returns

• Some(&Lang) if this is a string literal with a language tag (e.g., “en”, “es-MX”)
• None if this is not a language-tagged literal

impl Object

pub fn parse(str: &str, base: Option<&str>) -> Result<Object, RDFError>

Parsing methods

Parses a string into an RDF object, with optional base IRI resolution.

This method attempts to parse:

• Blank nodes: strings starting with “_:”
• Literals: strings starting with ‘“’ (not yet implemented)
• IRIs: all other strings, resolved against the base if provided

Parameters

• str: The string to parse
• base: Optional base IRI for resolving relative IRI references

Errors

• RDFError::ParsingIri if IRI parsing fails

impl Object

Formatting methods

pub fn show_qualified(&self, prefixmap: &PrefixMap) -> String

Formats this object using qualified names (prefixes) where possible.

This method produces a compact representation by replacing full IRIs with prefixed names (e.g., “rdf:type” instead of “http://www.w3.org/1999/02/22-rdf-syntax-ns#type”).

Parameters

• prefixmap: A prefix map containing IRI-to-prefix mappings

Trait Implementations

impl Clone for Object

fn clone(&self) -> Object

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Object

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

Formats the object for debugging (verbose output with type information).

Includes type tags for each variant:

• “Iri {}”
• “Bnode{}”
• “Literal{}”
• “Triple {,

  , }”

impl Default for Object

fn default() -> Self

Provides a default Object value (empty IRI).

impl<'de> Deserialize<'de> for Object

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Object

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

Formats the object for display (human-readable output).

• IRIs: displayed as-is
• Blank nodes: prefixed with “_:”
• Literals: uses the literal’s Display implementation
• Triples: not yet implemented

impl From<ConcreteLiteral> for Object

Converts a ConcreteLiteral into an Object::Literal.

This allows literals to be seamlessly used where objects are expected.

fn from(lit: ConcreteLiteral) -> Self

Converts to this type from the input type.

impl From<IriS> for Object

Converts an IriS into an Object::Iri.

This allows IRIs to be seamlessly used where objects are expected.

fn from(iri: IriS) -> Self

Converts to this type from the input type.

impl From<Object> for Term

Converts an Object into an oxrdf::Term.

This enables interoperability with the oxrdf library by converting the custom Object representation into oxrdf’s term type.

fn from(value: Object) -> Self

Converts to this type from the input type.

impl Hash for Object

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 Object

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

Implements total ordering for objects according to RDF semantics.

The ordering priority is: IRIs < Blank Nodes < Literals. Within each category, standard comparison applies:

• IRIs: lexicographic ordering of IRI strings
• Blank nodes: lexicographic ordering of identifiers
• Literals: ordering defined by ConcreteLiteral::cmp

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 Object

fn eq(&self, other: &Object) -> 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 Object

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

Implements partial ordering for objects.

Since Object implements total ordering via Ord, this always returns Some(ordering).

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 Serialize for Object

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Object> for IriOrBlankNode

Attempts to convert an Object into an IriOrBlankNode.

This conversion succeeds only when the object is an IRI or blank node. It fails with an error if the object is a literal or triple, as these cannot be represented as resources.

Errors

• RDFError::ExpectedIriOrBlankNodeFoundLiteral: When attempting to convert a literal object. Literals cannot be subjects in standard RDF.
• RDFError::ExpectedIriOrBlankNodeFoundTriple: When attempting to convert an RDF-star triple object in a context where quoted triples are not supported.

type Error = RDFError

The type returned in the event of a conversion error.

fn try_from(value: Object) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Object> for NamedOrBlankNode

Attempts to convert an Object into an oxrdf::NamedOrBlankNode.

This conversion is used when an object appears in subject position (which can only be IRIs or blank nodes, not literals).

Errors

Returns RDFError for objects that cannot be subjects (literals and triples).

type Error = RDFError

The type returned in the event of a conversion error.

fn try_from(value: Object) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Term> for Object

Attempts to convert an oxrdf::Term into an Object.

This enables interoperability with the oxrdf library by converting oxrdf’s term type into the custom Object representation.

Errors

Returns RDFError if the conversion fails (e.g., invalid literal format).

type Error = RDFError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for Object

impl StructuralPartialEq for Object