org.apache.commons.rdf.jena.impl.AbstractQuadLike Maven / Gradle / Ivy
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.rdf.jena.impl;
import java.util.Objects;
import java.util.Optional;
import java.util.UUID;
import org.apache.commons.rdf.api.QuadLike;
import org.apache.commons.rdf.api.RDFTerm;
import org.apache.commons.rdf.jena.JenaQuad;
import org.apache.commons.rdf.jena.JenaQuadLike;
import org.apache.commons.rdf.jena.JenaRDF;
import org.apache.commons.rdf.jena.JenaRDFTerm;
import org.apache.commons.rdf.jena.JenaTriple;
import org.apache.jena.graph.Triple;
import org.apache.jena.sparql.core.Quad;
/**
* A generalized {@link QuadLike}, backed by a Jena {@link Quad} or
* {@link Triple}.
*
* This class does not implement any particular {@link #equals(Object)} or
* {@link #hashCode()} but can otherwise be used as a base class for both a
* {@link JenaTriple} and a {@link JenaQuad}.
*
* @see JenaTripleImpl
* @see JenaQuadImpl
* @see internalJenaFactory#createGeneralizedTriple(RDFTerm, RDFTerm, RDFTerm)
* @see internalJenaFactory#createGeneralizedQuad(RDFTerm, RDFTerm, RDFTerm,
* RDFTerm)
*
*/
abstract class AbstractQuadLike
implements JenaQuadLike {
private static InternalJenaFactory internalJenaFactory = new InternalJenaFactory() {
};
/**
* COMMONSRDF-55 - special handling of urn:x-arq:DefaultGraph and friends
*
* This can recognize and
* from any IRI instance, so they can be
* replaced with Optional.empty(). Note that this code does not hardcode the
* internal Jena IRIs but uses Jena's constants {@link Quad#defaultGraphIRI}
* and {@link Quad#defaultGraphNodeGenerated}.
*/
private static class DefaultGraphChecker {
// Fixed UUID for comparison of defaultGraphNodeGenerated
private final UUID salt = UUID.fromString("aaa6bf96-ea58-4a55-9485-3733403a1f24");
private final RDFTerm defaultGraph = internalJenaFactory.createRDFTerm(Quad.defaultGraphIRI, salt);
private final RDFTerm defaultGraphNodeGenerated = internalJenaFactory.createRDFTerm(Quad.defaultGraphNodeGenerated, salt);
/**
* Check if RDFTerm is an IRI that matches the two Jena default graph
* constants (Even if they are from another RDF implementation).
*
* This checker is "softer" than {@link #isNotDefaultGraphJenaNode(RDFTerm)}
*
* @param graphName
* potential graph name IRI or BlankNode
* @return true if the RDFTerm does not indicate a default
* graph in Jena
*/
public boolean isNotDefaultGraph(final RDFTerm graphName) {
return !(graphName.equals(defaultGraph) || graphName.equals(defaultGraphNodeGenerated));
}
/**
* Check if RDFTerm has an IRI that matches the two Jena default graph
* constants (but only if it is an JenaRDFTerm instance)
*
* @param graphName
* potential graph name IRI or BlankNode
* @return true if the RDFTerm does not indicate a default
* graph in Jena
*/
public boolean isNotDefaultGraphJenaNode(final RDFTerm graphName) {
return ! (graphName instanceof JenaRDFTerm) ||
! Quad.isDefaultGraph(((JenaRDFTerm)graphName).asJenaNode());
}
}
private static DefaultGraphChecker defaultGraphChecker = new DefaultGraphChecker();
final Optional graphName;
final S subject;
final P predicate;
final O object;
org.apache.jena.sparql.core.Quad quad = null;
org.apache.jena.graph.Triple triple = null;
AbstractQuadLike(final S subject, final P predicate, final O object, final Optional graphName) {
this.subject = Objects.requireNonNull(subject);
this.predicate = Objects.requireNonNull(predicate);
this.object = Objects.requireNonNull(object);
// Enforce
this.graphName = Objects.requireNonNull(graphName).filter(defaultGraphChecker::isNotDefaultGraphJenaNode);
}
AbstractQuadLike(final S subject, final P predicate, final O object) {
this(subject, predicate, object, Optional.empty());
}
@SuppressWarnings("unchecked")
AbstractQuadLike(final org.apache.jena.sparql.core.Quad quad, final UUID salt) {
this.quad = Objects.requireNonNull(quad);
this.subject = (S) internalJenaFactory.createRDFTerm(quad.getSubject(), salt);
this.predicate = (P) internalJenaFactory.createRDFTerm(quad.getPredicate(), salt);
this.object = (O) internalJenaFactory.createRDFTerm(quad.getObject(), salt);
if (quad.isDefaultGraph()) {
this.graphName = Optional.empty();
} else {
this.graphName = Optional.of((G) internalJenaFactory.createRDFTerm(quad.getGraph(), salt));
}
}
@SuppressWarnings("unchecked")
AbstractQuadLike(final org.apache.jena.graph.Triple triple, final UUID salt) {
this.triple = Objects.requireNonNull(triple);
this.subject = (S) internalJenaFactory.createRDFTerm(triple.getSubject(), salt);
this.predicate = (P) internalJenaFactory.createRDFTerm(triple.getPredicate(), salt);
this.object = (O) internalJenaFactory.createRDFTerm(triple.getObject(), salt);
this.graphName = Optional.empty();
}
@Override
public org.apache.jena.sparql.core.Quad asJenaQuad() {
final JenaRDF factory = new JenaRDF();
if (quad == null) {
quad = org.apache.jena.sparql.core.Quad.create(
graphName.map(factory::asJenaNode).orElse(Quad.defaultGraphIRI),
factory.asJenaNode(subject),
factory.asJenaNode(predicate),
factory.asJenaNode(object));
}
return quad;
}
@Override
public org.apache.jena.graph.Triple asJenaTriple() {
final JenaRDF factory = new JenaRDF();
if (triple == null) {
triple = org.apache.jena.graph.Triple.create(
factory.asJenaNode(subject),
factory.asJenaNode(predicate),
factory.asJenaNode(object));
}
return triple;
}
@Override
public S getSubject() {
return subject;
}
@Override
public P getPredicate() {
return predicate;
}
@Override
public O getObject() {
return object;
}
@Override
public Optional getGraphName() {
return graphName;
}
@Override
public String toString() {
// kind of nquad syntax
return getSubject().ntriplesString() + " " + getPredicate().ntriplesString() + " "
+ getObject().ntriplesString() + " " + getGraphName().map(RDFTerm::ntriplesString).orElse("") + ".";
}
}