Enum ConcreteLiteral 

pub enum ConcreteLiteral {
    StringLiteral {
        lexical_form: String,
        lang: Option<Lang>,
    },
    DatatypeLiteral {
        lexical_form: String,
        datatype: IriRef,
    },
    NumericLiteral(NumericLiteral),
    DatetimeLiteral(XsdDateTime),
    BooleanLiteral(bool),
    WrongDatatypeLiteral {
        lexical_form: String,
        datatype: IriRef,
        error: String,
    },
}

Concrete representation of RDF literals with type-safe internal representations.

This enum provides a strongly-typed representation of RDF literals, using native Rust types (integers, floats, booleans, etc.) internally for efficiency. It also supports literals with incorrect datatypes to enable parsing and validation of potentially malformed RDF data.

Type Safety

The enum uses native Rust types internally, providing type safety and efficient operations on numeric values. For example, NumericLiteral stores actual numeric values rather than strings, enabling direct mathematical operations.

Error Handling

The WrongDatatypeLiteral variant allows parsing and representing malformed RDF data (e.g., "hello"^^xsd:integer) without losing information. This enables validation workflows that need to report specific errors while continuing to process other data.

Comparison and Ordering

Literals implement PartialOrd and Ord following SPARQL ordering rules:

• String literals are compared lexicographically
• Numeric literals are compared by numeric value
• Boolean literals follow false < true
• Datetime literals are compared chronologically

Panics

The Ord implementation panics when comparing incomparable literals (e.g., NaN floating-point values or literals with different datatypes). Use PartialOrd when comparing arbitrary literals to avoid panics.

Variants

StringLiteral

A plain string literal, optionally with a language tag.

Fields

lexical_form: String

lang: Option<Lang>

DatatypeLiteral

A literal with an explicit datatype IRI.

Fields

lexical_form: String

datatype: IriRef

NumericLiteral(NumericLiteral)

A numeric literal (integer, float, decimal, etc.).

DatetimeLiteral(XsdDateTime)

An XSD datetime literal.

BooleanLiteral(bool)

A boolean literal (true or false).

WrongDatatypeLiteral

Represents a literal with an invalid datatype.

For example, a value like "hello"^^xsd:integer would be represented as a WrongDatatypeLiteral. This is useful for parsing RDF data that may contain malformed literals while still enabling validation.

Fields

lexical_form: String

datatype: IriRef

error: String

Implementations

impl ConcreteLiteral

Display and formatting

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

Returns a string representation using the given prefix map to qualify IRIs.

This method formats the literal using shortened IRI prefixes from the provided prefix map, making the output more readable.

Arguments

• prefixmap - The prefix map used to shorten IRIs

Examples

use rudof_rdf::rdf_core::term::literal::ConcreteLiteral;
use prefixmap::PrefixMap;

let lit = ConcreteLiteral::integer(42);
let prefixmap = PrefixMap::basic();
println!("{}", lit.show_qualified(&prefixmap));

pub fn display_qualified<W: Write>( &self, f: &mut W, prefixmap: &PrefixMap, ) -> Result

Formats this literal using the given prefix map and writes the result into the provided formatter.

The output follows RDF/Turtle-style literal syntax:

• String literals are quoted, with an optional language tag
• Numeric and boolean literals are written as-is
• Datatype literals are written using ^^ and qualified IRIs
• Datatypes are shortened using the provided prefix map when possible

This method is intended for internal use by [show_qualified] and Display implementations rather than being called directly.

Arguments

• f - The output writer to which the literal representation is written
• prefixmap - The prefix map used to qualify datatype IRIs

Errors

Returns any formatting error encountered while writing to the formatter.

impl ConcreteLiteral

Validation and Conversion

pub fn into_checked_literal(self) -> Result<Self, RDFError>

Validates that the lexical form matches the declared datatype, consuming the literal and returning a validated version.

This method checks whether the lexical form of a datatype literal is compatible with its declared datatype. If the validation succeeds, a properly typed literal is returned. If the validation fails, a WrongDatatypeLiteral is returned instead.

For non-datatype literals, the value is returned unchanged.

Errors

Returns an LiteralError if datatype validation fails.

Examples

use rudof_rdf::rdf_core::term::literal::ConcreteLiteral;
use iri_s::IriS;
use prefixmap::IriRef;

// Create a datatype literal with an integer value
let dt_iri = IriRef::iri(IriS::new_unchecked("http://www.w3.org/2001/XMLSchema#integer"));
let lit = ConcreteLiteral::lit_datatype("42", &dt_iri);

// Validate the literal
let checked = lit.into_checked_literal().unwrap();

pub fn match_literal(&self, literal_expected: &Self) -> bool

Compares this literal with another for equality.

This method performs type-aware comparison, ensuring that literals of different types are not considered equal even if their lexical forms match.

Arguments

• literal_expected - The literal to compare against

Returns

true if the literals are equal, false otherwise.

Examples

use rudof_rdf::rdf_core::term::literal::ConcreteLiteral;
use rudof_rdf::rdf_core::term::literal::Lang;

let lit1 = ConcreteLiteral::str("hello");
let lit2 = ConcreteLiteral::str("hello");
let lit3 = ConcreteLiteral::lang_str("hello", Lang::new("en").unwrap());
let lit4 = ConcreteLiteral::integer(42);

// Plain string literals with the same content are equal
assert!(lit1.match_literal(&lit2));

// Language-tagged string literals must match both lexical form and lang
assert!(!lit1.match_literal(&lit3));

// Numeric and string literals are not equal even if lexical forms match
let lit5 = ConcreteLiteral::lit_datatype("42", &lit4.datatype());
assert!(!lit5.match_literal(&lit4));

// Comparing numeric literals of the same value returns true
let lit6 = ConcreteLiteral::integer(42);
assert!(lit4.match_literal(&lit6));

impl ConcreteLiteral

Constructor Methods - Numeric Types

pub fn integer(n: i128) -> Self

Creates a literal representing an unbounded integer (i128).

This corresponds to XSD’s xsd:integer type, which is unbounded.

pub fn non_negative_integer(n: u128) -> Self

Creates a literal representing a non-negative integer (u128 ≥ 0).

This corresponds to XSD’s xsd:nonNegativeInteger type.

pub fn non_positive_integer(n: i128) -> Result<Self, RDFError>

Creates a literal representing a non-positive integer (i128 ≤ 0).

This corresponds to XSD’s xsd:nonPositiveInteger type.

Errors

Returns RDFError::NumericOutOfRange if n is greater than 0.

pub fn positive_integer(n: u128) -> Result<Self, RDFError>

Creates a literal representing a strictly positive integer (u128 > 0).

This corresponds to XSD’s xsd:positiveInteger type.

Errors

Returns RDFError::NumericOutOfRange if n is 0.

pub fn negative_integer(n: i128) -> Result<Self, RDFError>

Creates a literal representing a strictly negative integer (i128 < 0).

This corresponds to XSD’s xsd:negativeInteger type.

Errors

Returns RDFError::NumericOutOfRange if n is greater than or equal to 0.

pub fn double(d: f64) -> Self

Creates a literal representing a double-precision floating-point number (f64).

This corresponds to XSD’s xsd:double type (64-bit IEEE 754).

pub fn decimal(d: Decimal) -> Self

Creates a literal representing a decimal number (Decimal type for precise arithmetic).

This corresponds to XSD’s xsd:decimal type for exact decimal arithmetic.

pub fn long(n: i64) -> Self

Creates a literal representing a 64-bit signed long integer (i64).

This corresponds to XSD’s xsd:long type (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807).

pub fn byte(n: i8) -> Self

Creates a literal representing a signed byte (i8), values -128 to 127.

This corresponds to XSD’s xsd:byte type.

pub fn short(n: i16) -> Self

Creates a literal representing a signed short (i16), values -32,768 to 32,767.

This corresponds to XSD’s xsd:short type.

pub fn unsigned_byte(n: u8) -> Self

Creates a literal representing an unsigned byte (u8), values 0–255.

This corresponds to XSD’s xsd:unsignedByte type.

pub fn unsigned_short(n: u16) -> Self

Creates a literal representing an unsigned short (u16), values 0–65,535.

This corresponds to XSD’s xsd:unsignedShort type.

pub fn unsigned_int(n: u32) -> Self

Creates a literal representing an unsigned integer (u32).

This corresponds to XSD’s xsd:unsignedInt type.

pub fn unsigned_long(n: u64) -> Self

Creates a literal representing an unsigned long integer (u64).

This corresponds to XSD’s xsd:unsignedLong type.

pub fn float(n: f32) -> Self

Creates a literal representing a single-precision floating-point number (f32).

This corresponds to XSD’s xsd:float type (32-bit IEEE 754).

pub fn datetime(dt: XsdDateTime) -> Self

Creates a DatetimeLiteral

impl ConcreteLiteral

Constructor Methods - Other Types

pub fn lit_datatype(lexical_form: &str, datatype: &IriRef) -> Self

Creates a literal with a custom datatype.

Parameters

• lexical_form: The string representation of the literal’s value.
• datatype: The IRI that identifies the literal’s datatype.

pub fn boolean(b: bool) -> Self

Creates a boolean literal (true or false).

pub fn str(lexical_form: &str) -> Self

Creates a plain string literal without a language tag.

Parameters

• lexical_form: The text content of the literal.

pub fn lang_str(lexical_form: &str, lang: Lang) -> Self

Creates a string literal with a language tag.

Parameters

• lexical_form: The text content of the literal.
• lang: The language of the literal, e.g., "en" for English.

impl ConcreteLiteral

Accessor Methods

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

Returns the language tag of the literal, if it is a language-tagged string.

pub fn lexical_form(&self) -> String

Returns the lexical form (string representation) of the literal.

Returns

A String representing the literal’s value:

• For string or datatype literals, returns the literal text.
• For numeric literals, returns the numeric value as a string.
• For boolean literals, returns "true" or "false".
• For datetime literals, returns a standard string representation.

pub fn datatype(&self) -> IriRef

Returns the datatype IRI of the literal.

Returns

• For explicitly typed literals (DatatypeLiteral or WrongDatatypeLiteral), returns the stored datatype IRI.
• For plain string literals without a language tag, returns xsd:string.
• For language-tagged string literals, returns rdf:langString.
• For numeric literals, returns the appropriate XML Schema datatype (e.g., xsd:integer, xsd:double).
• For boolean literals, returns xsd:boolean.
• For datetime literals, returns xsd:dateTime.

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

Returns the numeric literal value, if this literal is numeric.

impl ConcreteLiteral

Parsing Methods

pub fn parse_bool(s: &str) -> Result<bool, String>

Parses a boolean from its XSD lexical representation.

Valid values are: “true”, “false”, “1” (true), “0” (false). Parsing is case-sensitive.

Errors

Returns an error if the input string is not a valid boolean representation.

Examples

use rudof_rdf::rdf_core::term::literal::ConcreteLiteral;
assert_eq!(ConcreteLiteral::parse_bool("true").unwrap(), true);
assert_eq!(ConcreteLiteral::parse_bool("0").unwrap(), false);
assert!(ConcreteLiteral::parse_bool("yes").is_err());

pub fn parse_integer(s: &str) -> Result<i128, String>

Parses an integer from its string representation.

XSD integer is unbounded, so this returns i128.

Errors

Returns an error if the string cannot be parsed as an integer.

Examples

use rudof_rdf::rdf_core::term::literal::ConcreteLiteral;
assert_eq!(ConcreteLiteral::parse_integer("-7").unwrap(), -7);
assert_eq!(ConcreteLiteral::parse_integer("2").unwrap(), 2);
assert!(ConcreteLiteral::parse_integer("x").is_err());

pub fn parse_negative_integer(s: &str) -> Result<i128, String>

Parses a negative integer from its string representation.

Errors

Returns an error if the value is not negative or cannot be parsed.

Examples

use rudof_rdf::rdf_core::term::literal::ConcreteLiteral;
assert_eq!(ConcreteLiteral::parse_negative_integer("-3").unwrap(), -3);
assert!(ConcreteLiteral::parse_negative_integer("0").is_err());

pub fn parse_non_positive_integer(s: &str) -> Result<i128, String>

Parses a non-positive integer from its string representation.

Errors

Returns an error if the value is positive or cannot be parsed.

pub fn parse_positive_integer(s: &str) -> Result<u128, String>

Parses a positive integer from its string representation.

Errors

Returns an error if the value is not positive or cannot be parsed.

pub fn parse_non_negative_integer(s: &str) -> Result<u128, String>

Parses a non-negative integer from its string representation.

Errors

Returns an error if the string cannot be parsed as a non-negative integer.

pub fn parse_unsigned_byte(s: &str) -> Result<u8, String>

Parses an unsigned byte (0–255) from its string representation.

Errors

Returns an error if the string cannot be parsed as a u8.

pub fn parse_unsigned_short(s: &str) -> Result<u16, String>

Parses an unsigned short (0–65535) from its string representation.

Errors

Returns an error if the string cannot be parsed as a u16.

pub fn parse_unsigned_int(s: &str) -> Result<u32, String>

Parses an unsigned integer from its string representation.

Errors

Returns an error if the string cannot be parsed as a u32.

pub fn parse_unsigned_long(s: &str) -> Result<u64, String>

Parses an unsigned long (0–u64::MAX) from its string representation.

Errors

Returns an error if the string cannot be parsed as a u64.

pub fn parse_double(s: &str) -> Result<f64, String>

Parses a double (64-bit float) from its string representation.

Errors

Returns an error if the string cannot be parsed as a f64.

pub fn parse_long(s: &str) -> Result<i64, String>

Parses a long integer (64-bit signed) from its string representation.

Errors

Returns an error if the string cannot be parsed as an i64.

pub fn parse_decimal(s: &str) -> Result<Decimal, String>

Parses a decimal from its string representation using rust_decimal::Decimal.

Errors

Returns an error if the string cannot be parsed as a Decimal.

pub fn parse_float(s: &str) -> Result<f32, String>

Parses a float (32-bit) from its string representation.

Errors

Returns an error if the string cannot be parsed as a float.

pub fn parse_byte(s: &str) -> Result<i8, String>

Parses a signed byte (-128 to 127) from its string representation.

Errors

Returns an error if the string cannot be parsed as an i8.

pub fn parse_short(s: &str) -> Result<i16, String>

Parses a signed short (-32768 to 32767) from its string representation.

Errors

Returns an error if the string cannot be parsed as an i16.

pub fn parse_datetime(s: &str) -> Result<XsdDateTime, String>

Parses a datetime string using XsdDateTime

Trait Implementations

impl Clone for ConcreteLiteral

fn clone(&self) -> ConcreteLiteral

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConcreteLiteral

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

Formats the value using the given formatter.

impl Default for ConcreteLiteral

fn default() -> Self

Returns an empty string literal without a language tag.

This is used as a neutral default value when a literal is required but no concrete value is available.

impl DerefIri for ConcreteLiteral

fn deref_iri( self, base: Option<&IriS>, prefixmap: Option<&PrefixMap>, ) -> Result<Self, DerefError>

Resolves IRIs and prefixes contained in the literal.

• Value-based literals (NumericLiteral, BooleanLiteral, DatetimeLiteral, StringLiteral) are cloned directly.
• Datatype literals have their datatype IRIs dereferenced using base and prefixmap.
• Wrong datatype literals are converted into properly typed literals.

Errors

Returns DerefError if datatype resolution fails.

impl<'de> Deserialize<'de> for ConcreteLiteral

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ConcreteLiteral

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

Formats the literal using a basic prefix map for qualified display.

impl From<&ConcreteLiteral> for Literal

fn from(value: &ConcreteLiteral) -> Self

Converts to this type from the input type.

impl From<ConcreteLiteral> for Literal

fn from(value: ConcreteLiteral) -> Self

Converts an SLiteral into an oxrdf::Literal

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 Hash for ConcreteLiteral

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 ConcreteLiteral

Total ordering for literals.

Panics

This implementation panics if two literals are not comparable, such as:

• Literals with different datatypes
• Numeric literals involving NaN

This is intended as a temporary solution to support sorting in validation workflows where such cases are not expected.

TODO

Define a total ordering that is well-defined for all literals.

fn cmp(&self, other: &Self) -> 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 ConcreteLiteral

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

Partial ordering for literals following SPARQL comparison semantics.

Comparison rules:

• String literals are compared lexicographically by their lexical form.
• Datatype literals are comparable only if they share the same datatype, and are then compared by lexical form.
• Numeric literals are compared by numeric value.
• Boolean literals follow true > false.
• Datetime literals are compared chronologically.

If two literals are not comparable under these rules, None is returned.

See: https://www.w3.org/TR/sparql11-query/#OperatorMapping

fn partial_cmp(&self, other: &Self) -> 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 Serialize for ConcreteLiteral

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Literal> for ConcreteLiteral

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

Attempts to convert an oxrdf literal into an SLiteral.

Supported cases:

• Plain string literals
• Language-tagged string literals
• Typed literals (with datatype parsing)

Errors

Returns an LiteralError if:

• The language tag is invalid
• The datatype is unsupported or malformed
• The literal structure is unknown

type Error = RDFError

The type returned in the event of a conversion error.

impl Eq for ConcreteLiteral

impl StructuralPartialEq for ConcreteLiteral