@Override public final boolean isValid(Literal value) { if (value.getLanguage() != null){ if(languages == null) { //no language restrictions return true; //return any Plain Literal } else { Language literalLang = value.getLanguage(); return languages.contains(literalLang); } } else if(value.getDataType().equals(xsdString)) { /* * if the null language is active, than we can also return * "normal" literals (with no known language). This includes * Types literals with the data type xsd:string */ return containsNull; } else {// unknown Literal type -> filter + warning log.warn(String.format("Unknown LiteralType %s (lexicalForm=\"%s\") -> ignored! Pleas adapt this implementation to support this type!", value.getClass(),value.getLexicalForm())); return false; } } }
@Override public Boolean createObject(Literal literal) { if (literal == TRUE) return true; else if (literal == FALSE) return false; else if (!literal.getDataType().equals(booleanUri)) { throw new InvalidLiteralTypeException(Boolean.class, literal.getDataType()); } return Boolean.valueOf(literal.getLexicalForm()); } }
@Override public Long createObject(Literal literal) { if (!decimalTypes.contains(literal.getDataType())) { throw new InvalidLiteralTypeException(Long.class, literal.getDataType()); } return new Long(literal.getLexicalForm()); } }
@Override public IRI createObject(Literal literal) { if (!literal.getDataType().equals(xsdAnyURI)) { throw new InvalidLiteralTypeException(IRI.class, literal.getDataType()); } return new IRI(literal.getLexicalForm()); } }
try { Iterator<Triple> triples = systemGraph.filter(null, FOAF.mbox, new IRI("mailto:" + email)); if (!triples.hasNext()) { return null; BlankNodeOrIRI user = triples.next().getSubject(); triples = systemGraph.filter(user, PLATFORM.userName, null); if (!triples.hasNext()) { + " does not have a name"); return ((Literal) triples.next().getObject()).getLexicalForm(); } finally { readLock.unlock();
private void handleStatement(RDFDataset result, Triple t, Map<BlankNode, String> blankNodeMap) { final String subject = getResourceValue(t.getSubject(), blankNodeMap); final String predicate = getResourceValue(t.getPredicate(), blankNodeMap); final RDFTerm object = t.getObject(); if (object instanceof Literal) { final Literal literalObject = (Literal) object; final String value = literalObject.getLexicalForm(); final String language; final String datatype; if (literalObject.getLanguage() != null) { language = literalObject.getLanguage().toString(); datatype = RDF_LANG_STRING; } else { datatype = getResourceValue(literalObject.getDataType(), blankNodeMap); language = null; } result.addTriple(subject, predicate, value, datatype, language); count++; } else { result.addTriple(subject, predicate, getResourceValue((BlankNodeOrIRI) object, blankNodeMap)); count++; } }
@Override public final String adapt(T value, Class<String> type) { if (value == null) { return null; } else if (value instanceof IRI) { return ((IRI) value).getUnicodeString(); } else if (value instanceof Literal) { return ((Literal) value).getLexicalForm(); } else { return value.toString(); } }
@Override public String next() { return ((Literal)results.next().getObject()).getLexicalForm(); } @Override
uri, DCTERMS.title, null); while (titleStatements.hasNext()) { RDFTerm object = titleStatements.next().getObject(); if (object instanceof Literal) { result.append("title: "); result.append (((Literal) object).getLexicalForm()); result.append("\n"); uri, DCTERMS.description, null); while (descriptionStatements.hasNext()) { RDFTerm object = descriptionStatements.next().getObject(); if (object instanceof Literal) { result.append("description: "); result.append (((Literal) object).getLexicalForm()); result.append("\n"); uri, SKOS.definition, null); while (skosDefStatements.hasNext()) { RDFTerm object = skosDefStatements.next().getObject(); if (object instanceof Literal) { result.append("definition: "); result.append (((Literal) object).getLexicalForm()); result.append("\n"); if (object instanceof Literal) { result.append("comment: "); result.append(((Literal) object).getLexicalForm()); result.append("\n");
@Override public Triple next() { Triple triple = wrapped.next(); BlankNodeOrIRI subject = triple.getSubject(); if (subject instanceof IRI) { subject = replacePlaceHolder((IRI) subject); } IRI predicate = replacePlaceHolder(triple.getPredicate()); RDFTerm object = triple.getObject(); if (object instanceof IRI) { object = replacePlaceHolder((IRI) object); } else if (object instanceof Literal) { Literal literal = (Literal) object; if (literal.getDataType().equals(XML_LITERAL)) { object = replacePlaceHolderInUrl(literal); } } return new TripleImpl(subject, predicate, object); }
BlankNodeOrIRI role = roleIterator.next().getSubject(); Iterator<Triple> roleNameTriples = systemGraph.filter(role, DC.title, null); while (roleNameTriples.hasNext()) { Literal roleLiteral = (Literal) roleNameTriples.next().getObject(); if (roleName.equals(roleLiteral.getLexicalForm())) { roleNode = new GraphNode(role, systemGraph); break;
Iterator<Triple> dcLanguageIterator = enhancements.filter(textAnnotation, DC_LANGUAGE, null); if(dcLanguageIterator.hasNext()){ //a language annotation RDFTerm dcLanguageResource = dcLanguageIterator.next().getObject(); assertTrue("The dc:language value MUST BE a PlainLiteral", dcLanguageResource instanceof Literal); assertTrue("The dc:language value '"+dcLanguageResource+"'MUST BE at least two chars long", ((Literal)dcLanguageResource).getLexicalForm().length() >=2); assertFalse("TextAnnotations with the dc:language property MUST only have a single dc:language value (uri " +textAnnotation+")",dcLanguageIterator.hasNext()); +textAnnotation+")", dcTypeIterator.hasNext()); assertEquals("TextAnnotations with the dc:language property MUST use dc:type dc:LinguisticSystem (uri " +textAnnotation+")", DCTERMS_LINGUISTIC_SYSTEM,dcTypeIterator.next().getObject()); assertFalse("TextAnnotations with the dc:language property MUST only have a single dc:type value (uri " +textAnnotation+")",dcTypeIterator.hasNext()); assertFalse("Only fise:TextAnnotations without a dc:language value MUST NOT use the " + "dc:type value dc:LinguisticSystem (uri "+textAnnotation+")", DCTERMS_LINGUISTIC_SYSTEM.equals(dcTypeIterator.next().getObject()));
while (literals.hasNext()) { Literal act = literals.next(); if (act.getLanguage() != null) { if (languageSet.contains(act.getLanguage())) { results.add(0, act.getLexicalForm()); //add to front results.add(act.getLexicalForm()); //append to the end
public String getSummary() { Iterator<Triple> abstracts = entityProperties.filter(uri, SUMMARY, null); while (abstracts.hasNext()) { RDFTerm object = abstracts.next().getObject(); if (object instanceof Literal) { Literal abstract_ = (Literal) object; if (new Language("en").equals(abstract_.getLanguage())) { return abstract_.getLexicalForm(); } } } return ""; }
recipeGraph = tcManager.getGraph(recipeID); } catch (NoSuchEntityException e) { throw new NoSuchRecipeException(recipeID.toString()); String recipeDescription = null; if (descriptions != null && descriptions.hasNext()) { recipeDescription = descriptions.next().getObject().toString(); String query = "SELECT ?rule ?ruleName ?ruleBody ?ruleHead " + "WHERE { " + " " + recipeID.toString() + " " + Symbols.hasRule.toString() + " ?rule . " + " ?rule " + Symbols.ruleName.toString() + " ?ruleName . " + " ?rule " + Symbols.ruleBody.toString() + " ?ruleBody . " + " ?rule " stanbolRuleBuilder.append(((Literal) nameResource).getLexicalForm()); stanbolRuleBuilder.append("["); stanbolRuleBuilder.append(((Literal) bodyResource).getLexicalForm()); stanbolRuleBuilder.append(" -> "); stanbolRuleBuilder.append(((Literal) headResource).getLexicalForm()); stanbolRuleBuilder.append("]");
while (allRoleTriples.hasNext()) { Triple triple = allRoleTriples.next(); GraphNode roleNode = new GraphNode(triple.getSubject(), systemGraph); Iterator<Literal> titlesIterator = roleNode.getLiterals(DC.title); while (titlesIterator.hasNext()) { allRoleNames.add(titlesIterator.next().getLexicalForm()); while (userRoleTriples.hasNext()) { Triple triple = userRoleTriples.next(); GraphNode roleNode = new GraphNode(triple.getSubject(), rolesGraph); userRoleNames.add(titlesIterator.next().getLexicalForm());
@Override public final Text adapt(T value, Class<Text> type) { if(value.getLanguage() != null) { Language literalLang = value.getLanguage(); if(languages == null || languages.contains(literalLang)){ return valueFactory.createText(value); } //else wrong language -> filter } else { if(containsNull && value.getDataType().equals(xsdString)){ /* * if the null language is active, than we can also return * "normal" literals (with no known language). * But first we need to check the Datatype! */ return valueFactory.createText(value); } // else no xsd:string dataType and therefore not a text with default lang! } return null; }
@Test public void testUseLanguageLiterals() { Graph graph = getEmptyGraph(); Assert.assertEquals(0, graph.size()); Language language = new Language("it"); Literal value = new PlainLiteralImpl("<elem>value</elem>",language); final TripleImpl triple1 = new TripleImpl(uriRef1, uriRef2, value); graph.add(triple1); Iterator<Triple> tripleIter = graph.filter(uriRef1, uriRef2, null); Assert.assertTrue(tripleIter.hasNext()); RDFTerm gotValue = tripleIter.next().getObject(); Assert.assertEquals(value, gotValue); Assert.assertEquals(language, ((Literal)gotValue).getLanguage()); }
@Override public String process(Object... values) { return ((Literal) values[0]).getLexicalForm(); } };
@Override public RDFTerm convert(RDFTerm value) { if(value instanceof Literal && XSD.double_.equals(((Literal)value).getDataType())){ LiteralFactory lf = LiteralFactory.getInstance(); double mm = lf.createObject(Double.class, (Literal)value); return lf.createTypedLiteral(Double.valueOf( mm*1024/60)); } else { return value; //do not convert } }