private GroundFunctionalTerm convertIRIIntoGroundFunctionalTerm(IRI iri) { return (GroundFunctionalTerm) termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(iri.getIRIString())); }
private ImmutableFunctionalTerm createGroundFunctionalTerm(IRI iri) { return termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(iri.getIRIString())); } }
private GroundFunctionalTerm convertIRIIntoGroundFunctionalTerm(IRI iri) { return (GroundFunctionalTerm) termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(iri.getIRIString())); }
private ImmutableFunctionalTerm getUriFunctionTerm(String text) { final String PLACEHOLDER = "{}"; List<ImmutableTerm> terms = new LinkedList<>(); List<FormatString> tokens = parse(text); StringBuilder sb = new StringBuilder(); for (FormatString token : tokens) { if (token instanceof FixedString) { // if part of URI template sb.append(token.toString()); } else if (token instanceof ColumnString) { sb.append(PLACEHOLDER); Variable column = termFactory.getVariable(token.toString()); terms.add(column); } } ValueConstant uriTemplate = termFactory.getConstantLiteral(sb.toString()); // complete URI template terms.add(0, uriTemplate); return termFactory.getImmutableUriTemplate(ImmutableList.copyOf(terms)); }
values.add(termFactory.getConstantLiteral(value)); functionURI = termFactory.getImmutableUriTemplate(values.build()); functionURI = termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(uriString)); functionURI = termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(uriString));
values.add(TERM_FACTORY.getConstantLiteral(value)); functionURI = TERM_FACTORY.getImmutableUriTemplate(values.build()); functionURI = TERM_FACTORY.getImmutableUriTemplate(TERM_FACTORY.getConstantLiteral(uriString)); functionURI = TERM_FACTORY.getImmutableUriTemplate(TERM_FACTORY.getConstantLiteral(uriString));
private ImmutableList<TargetAtom> constructTargetQuery(ImmutableFunctionalTerm classTerm, ObjectRDFType type) { Variable X = termFactory.getVariable("X"); ImmutableFunctionalTerm subjectTerm; if (!type.isBlankNode()) subjectTerm = termFactory.getImmutableUriTemplate(X); else { subjectTerm = termFactory.getImmutableBNodeTemplate(X); } ImmutableTerm predTerm = termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral( org.eclipse.rdf4j.model.vocabulary.RDF.TYPE.toString())); TargetAtom targetAtom = targetAtomFactory.getTripleTargetAtom(subjectTerm, predTerm ,classTerm); return ImmutableList.of(targetAtom); }
if (token instanceof FixedString) { toReturn = termFactory.getImmutableUriTemplate(uriTemplate); } else if (token instanceof ColumnString) { toReturn = termFactory.getImmutableUriTemplate(column); toReturn = termFactory.getImmutableUriTemplate(ImmutableList.copyOf(terms));
ImmutableFunctionalTerm templateFunction = TERM_FACTORY.getImmutableUriTemplate(TERM_FACTORY.getVariable("x")); Pattern matcher = Pattern.compile("(.+)"); uriTemplateMatcher.uriTemplateMatcher.put(matcher, templateFunction);
ImmutableFunctionalTerm templateFunction = termFactory.getImmutableUriTemplate(termFactory.getVariable("x")); Pattern matcher = Pattern.compile("(.+)"); uriTemplateMatcher.uriTemplateMatcher.put(matcher, templateFunction);
@Override public ImmutableTerm visitVerb(VerbContext ctx) { ResourceContext rc = ctx.resource(); if (rc != null) { return visitResource(rc); } return termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(it.unibz.inf.ontop.model.vocabulary.RDF.TYPE.getIRIString())); }
/** * Get body predicates with templates * @param pom * @return * @throws Exception */ public List<ImmutableFunctionalTerm> getBodyURIPredicates(PredicateObjectMap pom) { List<ImmutableFunctionalTerm> predicateAtoms = new ArrayList<>(); // process PREDICATEMAP for (PredicateMap pm : pom.getPredicateMaps()) { String pmConstant = pm.getConstant().toString(); if (pmConstant != null) { ImmutableFunctionalTerm bodyPredicate = termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(pmConstant)); predicateAtoms.add(bodyPredicate); } Template t = pm.getTemplate(); if (t != null) { // create uri("...",var) ImmutableFunctionalTerm predicateAtom = getURIFunction(t.toString()); predicateAtoms.add(predicateAtom); } // process column declaration String c = pm.getColumn(); if (c != null) { ImmutableFunctionalTerm predicateAtom = getURIFunction(c); predicateAtoms.add(predicateAtom); } } return predicateAtoms; }
terms.add(0, uriTemplate); // the URI template is always on the return termFactory.getImmutableUriTemplate(ImmutableList.copyOf(terms)); terms.add(0, uriTemplate); // the URI template is always on the return termFactory.getImmutableUriTemplate(ImmutableList.copyOf(terms));
GroundFunctionalTerm predicateTerm = (GroundFunctionalTerm) termFactory.getImmutableUriTemplate( termFactory.getConstantLiteral(getPredicateName(templateAtom.getTerm(0), values)));
private ImmutableList<TargetAtom> constructTargetQuery(ImmutableFunctionalTerm iriTerm, ObjectRDFType type1, RDFTermType type2) { Variable X = termFactory.getVariable("X"); Variable Y = termFactory.getVariable("Y"); ImmutableFunctionalTerm subjectTerm; if (!type1.isBlankNode()) subjectTerm = termFactory.getImmutableUriTemplate(X); else { subjectTerm = termFactory.getImmutableBNodeTemplate(X); } ImmutableFunctionalTerm objectTerm; if (type2 instanceof ObjectRDFType) { objectTerm = ((ObjectRDFType)type2).isBlankNode() ? termFactory.getImmutableBNodeTemplate(Y) : termFactory.getImmutableUriTemplate(Y); } else { RDFDatatype datatype = (RDFDatatype) type2; if (datatype.getLanguageTag().isPresent()) { LanguageTag languageTag = datatype.getLanguageTag().get(); objectTerm = termFactory.getImmutableTypedTerm(Y, languageTag.getFullString()); } else { objectTerm = termFactory.getImmutableTypedTerm(Y, datatype); } } TargetAtom targetAtom = targetAtomFactory.getTripleTargetAtom(subjectTerm,iriTerm,objectTerm); return ImmutableList.of(targetAtom); }
terms.add(termFactory.getVariable(varNamePrefix + att.getID().getName())); return termFactory.getImmutableUriTemplate(ImmutableList.copyOf(terms));
ImmutableTerm predFunction = termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(RDF.TYPE.toString())); ;
terms.add(df.getVariable(varNamePrefix + att.getID().getName())); return df.getImmutableUriTemplate(ImmutableList.copyOf(terms));
if(template == null && (termType.equals(R2RMLVocabulary.iri))){ subjectAtom = termFactory.getImmutableUriTemplate(termFactory.getVariable(subj)); classPredicates.add( termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral(o.getIRIString())));
objectAtom = termFactory.getImmutableUriTemplate(termFactory.getConstantLiteral( ((IRI) constantObj).getIRIString())); objectAtom = termFactory.getImmutableUriTemplate(objectAtom);