Refine search
public static Optional<Boolean> getBooleanValue(Model theGraph, Resource theSubj, IRI thePred) { Optional<Literal> aLitOpt = getLiteral(theGraph, theSubj, thePred); if (!aLitOpt.isPresent()) { return Optional.empty(); } else { Literal aLiteral = (Literal)aLitOpt.get(); return (aLiteral.getDatatype() == null || !aLiteral.getDatatype().equals(XMLSchema.BOOLEAN)) && !aLiteral.getLabel().equalsIgnoreCase("true") && !aLiteral.getLabel().equalsIgnoreCase("false") ? Optional.empty() : Optional.of(Boolean.valueOf(aLiteral.getLabel())); } }
public static String writeSubjectPredicate(final Statement statement) { Validate.notNull(statement); Validate.notNull(statement.getSubject()); Validate.notNull(statement.getPredicate()); return statement.getSubject().toString() + SEP + statement.getPredicate().toString(); }
@Override public boolean accepts(String range, Optional<KBObject> rangeKbObject) { if (rangeKbObject != null && rangeKbObject.isPresent()) { return true; } else if (range != null && range.equals(XMLSchema.STRING.stringValue())) { return true; } return false; }
private String shorten(IRI iri) { if (shortenUris) { String localName = iri.getLocalName(); String prefix = getPrefix(iri.getNamespace()); return prefix + PREFIX_SEPARATOR + localName; } else { return iri.stringValue(); } }
private StringBuilder appendValue(StringBuilder sb, Literal lit) { sb.append('"'); sb.append(lit.getLabel().replace("\"", "\\\"")); sb.append('"'); if (Literals.isLanguageLiteral(lit)) { sb.append('@'); sb.append(lit.getLanguage().get()); } else { sb.append("^^<"); sb.append(lit.getDatatype().stringValue()); sb.append('>'); } return sb; }
@Override public void handleStatement(Statement st) throws RDFHandlerException { Value object = st.getObject(); StreamedStatement statement = new StreamedStatement(st.getSubject().stringValue(), st.getPredicate().stringValue(), object.stringValue(), (object instanceof Literal), ((object instanceof Literal)? ((Literal) object).getDatatype().stringValue(): null), (object instanceof Literal ? ((Literal) object).getLanguage().orElse(null) : null)); statements.add(statement); }
@Override public TupleFunction parse(IRI funcUri, TripleSource store) throws RDF4JException { return functionRegistry.get(funcUri.stringValue()).orElse(null); } }
@Override protected Value evaluate(ValueFactory valueFactory, Value arg1, Value arg2) throws ValueExprEvaluationException { if (!(arg1 instanceof Literal)) { throw new ValueExprEvaluationException("First argument must be a literal"); } if (!(arg2 instanceof IRI)) { throw new ValueExprEvaluationException("Second argument must be a datatype"); } Literal value = (Literal)arg1; IRI targetDatatype = (IRI)arg2; Function func = FunctionRegistry.getInstance().get(targetDatatype.stringValue()).orElse(null); return (func != null) ? func.evaluate(valueFactory, value) : valueFactory.createLiteral(value.getLabel(), targetDatatype); } }
@Override public void statementAdded(Statement st) { if (RDFS.SUBCLASSOF.equals(st.getPredicate()) && st.getObject() instanceof Resource) { resetClasses(); } }
@Override protected boolean accept(Statement st) { //de-duplicate triples if (st.getSubject().equals(lastSubj) && st.getPredicate().equals(lastPred) && st.getObject().equals(lastObj)) { return false; } else { lastSubj = st.getSubject(); lastPred = st.getPredicate(); lastObj = st.getObject(); return true; } }
private void checkForSearchType(Value val) { if (HALYARD.SEARCH_TYPE.equals(val) ||((val instanceof Literal) && HALYARD.SEARCH_TYPE.equals(((Literal)val).getDatatype()))) { throw new IncompatibleOperationException(); } } @Override
private void getUsedNamespaces(Set<Statement> stmts, Set<String> used) { for (Statement st : stmts) { used.add(st.getPredicate().getNamespace()); if (st.getObject() instanceof IRI) { IRI uri = (IRI)st.getObject(); used.add(uri.getNamespace()); } else if (st.getObject() instanceof Literal) { Literal lit = (Literal)st.getObject(); if (lit.getDatatype() != null) { used.add(lit.getDatatype().getNamespace()); } } } }
private byte[] literal2legacy(Literal literal) throws IOException { IRI dt = literal.getDatatype(); if (XMLSchema.STRING.equals(dt) || RDF.LANGSTRING.equals(dt)) return literal2data(literal.getLabel(), literal.getLanguage(), null, false); return literal2data(literal.getLabel(), literal.getLanguage(), dt, false); }
private static Value makeValue(final String valueString, final IRI typeURI) { // Convert the String Value into a Value. if (typeURI.equals(XMLSchema.ANYURI)) { return VF.createIRI(valueString); } else { return VF.createLiteral(valueString, typeURI); } }
private Resource getResource(Model model) { Iterator<Statement> st = model.iterator(); while (st.hasNext()) { Statement s = st.next(); if ((s.getPredicate().equals(RDF.TYPE))) { if (isRootElement(s)) { return s.getSubject(); } } } return null; }
private static double parseTemporalDuration(ValueConstant valConst) { Value val = valConst.getValue(); Preconditions.checkArgument(val instanceof Literal); Literal literal = (Literal) val; String stringVal = literal.getLabel(); IRI dataType = literal.getDatatype(); Preconditions.checkArgument(dataType.equals(XMLSchema.DECIMAL) || dataType.equals(XMLSchema.DOUBLE) || dataType.equals(XMLSchema.FLOAT) || dataType.equals(XMLSchema.INTEGER) || dataType.equals(XMLSchema.INT)); return Double.parseDouble(stringVal); }
private Instant convertToInstant(Literal literal) { String stringVal = literal.getLabel(); IRI dataType = literal.getDatatype(); checkArgument(dataType.equals(XMLSchema.DATETIME) || dataType.equals(XMLSchema.DATE), String.format("Invalid data type for date time. Data Type must be of type %s or %s .", XMLSchema.DATETIME, XMLSchema.DATE)); checkArgument(XMLDatatypeUtil.isValidDateTime(stringVal) || XMLDatatypeUtil.isValidDate(stringVal), "Invalid date time value."); return literal.calendarValue().toGregorianCalendar().toInstant(); }
public IRI rewrite(final IRI original) { if (null == original) { return null; } else { String s = original.stringValue(); return s.startsWith(externalBaseURI) ? vf.createIRI(s.replace(externalBaseURI, internalBaseURI)) : original; } } };
/******************************************************************************************************************* * * ******************************************************************************************************************/ @Nonnull public static URL urlFor (final @Nonnull IRI uri) throws MalformedURLException { return new URL(uri.toString()); }
private void checkUpdatedStatement(Statement st) { IRI pred = st.getPredicate(); if (pred.equals(RDF.TYPE) || pred.equals(RDFS.SUBCLASSOF) || pred.equals(RDFS.SUBPROPERTYOF)) { updateNeeded = true; } }