private void writeNode(RDFNode node) throws IOException {
Node n = node.asNode();
if (n.isURI()) {
write(" <uri>" + escape(n.getURI()) + "</uri>\n");
return;
}
if (n.isBlank()) {
write(" <id>" + escape(n.getBlankNodeId().toString()) + "</id>\n");
return;
}
if (!n.isLiteral()) {
throw new JenaException("Don't know how to serialize node " + n);
}
if (n.getLiteral().getDatatypeURI() != null) {
write(
" <typedLiteral datatype=\""
+ escape(n.getLiteral().getDatatypeURI())
+ "\">"
+ escape(n.getLiteral().getLexicalForm())
+ "</typedLiteral>\n");
return;
}
if (n.getLiteral().language() == null || "".equals(n.getLiteral().language())) {
write(" <plainLiteral>" + escape(n.getLiteral().getLexicalForm()) + "</plainLiteral>\n");
return;
}
write(
" <plainLiteral xml:lang=\""
+ n.getLiteral().language()
+ "\">"
+ escape(n.getLiteral().getLexicalForm())
+ "</plainLiteral>\n");
}
public SPDXChecksum(Model spdxModel, Node checksumNode) throws InvalidSPDXAnalysisException {
this.model = spdxModel;
this.checksumNode = checksumNode;
if (checksumNode.isBlank()) {
checksumResource = model.createResource(checksumNode.getBlankNodeId());
} else if (checksumNode.isURI()) {
checksumResource = model.createResource(checksumNode.getURI());
} else {
throw (new InvalidSPDXAnalysisException("Checksum node can not be a literal"));
}
// Algorithm
Node p =
spdxModel
.getProperty(SpdxRdfConstants.SPDX_NAMESPACE, SpdxRdfConstants.PROP_CHECKSUM_ALGORITHM)
.asNode();
Triple m = Triple.createMatch(checksumNode, p, null);
ExtendedIterator<Triple> tripleIter = spdxModel.getGraph().find(m);
while (tripleIter.hasNext()) {
Triple t = tripleIter.next();
if (t.getObject().isLiteral()) {
// The following is for compatibility with rdf generated with older
// versions of the tool
this.algorithm = t.getObject().toString(false);
} else if (t.getObject().isURI()) {
this.algorithm = URI_TO_ALGORITHM.get(t.getObject().getURI());
if (this.algorithm == null) {
this.algorithm = "UNKNOWN";
}
} else {
throw (new InvalidSPDXAnalysisException(
"Invalid checksum algorithm - must be one of the defined algorithms supported by SPDX."));
}
}
// value
p =
spdxModel
.getProperty(SpdxRdfConstants.SPDX_NAMESPACE, SpdxRdfConstants.PROP_CHECKSUM_VALUE)
.asNode();
m = Triple.createMatch(checksumNode, p, null);
tripleIter = spdxModel.getGraph().find(m);
while (tripleIter.hasNext()) {
Triple t = tripleIter.next();
this.value = t.getObject().toString(false);
}
}
/**
* Gets NXRelations node instance given Jena node.
*
* @param jenaNodeInst
* @return NXRelations node instance
*/
private Node getNXRelationsNode(com.hp.hpl.jena.graph.Node jenaNodeInst) {
if (jenaNodeInst == null) {
return null;
}
Node nuxNode = null;
if (jenaNodeInst.isBlank()) {
AnonId anonId = jenaNodeInst.getBlankNodeId();
String id = anonId.getLabelString();
nuxNode = NodeFactory.createBlank(id);
} else if (jenaNodeInst.isLiteral()) {
LiteralLabel label = jenaNodeInst.getLiteral();
String value = label.getLexicalForm();
String type = jenaNodeInst.getLiteralDatatypeURI();
String language = jenaNodeInst.getLiteralLanguage();
if (type != "") {
nuxNode = NodeFactory.createTypedLiteral(value, type);
} else if (language != "") {
nuxNode = NodeFactory.createLiteral(value, language);
} else {
nuxNode = NodeFactory.createLiteral(value);
}
} else if (jenaNodeInst.isURI()) {
String uri = jenaNodeInst.getURI();
// try to find corresponding prefix
// TODO AT: maybe take namespaces from relation service?
for (Map.Entry<String, String> ns : namespaces.entrySet()) {
String base = ns.getValue();
if (uri.startsWith(base)) {
String localName = uri.substring(base.length());
nuxNode = NodeFactory.createQNameResource(base, localName);
break;
}
}
if (nuxNode == null) {
// default to resource
nuxNode = NodeFactory.createResource(uri);
}
} else {
throw new IllegalArgumentException(
"Cannot translate non concrete Jena node into NXRelations node");
}
return nuxNode;
}
