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())); } }
private Object getObjectValue(Literal object) { IRI datatype = object.getDatatype(); if (datatype.equals(XMLSchema.INT) || datatype.equals(XMLSchema.INTEGER) || datatype.equals(XMLSchema.LONG)){ return object.longValue(); } else if (datatype.equals(XMLSchema.DECIMAL) || datatype.equals(XMLSchema.DOUBLE) || datatype.equals(XMLSchema.FLOAT)) { return object.doubleValue(); } else if (datatype.equals(XMLSchema.BOOLEAN)) { return object.booleanValue(); } else { // it's a string, and it can be tagged with language info. // if a language filter has been defined we apply it here final Optional<String> language = object.getLanguage(); if(langFilter == null || !language.isPresent() || (language.isPresent() && langFilter.equals(language.get()))){ return object.stringValue(); } return null; //string is filtered } }
private byte[] literal2data(Literal literal, boolean create) throws IOException { return literal2data(literal.getLabel(), literal.getLanguage(), literal.getDatatype(), create); }
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); }
public Literal evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException { if (args.length != 1) { throw new ValueExprEvaluationException("LCASE requires exactly 1 argument, got " + args.length); } if (args[0] instanceof Literal) { Literal literal = (Literal)args[0]; // LowerCase function accepts only string literals. if (QueryEvaluationUtil.isStringLiteral(literal)) { String lexicalValue = literal.getLabel().toLowerCase(); Optional<String> language = literal.getLanguage(); if (language.isPresent()) { return valueFactory.createLiteral(lexicalValue, language.get()); } else if (XMLSchema.STRING.equals(literal.getDatatype())) { return valueFactory.createLiteral(lexicalValue, XMLSchema.STRING); } else { return valueFactory.createLiteral(lexicalValue); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } }
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; }
private void writeLiteral(Literal literal) throws IOException { String label = literal.getLabel(); IRI datatype = literal.getDatatype(); if (Literals.isLanguageLiteral(literal)) { out.writeByte(LANG_LITERAL_VALUE); writeString(label); writeString(literal.getLanguage().get()); } else { out.writeByte(DATATYPE_LITERAL_VALUE); writeString(label); writeString(datatype.toString()); } }
public Value evaluate(Lang node, BindingSet bindings) throws ValueExprEvaluationException, QueryEvaluationException { Value argValue = evaluate(node.getArg(), bindings); if (argValue instanceof Literal) { Literal literal = (Literal)argValue; return tripleSource.getValueFactory().createLiteral(literal.getLanguage().orElse("")); } throw new ValueExprEvaluationException(); }
/** * Helper method to determine whether a literal is a language literal, and not a typed literal. * * @param literal * The literal to check * @return True if the literal has a language tag attached to it and false otherwise. */ public static boolean isLanguageLiteral(Literal literal) { return Objects.requireNonNull(literal, "Literal cannot be null").getLanguage().isPresent(); }
/** * Converts a {@link Literal} into a {@link RyaType} representation of the * {@code literal}. * @param literal the {@link Literal} to convert. * @return the {@link RyaType} representation of the {@code literal}. */ public static RyaType convertLiteral(final Literal literal) { if (literal == null) { return null; } if (literal.getDatatype() != null) { if (Literals.isLanguageLiteral(literal)) { final String language = literal.getLanguage().get(); if (Literals.isValidLanguageTag(language)) { return new RyaType(literal.getDatatype(), literal.stringValue(), language); } else { log.warn("Invalid language (" + LogUtils.clean(language) + ") found in Literal. Defaulting to: " + UNDETERMINED_LANGUAGE); // Replace invalid language with "und" return new RyaType(literal.getDatatype(), literal.stringValue(), UNDETERMINED_LANGUAGE); } } return new RyaType(literal.getDatatype(), literal.stringValue()); } return new RyaType(literal.stringValue()); }
public static Node asNode(Value v) { Node node; if (v == null) { node = Node.ANY; // TODO or Node.NULL or null? } else if (v instanceof IRI) { node = NodeFactory.createURI(v.stringValue()); } else if (v instanceof BNode) { node = NodeFactory.createBlankNode(((BNode) v).getID()); } else if (v instanceof Literal) { Literal lit = (Literal) v; IRI datatype = lit.getDatatype(); String lang = lit.getLanguage().orElse(null); if (lang != null) { node = NodeFactory.createLiteral(lit.getLabel(), lang, null); } else if (datatype != null) { node = NodeFactory.createLiteral(lit.getLabel(), null, NodeFactory.getType(datatype.toString())); } else { node = NodeFactory.createLiteral(lit.stringValue()); } } else { throw new IllegalArgumentException("Cannot create Node from Value: " + v); } return node; }
@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 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); } }
@Test public void testConvertLiteral_nullDataType() { final String expectedData = "Ice Cream"; final RyaType ryaType = new RyaType(null, expectedData); final Literal literal = RyaToRdfConversions.convertLiteral(ryaType); final Literal expected = VF.createLiteral(expectedData, XMLSchema.STRING); assertEquals(expected, literal); assertFalse(literal.getLanguage().isPresent()); }
@Override public void parse(Model model, Resource implNode) throws RepositoryConfigException { super.parse(model, implNode); try { Models.objectIRI(model.filter(implNode, REPOSITORYURL, null)).ifPresent( iri -> setURL(iri.stringValue())); Models.objectLiteral(model.filter(implNode, USERNAME, null)).ifPresent( username -> setUsername(username.getLabel())); Models.objectLiteral(model.filter(implNode, PASSWORD, null)).ifPresent( password -> setPassword(password.getLabel())); } catch (ModelException e) { throw new RepositoryConfigException(e.getMessage(), e); } } }
public void parse(Model m, Resource implNode) throws SailConfigException { try { Models.objectLiteral(m.filter(implNode, SAILTYPE, null)).ifPresent( lit -> setType(lit.getLabel())); Models.objectLiteral( m.filter(implNode, SailConfigSchema.ITERATION_CACHE_SYNC_THRESHOLD, null)).ifPresent( lit -> setIterationCacheSyncThreshold(lit.longValue())); Models.objectLiteral( m.filter(implNode, SailConfigSchema.CONNECTION_TIME_OUT, null)).ifPresent( lit -> setConnectionTimeOut(lit.longValue())); } catch (ModelException e) { throw new SailConfigException(e.getMessage(), e); } }
@Override public void parse(Model m, Resource implNode) throws SailConfigException { super.parse(m, implNode); try { Models.objectLiteral(m.filter(implNode, SpinSailSchema.AXIOM_CLOSURE_NEEDED, null)).ifPresent( lit -> setAxiomClosureNeeded(lit.booleanValue())); } catch (ModelException e) { throw new SailConfigException(e.getMessage(), e); } } }
@Override public void parse(Model graph, Resource implNode) throws SailConfigException { super.parse(graph, implNode); try { Models.objectLiteral(graph.filter(implNode, EVALUATION_STRATEGY_FACTORY, null)).ifPresent( factoryClassName -> { setEvaluationStrategyFactoryClassName(factoryClassName.stringValue()); }); } catch (ModelException e) { throw new SailConfigException(e.getMessage(), e); } } }
public Literal evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException { if (args.length != 1) { throw new ValueExprEvaluationException("SHA256 requires exactly 1 argument, got " + args.length); } if (args[0] instanceof Literal) { Literal literal = (Literal)args[0]; if (QueryEvaluationUtil.isSimpleLiteral(literal) || XMLSchema.STRING.equals(literal.getDatatype())) { String lexValue = literal.getLabel(); try { return valueFactory.createLiteral(hash(lexValue, "SHA-256")); } catch (NoSuchAlgorithmException e) { // SHA256 should always be available. throw new RuntimeException(e); } } else { throw new ValueExprEvaluationException("Invalid argument for SHA256: " + literal); } } else { throw new ValueExprEvaluationException("Invalid argument for SHA256: " + args[0]); } }