Allows using oxrdf without RDF-star

pull/190/head
Tpt 3 years ago
parent f5545f1948
commit a16a4108b8
  1. 2
      lib/Cargo.toml
  2. 4
      lib/oxrdf/Cargo.toml
  3. 2
      lib/oxrdf/README.md
  4. 65
      lib/oxrdf/src/dataset.rs
  5. 12
      lib/oxrdf/src/interning.rs
  6. 2
      lib/oxrdf/src/lib.rs
  7. 43
      lib/oxrdf/src/parser.rs
  8. 26
      lib/oxrdf/src/triple.rs

@ -42,7 +42,7 @@ lazy_static = "1"
sophia_api = { version = "0.7", optional = true } sophia_api = { version = "0.7", optional = true }
json-event-parser = "0.1" json-event-parser = "0.1"
num_cpus = "1" num_cpus = "1"
oxrdf = { version = "0.1", path="oxrdf" } oxrdf = { version = "0.1", path="oxrdf", features = ["rdf-star"] }
spargebra = { version = "0.1", path="../spargebra", features = ["rdf-star"] } spargebra = { version = "0.1", path="../spargebra", features = ["rdf-star"] }
[target.'cfg(not(target_arch = "wasm32"))'.dependencies] [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

@ -12,6 +12,10 @@ A library providing basic data structures related to RDF
""" """
edition = "2021" edition = "2021"
[features]
default = []
rdf-star = []
[dependencies] [dependencies]
rand = "0.8" rand = "0.8"
oxilangtag = "0.1" oxilangtag = "0.1"

@ -11,6 +11,8 @@ OxRDF is a simple library providing datastructures encoding [RDF 1.1 concepts](h
This crate is intended to be a basic building block of other crates like [Oxigraph](https://crates.io/crates/oxigraph) or [Spargebra](https://crates.io/crates/spargebra). This crate is intended to be a basic building block of other crates like [Oxigraph](https://crates.io/crates/oxigraph) or [Spargebra](https://crates.io/crates/spargebra).
Support for [RDF-star](https://w3c.github.io/rdf-star/cg-spec/) is available behind the `rdf-star` feature.
Inspired by [RDF/JS](https://rdf.js.org/data-model-spec/) and [Apache Commons RDF](http://commons.apache.org/proper/commons-rdf/). Inspired by [RDF/JS](https://rdf.js.org/data-model-spec/) and [Apache Commons RDF](http://commons.apache.org/proper/commons-rdf/).
Usage example: Usage example:

@ -536,12 +536,16 @@ impl Dataset {
for (g, s, _, o) in &self.gspo { for (g, s, _, o) in &self.gspo {
if let InternedSubject::BlankNode(bnode) = s { if let InternedSubject::BlankNode(bnode) = s {
bnodes.insert(*bnode); bnodes.insert(*bnode);
} else if let InternedSubject::Triple(triple) = s { }
#[cfg(feature = "rdf-star")]
if let InternedSubject::Triple(triple) = s {
self.triple_blank_nodes(triple, &mut bnodes); self.triple_blank_nodes(triple, &mut bnodes);
} }
if let InternedTerm::BlankNode(bnode) = o { if let InternedTerm::BlankNode(bnode) = o {
bnodes.insert(*bnode); bnodes.insert(*bnode);
} else if let InternedTerm::Triple(triple) = o { }
#[cfg(feature = "rdf-star")]
if let InternedTerm::Triple(triple) = o {
self.triple_blank_nodes(triple, &mut bnodes); self.triple_blank_nodes(triple, &mut bnodes);
} }
if let InternedGraphName::BlankNode(bnode) = g { if let InternedGraphName::BlankNode(bnode) = g {
@ -551,6 +555,7 @@ impl Dataset {
bnodes bnodes
} }
#[cfg(feature = "rdf-star")]
fn triple_blank_nodes(&self, triple: &InternedTriple, bnodes: &mut HashSet<InternedBlankNode>) { fn triple_blank_nodes(&self, triple: &InternedTriple, bnodes: &mut HashSet<InternedBlankNode>) {
if let InternedSubject::BlankNode(bnode) = &triple.subject { if let InternedSubject::BlankNode(bnode) = &triple.subject {
bnodes.insert(*bnode); bnodes.insert(*bnode);
@ -633,20 +638,24 @@ impl Dataset {
node: &InternedSubject, node: &InternedSubject,
bnodes_hash: &HashMap<InternedBlankNode, u64>, bnodes_hash: &HashMap<InternedBlankNode, u64>,
) -> u64 { ) -> u64 {
#[cfg(feature = "rdf-star")]
if let InternedSubject::Triple(triple) = node {
return self.hash_triple(triple, bnodes_hash);
}
if let InternedSubject::BlankNode(bnode) = node { if let InternedSubject::BlankNode(bnode) = node {
bnodes_hash[bnode] bnodes_hash[bnode]
} else if let InternedSubject::Triple(triple) = node {
self.hash_triple(triple, bnodes_hash)
} else { } else {
Self::hash_tuple(node.decode_from(&self.interner)) Self::hash_tuple(node.decode_from(&self.interner))
} }
} }
fn hash_term(&self, term: &InternedTerm, bnodes_hash: &HashMap<InternedBlankNode, u64>) -> u64 { fn hash_term(&self, term: &InternedTerm, bnodes_hash: &HashMap<InternedBlankNode, u64>) -> u64 {
#[cfg(feature = "rdf-star")]
if let InternedTerm::Triple(triple) = term {
return self.hash_triple(triple, bnodes_hash);
}
if let InternedTerm::BlankNode(bnode) = term { if let InternedTerm::BlankNode(bnode) = term {
bnodes_hash[bnode] bnodes_hash[bnode]
} else if let InternedTerm::Triple(triple) = term {
self.hash_triple(triple, bnodes_hash)
} else { } else {
Self::hash_tuple(term.decode_from(&self.interner)) Self::hash_tuple(term.decode_from(&self.interner))
} }
@ -664,6 +673,7 @@ impl Dataset {
} }
} }
#[cfg(feature = "rdf-star")]
fn hash_triple( fn hash_triple(
&self, &self,
triple: &InternedTriple, triple: &InternedTriple,
@ -738,24 +748,42 @@ impl Dataset {
( (
if let InternedSubject::BlankNode(bnode) = s { if let InternedSubject::BlankNode(bnode) = s {
InternedSubject::BlankNode(self.map_bnode(bnode, hashes)) InternedSubject::BlankNode(self.map_bnode(bnode, hashes))
} else if let InternedSubject::Triple(triple) = s {
InternedSubject::Triple(Box::new(InternedTriple::encoded_into(
self.label_triple(&triple, hashes).as_ref(),
&mut self.interner,
)))
} else { } else {
s #[cfg(feature = "rdf-star")]
{
if let InternedSubject::Triple(triple) = s {
InternedSubject::Triple(Box::new(InternedTriple::encoded_into(
self.label_triple(&triple, hashes).as_ref(),
&mut self.interner,
)))
} else {
s
}
}
#[cfg(not(feature = "rdf-star"))]
{
s
}
}, },
p, p,
if let InternedTerm::BlankNode(bnode) = o { if let InternedTerm::BlankNode(bnode) = o {
InternedTerm::BlankNode(self.map_bnode(bnode, hashes)) InternedTerm::BlankNode(self.map_bnode(bnode, hashes))
} else if let InternedTerm::Triple(triple) = o {
InternedTerm::Triple(Box::new(InternedTriple::encoded_into(
self.label_triple(&triple, hashes).as_ref(),
&mut self.interner,
)))
} else { } else {
o #[cfg(feature = "rdf-star")]
{
if let InternedTerm::Triple(triple) = o {
InternedTerm::Triple(Box::new(InternedTriple::encoded_into(
self.label_triple(&triple, hashes).as_ref(),
&mut self.interner,
)))
} else {
o
}
}
#[cfg(not(feature = "rdf-star"))]
{
o
}
}, },
if let InternedGraphName::BlankNode(bnode) = g { if let InternedGraphName::BlankNode(bnode) = g {
InternedGraphName::BlankNode(self.map_bnode(bnode, hashes)) InternedGraphName::BlankNode(self.map_bnode(bnode, hashes))
@ -769,6 +797,7 @@ impl Dataset {
quads quads
} }
#[cfg(feature = "rdf-star")]
fn label_triple( fn label_triple(
&mut self, &mut self,
triple: &InternedTriple, triple: &InternedTriple,

@ -7,6 +7,7 @@ use std::collections::HashMap;
#[derive(Debug, Default)] #[derive(Debug, Default)]
pub struct Interner { pub struct Interner {
strings: Rodeo, strings: Rodeo,
#[cfg(feature = "rdf-star")]
triples: HashMap<InternedTriple, Triple>, triples: HashMap<InternedTriple, Triple>,
} }
@ -175,6 +176,7 @@ impl InternedLiteral {
pub enum InternedSubject { pub enum InternedSubject {
NamedNode(InternedNamedNode), NamedNode(InternedNamedNode),
BlankNode(InternedBlankNode), BlankNode(InternedBlankNode),
#[cfg(feature = "rdf-star")]
Triple(Box<InternedTriple>), Triple(Box<InternedTriple>),
} }
@ -187,6 +189,7 @@ impl InternedSubject {
SubjectRef::BlankNode(node) => { SubjectRef::BlankNode(node) => {
Self::BlankNode(InternedBlankNode::encoded_into(node, interner)) Self::BlankNode(InternedBlankNode::encoded_into(node, interner))
} }
#[cfg(feature = "rdf-star")]
SubjectRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_into( SubjectRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_into(
triple.as_ref(), triple.as_ref(),
interner, interner,
@ -202,6 +205,7 @@ impl InternedSubject {
SubjectRef::BlankNode(node) => { SubjectRef::BlankNode(node) => {
Self::BlankNode(InternedBlankNode::encoded_from(node, interner)?) Self::BlankNode(InternedBlankNode::encoded_from(node, interner)?)
} }
#[cfg(feature = "rdf-star")]
SubjectRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_from( SubjectRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_from(
triple.as_ref(), triple.as_ref(),
interner, interner,
@ -213,6 +217,7 @@ impl InternedSubject {
match self { match self {
Self::NamedNode(node) => SubjectRef::NamedNode(node.decode_from(interner)), Self::NamedNode(node) => SubjectRef::NamedNode(node.decode_from(interner)),
Self::BlankNode(node) => SubjectRef::BlankNode(node.decode_from(interner)), Self::BlankNode(node) => SubjectRef::BlankNode(node.decode_from(interner)),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => SubjectRef::Triple(&interner.triples[triple.as_ref()]), Self::Triple(triple) => SubjectRef::Triple(&interner.triples[triple.as_ref()]),
} }
} }
@ -225,6 +230,7 @@ impl InternedSubject {
match self { match self {
Self::NamedNode(node) => Self::NamedNode(node.next()), Self::NamedNode(node) => Self::NamedNode(node.next()),
Self::BlankNode(node) => Self::BlankNode(node.next()), Self::BlankNode(node) => Self::BlankNode(node.next()),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => Self::Triple(Box::new(triple.next())), Self::Triple(triple) => Self::Triple(Box::new(triple.next())),
} }
} }
@ -296,6 +302,7 @@ pub enum InternedTerm {
NamedNode(InternedNamedNode), NamedNode(InternedNamedNode),
BlankNode(InternedBlankNode), BlankNode(InternedBlankNode),
Literal(InternedLiteral), Literal(InternedLiteral),
#[cfg(feature = "rdf-star")]
Triple(Box<InternedTriple>), Triple(Box<InternedTriple>),
} }
@ -309,6 +316,7 @@ impl InternedTerm {
Self::BlankNode(InternedBlankNode::encoded_into(term, interner)) Self::BlankNode(InternedBlankNode::encoded_into(term, interner))
} }
TermRef::Literal(term) => Self::Literal(InternedLiteral::encoded_into(term, interner)), TermRef::Literal(term) => Self::Literal(InternedLiteral::encoded_into(term, interner)),
#[cfg(feature = "rdf-star")]
TermRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_into( TermRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_into(
triple.as_ref(), triple.as_ref(),
interner, interner,
@ -325,6 +333,7 @@ impl InternedTerm {
Self::BlankNode(InternedBlankNode::encoded_from(term, interner)?) Self::BlankNode(InternedBlankNode::encoded_from(term, interner)?)
} }
TermRef::Literal(term) => Self::Literal(InternedLiteral::encoded_from(term, interner)?), TermRef::Literal(term) => Self::Literal(InternedLiteral::encoded_from(term, interner)?),
#[cfg(feature = "rdf-star")]
TermRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_from( TermRef::Triple(triple) => Self::Triple(Box::new(InternedTriple::encoded_from(
triple.as_ref(), triple.as_ref(),
interner, interner,
@ -337,6 +346,7 @@ impl InternedTerm {
Self::NamedNode(term) => TermRef::NamedNode(term.decode_from(interner)), Self::NamedNode(term) => TermRef::NamedNode(term.decode_from(interner)),
Self::BlankNode(term) => TermRef::BlankNode(term.decode_from(interner)), Self::BlankNode(term) => TermRef::BlankNode(term.decode_from(interner)),
Self::Literal(term) => TermRef::Literal(term.decode_from(interner)), Self::Literal(term) => TermRef::Literal(term.decode_from(interner)),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => TermRef::Triple(&interner.triples[triple.as_ref()]), Self::Triple(triple) => TermRef::Triple(&interner.triples[triple.as_ref()]),
} }
} }
@ -350,6 +360,7 @@ impl InternedTerm {
Self::NamedNode(node) => Self::NamedNode(node.next()), Self::NamedNode(node) => Self::NamedNode(node.next()),
Self::BlankNode(node) => Self::BlankNode(node.next()), Self::BlankNode(node) => Self::BlankNode(node.next()),
Self::Literal(node) => Self::Literal(node.next()), Self::Literal(node) => Self::Literal(node.next()),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => Self::Triple(Box::new(triple.next())), Self::Triple(triple) => Self::Triple(Box::new(triple.next())),
} }
} }
@ -366,6 +377,7 @@ pub struct InternedTriple {
pub object: InternedTerm, pub object: InternedTerm,
} }
#[cfg(feature = "rdf-star")]
impl InternedTriple { impl InternedTriple {
pub fn encoded_into(triple: TripleRef<'_>, interner: &mut Interner) -> Self { pub fn encoded_into(triple: TripleRef<'_>, interner: &mut Interner) -> Self {
let interned_triple = Self { let interned_triple = Self {

@ -2,6 +2,8 @@
//! //!
//! This crate is intended to be a basic building block of other crates like [Oxigraph](https://crates.io/crates/oxigraph) or [Spargebra](https://crates.io/crates/spargebra). //! This crate is intended to be a basic building block of other crates like [Oxigraph](https://crates.io/crates/oxigraph) or [Spargebra](https://crates.io/crates/spargebra).
//! //!
//! Support for [RDF-star](https://w3c.github.io/rdf-star/cg-spec/) is available behind the `rdf-star` feature.
//!
//! Inspired by [RDF/JS](https://rdf.js.org/data-model-spec/) and [Apache Commons RDF](http://commons.apache.org/proper/commons-rdf/). //! Inspired by [RDF/JS](https://rdf.js.org/data-model-spec/) and [Apache Commons RDF](http://commons.apache.org/proper/commons-rdf/).
//! //!
//! Usage example: //! Usage example:

@ -301,24 +301,31 @@ fn read_term(s: &str) -> Result<(Term, &str), TermParseError> {
let (object, remain) = read_term(remain)?; let (object, remain) = read_term(remain)?;
let remain = remain.trim_start(); let remain = remain.trim_start();
if let Some(remain) = remain.strip_prefix(">>") { if let Some(remain) = remain.strip_prefix(">>") {
Ok(( #[cfg(feature = "rdf-star")]
Triple { {
subject: match subject { Ok((
Term::NamedNode(s) => s.into(), Triple {
Term::BlankNode(s) => s.into(), subject: match subject {
Term::Literal(_) => { Term::NamedNode(s) => s.into(),
return Err(TermParseError::msg( Term::BlankNode(s) => s.into(),
"Literals are not allowed in subject position", Term::Literal(_) => {
)) return Err(TermParseError::msg(
} "Literals are not allowed in subject position",
Term::Triple(s) => Subject::Triple(s), ))
}, }
predicate, Term::Triple(s) => Subject::Triple(s),
object, },
} predicate,
.into(), object,
remain, }
)) .into(),
remain,
))
}
#[cfg(not(feature = "rdf-star"))]
{
Err(TermParseError::msg("RDF-star is not supported"))
}
} else { } else {
Err(TermParseError::msg( Err(TermParseError::msg(
"Nested triple serialization should be enclosed between << and >>", "Nested triple serialization should be enclosed between << and >>",

@ -157,6 +157,7 @@ impl<'a> From<NamedOrBlankNodeRef<'a>> for NamedOrBlankNode {
pub enum Subject { pub enum Subject {
NamedNode(NamedNode), NamedNode(NamedNode),
BlankNode(BlankNode), BlankNode(BlankNode),
#[cfg(feature = "rdf-star")]
Triple(Arc<Triple>), Triple(Arc<Triple>),
} }
@ -171,6 +172,7 @@ impl Subject {
self.as_ref().is_blank_node() self.as_ref().is_blank_node()
} }
#[cfg(feature = "rdf-star")]
#[inline] #[inline]
pub fn is_triple(&self) -> bool { pub fn is_triple(&self) -> bool {
self.as_ref().is_triple() self.as_ref().is_triple()
@ -181,6 +183,7 @@ impl Subject {
match self { match self {
Self::NamedNode(node) => SubjectRef::NamedNode(node.as_ref()), Self::NamedNode(node) => SubjectRef::NamedNode(node.as_ref()),
Self::BlankNode(node) => SubjectRef::BlankNode(node.as_ref()), Self::BlankNode(node) => SubjectRef::BlankNode(node.as_ref()),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => SubjectRef::Triple(triple), Self::Triple(triple) => SubjectRef::Triple(triple),
} }
} }
@ -221,6 +224,7 @@ impl From<BlankNodeRef<'_>> for Subject {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<Triple> for Subject { impl From<Triple> for Subject {
#[inline] #[inline]
fn from(node: Triple) -> Self { fn from(node: Triple) -> Self {
@ -228,6 +232,7 @@ impl From<Triple> for Subject {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<Arc<Triple>> for Subject { impl From<Arc<Triple>> for Subject {
#[inline] #[inline]
fn from(node: Arc<Triple>) -> Self { fn from(node: Arc<Triple>) -> Self {
@ -235,6 +240,7 @@ impl From<Arc<Triple>> for Subject {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<Box<Triple>> for Subject { impl From<Box<Triple>> for Subject {
#[inline] #[inline]
fn from(node: Box<Triple>) -> Self { fn from(node: Box<Triple>) -> Self {
@ -242,6 +248,7 @@ impl From<Box<Triple>> for Subject {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<TripleRef<'_>> for Subject { impl From<TripleRef<'_>> for Subject {
#[inline] #[inline]
fn from(node: TripleRef<'_>) -> Self { fn from(node: TripleRef<'_>) -> Self {
@ -271,6 +278,7 @@ impl From<NamedOrBlankNodeRef<'_>> for Subject {
pub enum SubjectRef<'a> { pub enum SubjectRef<'a> {
NamedNode(NamedNodeRef<'a>), NamedNode(NamedNodeRef<'a>),
BlankNode(BlankNodeRef<'a>), BlankNode(BlankNodeRef<'a>),
#[cfg(feature = "rdf-star")]
Triple(&'a Triple), Triple(&'a Triple),
} }
@ -285,6 +293,7 @@ impl<'a> SubjectRef<'a> {
matches!(self, Self::BlankNode(_)) matches!(self, Self::BlankNode(_))
} }
#[cfg(feature = "rdf-star")]
#[inline] #[inline]
pub fn is_triple(&self) -> bool { pub fn is_triple(&self) -> bool {
matches!(self, Self::Triple(_)) matches!(self, Self::Triple(_))
@ -295,6 +304,7 @@ impl<'a> SubjectRef<'a> {
match self { match self {
Self::NamedNode(node) => Subject::NamedNode(node.into_owned()), Self::NamedNode(node) => Subject::NamedNode(node.into_owned()),
Self::BlankNode(node) => Subject::BlankNode(node.into_owned()), Self::BlankNode(node) => Subject::BlankNode(node.into_owned()),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => Subject::Triple(Arc::new(triple.clone())), Self::Triple(triple) => Subject::Triple(Arc::new(triple.clone())),
} }
} }
@ -306,6 +316,7 @@ impl fmt::Display for SubjectRef<'_> {
match self { match self {
Self::NamedNode(node) => node.fmt(f), Self::NamedNode(node) => node.fmt(f),
Self::BlankNode(node) => node.fmt(f), Self::BlankNode(node) => node.fmt(f),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => write!(f, "<<{}>>", triple), Self::Triple(triple) => write!(f, "<<{}>>", triple),
} }
} }
@ -339,6 +350,7 @@ impl<'a> From<&'a BlankNode> for SubjectRef<'a> {
} }
} }
#[cfg(feature = "rdf-star")]
impl<'a> From<&'a Triple> for SubjectRef<'a> { impl<'a> From<&'a Triple> for SubjectRef<'a> {
#[inline] #[inline]
fn from(node: &'a Triple) -> Self { fn from(node: &'a Triple) -> Self {
@ -384,6 +396,7 @@ pub enum Term {
NamedNode(NamedNode), NamedNode(NamedNode),
BlankNode(BlankNode), BlankNode(BlankNode),
Literal(Literal), Literal(Literal),
#[cfg(feature = "rdf-star")]
Triple(Arc<Triple>), Triple(Arc<Triple>),
} }
@ -403,6 +416,7 @@ impl Term {
self.as_ref().is_literal() self.as_ref().is_literal()
} }
#[cfg(feature = "rdf-star")]
#[inline] #[inline]
pub fn is_triple(&self) -> bool { pub fn is_triple(&self) -> bool {
self.as_ref().is_triple() self.as_ref().is_triple()
@ -414,6 +428,7 @@ impl Term {
Self::NamedNode(node) => TermRef::NamedNode(node.as_ref()), Self::NamedNode(node) => TermRef::NamedNode(node.as_ref()),
Self::BlankNode(node) => TermRef::BlankNode(node.as_ref()), Self::BlankNode(node) => TermRef::BlankNode(node.as_ref()),
Self::Literal(literal) => TermRef::Literal(literal.as_ref()), Self::Literal(literal) => TermRef::Literal(literal.as_ref()),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => TermRef::Triple(triple), Self::Triple(triple) => TermRef::Triple(triple),
} }
} }
@ -468,6 +483,7 @@ impl From<LiteralRef<'_>> for Term {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<Triple> for Term { impl From<Triple> for Term {
#[inline] #[inline]
fn from(triple: Triple) -> Self { fn from(triple: Triple) -> Self {
@ -475,6 +491,7 @@ impl From<Triple> for Term {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<Arc<Triple>> for Term { impl From<Arc<Triple>> for Term {
#[inline] #[inline]
fn from(node: Arc<Triple>) -> Self { fn from(node: Arc<Triple>) -> Self {
@ -482,6 +499,7 @@ impl From<Arc<Triple>> for Term {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<Box<Triple>> for Term { impl From<Box<Triple>> for Term {
#[inline] #[inline]
fn from(node: Box<Triple>) -> Self { fn from(node: Box<Triple>) -> Self {
@ -489,6 +507,7 @@ impl From<Box<Triple>> for Term {
} }
} }
#[cfg(feature = "rdf-star")]
impl From<TripleRef<'_>> for Term { impl From<TripleRef<'_>> for Term {
#[inline] #[inline]
fn from(triple: TripleRef<'_>) -> Self { fn from(triple: TripleRef<'_>) -> Self {
@ -519,6 +538,7 @@ impl From<Subject> for Term {
match node { match node {
Subject::NamedNode(node) => node.into(), Subject::NamedNode(node) => node.into(),
Subject::BlankNode(node) => node.into(), Subject::BlankNode(node) => node.into(),
#[cfg(feature = "rdf-star")]
Subject::Triple(triple) => Self::Triple(triple), Subject::Triple(triple) => Self::Triple(triple),
} }
} }
@ -538,6 +558,7 @@ pub enum TermRef<'a> {
NamedNode(NamedNodeRef<'a>), NamedNode(NamedNodeRef<'a>),
BlankNode(BlankNodeRef<'a>), BlankNode(BlankNodeRef<'a>),
Literal(LiteralRef<'a>), Literal(LiteralRef<'a>),
#[cfg(feature = "rdf-star")]
Triple(&'a Triple), Triple(&'a Triple),
} }
@ -557,6 +578,7 @@ impl<'a> TermRef<'a> {
matches!(self, Self::Literal(_)) matches!(self, Self::Literal(_))
} }
#[cfg(feature = "rdf-star")]
#[inline] #[inline]
pub fn is_triple(&self) -> bool { pub fn is_triple(&self) -> bool {
matches!(self, Self::Triple(_)) matches!(self, Self::Triple(_))
@ -568,6 +590,7 @@ impl<'a> TermRef<'a> {
Self::NamedNode(node) => Term::NamedNode(node.into_owned()), Self::NamedNode(node) => Term::NamedNode(node.into_owned()),
Self::BlankNode(node) => Term::BlankNode(node.into_owned()), Self::BlankNode(node) => Term::BlankNode(node.into_owned()),
Self::Literal(literal) => Term::Literal(literal.into_owned()), Self::Literal(literal) => Term::Literal(literal.into_owned()),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => Term::Triple(Arc::new(triple.clone())), Self::Triple(triple) => Term::Triple(Arc::new(triple.clone())),
} }
} }
@ -580,6 +603,7 @@ impl fmt::Display for TermRef<'_> {
Self::NamedNode(node) => node.fmt(f), Self::NamedNode(node) => node.fmt(f),
Self::BlankNode(node) => node.fmt(f), Self::BlankNode(node) => node.fmt(f),
Self::Literal(literal) => literal.fmt(f), Self::Literal(literal) => literal.fmt(f),
#[cfg(feature = "rdf-star")]
Self::Triple(triple) => { Self::Triple(triple) => {
write!(f, "<<{}>>", triple) write!(f, "<<{}>>", triple)
} }
@ -629,6 +653,7 @@ impl<'a> From<&'a Literal> for TermRef<'a> {
} }
} }
#[cfg(feature = "rdf-star")]
impl<'a> From<&'a Triple> for TermRef<'a> { impl<'a> From<&'a Triple> for TermRef<'a> {
#[inline] #[inline]
fn from(node: &'a Triple) -> Self { fn from(node: &'a Triple) -> Self {
@ -659,6 +684,7 @@ impl<'a> From<SubjectRef<'a>> for TermRef<'a> {
match node { match node {
SubjectRef::NamedNode(node) => node.into(), SubjectRef::NamedNode(node) => node.into(),
SubjectRef::BlankNode(node) => node.into(), SubjectRef::BlankNode(node) => node.into(),
#[cfg(feature = "rdf-star")]
SubjectRef::Triple(triple) => triple.into(), SubjectRef::Triple(triple) => triple.into(),
} }
} }

Loading…
Cancel
Save