public static String nodeToLex(Node node) { if ( node.isURI() ) return node.getURI() ; if ( node.isLiteral() ) return node.getLiteralLexicalForm() ; if ( node.isBlank() ) return node.getBlankNodeId().getLabelString() ; throw new SDBException("Can't create lexical representation for "+node) ; }
private static boolean isBnodeTypeQuery(final Triple t) { return t.getSubject().isBlank() && t.getPredicate().equals(RDF.type.asNode()) && (BuiltinTerm.find(t.getObject()) == null || t.getObject().equals(OWL.Thing.asNode()) || t.getObject().equals(OWL.Nothing.asNode())); }
public static void addVar(Collection<Var> acc, Node n) { if (n == null) return ; if (n.isVariable()) acc.add(Var.alloc(n)) ; }
static GraphTraversal<?, ?> transform(final Triple triple) { final GraphTraversal<Vertex, ?> matchTraversal = __.as(triple.getSubject().getName()); final Node predicate = triple.getPredicate(); final String uri = predicate.getURI(); final String uriValue = Prefixes.getURIValue(uri); final String prefix = Prefixes.getPrefix(uri); switch (prefix) { case "edge": return matchTraversal.out(uriValue).as(triple.getObject().getName()); case "property": return matchProperty(matchTraversal, uriValue, PropertyType.PROPERTY, triple.getObject()); case "value": return matchProperty(matchTraversal, uriValue, PropertyType.VALUE, triple.getObject()); default: throw new IllegalStateException(String.format("Unexpected predicate: %s", predicate)); } }
private static String simpleLiteralOrXSDString(Node n) { if ( !n.isLiteral() ) return null ; if ( n.getLiteralDatatype() == null ) { if ( n.getLiteralLanguage().equals("") ) return n.getLiteralLexicalForm() ; } else if ( n.getLiteralDatatype().equals(XSDDatatype.XSDstring) ) return n.getLiteralLexicalForm() ; return null ; }
protected static boolean equalsObjectOK( Triple t ) { Node o = t.getObject(); return o.isLiteral() ? o.getLiteralDatatype() == null : true; }
@Override protected final boolean accepts(TKey key, TripleWritable tuple) { Triple t = tuple.get(); return (t.getSubject().isURI() || t.getSubject().isBlank()) && t.getPredicate().isURI() && (t.getObject().isURI() || t.getObject().isBlank() || t.getObject().isLiteral()); }
public String getComment() { if (this.model != null && this.resource != null) { Node p = model.getProperty(SpdxRdfConstants.RDFS_NAMESPACE, SpdxRdfConstants.RDFS_PROP_COMMENT).asNode(); Triple m = Triple.createMatch(this.resource.asNode(), p, null); ExtendedIterator<Triple> tripleIter = model.getGraph().find(m); while (tripleIter.hasNext()) { this.comment = tripleIter.next().getObject().toString(false); } } return this.comment; }
public void testURIs() { assertFalse( "URI nodes aren't blank", NodeFactory.createURI( U ).isBlank() ); assertFalse( "URI nodes aren't literal", NodeFactory.createURI( U ).isLiteral() ); assertFalse( "URI nodes aren't variables", NodeFactory.createURI( U ).isVariable() ); assertTrue( "URI nodes are URIs", NodeFactory.createURI( U ).isURI() ); assertEquals( "URI nodes preserve URI", NodeFactory.createURI( U ).getURI(), U ); }
@Override public ExtendedIterator<Triple> find( Node s, Node p, Node o ) { return SimpleEventManager.notifyingRemove( this, base.find( s, p, o ).filterDrop( t -> t.getSubject().isLiteral() || t.getPredicate().isBlank() || t.getPredicate().isLiteral() ) ); }
public void testBlanks() { assertTrue( "anonymous nodes are blank", NodeFactory.createBlankNode().isBlank() ); assertFalse( "anonymous nodes aren't literal", NodeFactory.createBlankNode().isLiteral() ); assertFalse( "anonymous nodes aren't URIs", NodeFactory.createBlankNode().isURI() ); assertFalse( "anonymous nodes aren't variables", NodeFactory.createBlankNode().isVariable() ); assertEquals( "anonymous nodes have the right id", NodeFactory.createBlankNode(A).getBlankNodeId(), A ); }
public boolean check(Node node, long line, long col) { // NodeVisitor? if ( node.isURI() ) return checkIRI(node, line, col) ; else if ( node.isBlank() ) return checkBlank(node, line, col) ; else if ( node.isLiteral() ) return checkLiteral(node, line, col) ; else if ( node.isVariable() ) return checkVar(node, line, col) ; handler.warning("Not a recognized node: ", line, col) ; return false ; }
@Test public void binaryThrift() { Triple t = Triple.create(n(":s"), n(":p"), NodeFactory.createBlankNode("ABCD")); Node obj = t.getObject(); Graph graph = Factory.createDefaultGraph(); graph.add(t); ByteArrayOutputStream bout = new ByteArrayOutputStream(); RDFDataMgr.write(bout, graph, Lang.RDFTHRIFT); ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); Graph graph1 = Factory.createDefaultGraph(); RDFDataMgr.read(graph1, bin, Lang.RDFTHRIFT); Node obj1 = graph1.find().next().getObject(); assertEquals(obj, obj1); assertTrue(obj1.isBlank()); assertEquals(obj.getBlankNodeLabel(), obj1.getBlankNodeLabel()); }
private static boolean exactlyOne(Graph graph, Node n, Node predicate, Node object) { ExtendedIterator<Triple> iter = graph.find(n, predicate, Node.ANY) ; try { if ( ! iter.hasNext() ) return false ; while (iter.hasNext()) { Node obj = iter.next().getObject() ; if ( ! obj.equals(object) ) return false ; } return true ; } finally { iter.close() ; } }
public void testLiterals() { assertFalse( "literal nodes aren't blank", NodeFactory.createLiteral( L ).isBlank() ); assertTrue( "literal nodes are literal", NodeFactory.createLiteral( L ).isLiteral() ); assertFalse( "literal nodes aren't variables", NodeFactory.createLiteral( L ).isVariable() ); assertFalse( "literal nodes aren't URIs", NodeFactory.createLiteral( L ).isURI() ); assertEquals( "literal nodes preserve value", NodeFactory.createLiteral( L ).getLiteral(), L ); }
@Override public ExtendedIterator<Triple> find(Node subject, Node predicate, Node object) { List<Triple> nbTripList = new ArrayList<Triple>(); ExtendedIterator<Triple> triples = graph.find(subject, predicate, object); while (triples.hasNext()) { Triple triple = triples.next(); if (!triple.getSubject().isBlank() && !triple.getObject().isBlank()) { nbTripList.add(triple); } } return WrappedIterator.create(nbTripList.iterator()); }
/** * Validate a triple add to see if it should reinvoke the hook. If so * then the inference will be restarted at next prepare time. Incremental * re-processing is not yet supported. */ @Override public boolean needsRerun(FBRuleInfGraph infGraph, Triple t) { return (t.getPredicate().equals(OWL.intersectionOf.asNode())); }
public static String str(Node node) { if ( node.isLiteral() ) return node.getLiteral().getLexicalForm() ; if ( node.isURI() ) return node.getURI() ; // if ( node.isBlank() ) return node.getBlankNodeId().getLabelString() ; // if ( node.isBlank() ) return "" ; if ( node.isBlank() ) NodeValue.raise(new ExprTypeException("Blank node: " + node)) ; NodeValue.raise(new ExprEvalException("Not a string: " + node)) ; return "[undef]" ; }
@Override public boolean evaluate(final Object principal, final Action action, final Node graphIRI, final Triple triple) { if (triple.getSubject().isURI() && triple.getSubject().getURI().equals("http://example.com/resource/1")) { return false; } return super.evaluate(principal, action, graphIRI, triple); }
@Override protected void check(Triple t) { if ( Var.isVar(getGraph()) ) throw new QueryParseException("Variables not permitted in data quad", -1, -1) ; if ( Var.isVar(t.getSubject()) || Var.isVar(t.getPredicate()) || Var.isVar(t.getObject())) throw new QueryParseException("Variables not permitted in data quad", -1, -1) ; if ( t.getSubject().isLiteral() ) throw new QueryParseException("Literals not allowed as subjects in data", -1, -1) ; }