@Override public Function getUriTemplateForDatatype(String type) { ValueConstant term = getConstantLiteral(type); return getFunction(getURITemplatePredicate(ImmutableList.of(term)), term); }
@Override public Expression getFunctionCast(Term term1, Term term2) { // TODO implement cast function return getExpression(ExpressionOperation.QUEST_CAST, term1, term2); }
@Override public ImmutableExpression getImmutableExpression(OperationPredicate functor, ImmutableTerm... arguments) { return getImmutableExpression(functor, ImmutableList.copyOf(arguments)); }
@Override public ImmutableFunctionalTerm getImmutableUriTemplate(ImmutableList<ImmutableTerm> terms) { FunctionSymbol pred = getURITemplatePredicate(terms); return getImmutableFunctionalTerm(pred, terms); }
@Override public Function getTypedTerm(Term value, RDFDatatype type) { return getFunction(getRequiredTypePredicate(type), value); }
@Override public ImmutableFunctionalTerm getImmutableTypedTerm(ImmutableTerm value, RDFDatatype type) { FunctionSymbol pred = getRequiredTypePredicate(type); if (pred == null) throw new RuntimeException("Unknown data type: " + type); return getImmutableFunctionalTerm(pred, value); }
@Override public ImmutableFunctionalTerm getImmutableFunctionalTerm(FunctionSymbol functor, ImmutableTerm... terms) { return getImmutableFunctionalTerm(functor, ImmutableList.copyOf(terms)); }
@Override public Function getFunction(Predicate functor, Term... arguments) { return getFunction(functor, Arrays.asList(arguments)); }
@Override public Function getTypedTerm(Term value, String language) { Term lang = getConstantLiteral(language.toLowerCase(), COL_TYPE.STRING); Predicate pred = typeFactory.getTypePredicate(COL_TYPE.LANG_STRING); return getFunction(pred, value, lang); }
@Override public Function getUriTemplate(List<Term> terms) { FunctionSymbol uriPred = getURITemplatePredicate(terms.size(), terms); return getFunction(uriPred, terms); }
@Override public Function getFunction(Predicate functor, List<Term> arguments) { if (isTestModeEnabled) { checkMutability(arguments); } if (functor instanceof OperationPredicate) { return getExpression((OperationPredicate) functor, arguments); } // Default constructor return new FunctionalTermImpl(functor, arguments); }
@Override public ImmutableFunctionalTerm getImmutableTypedTerm(ImmutableTerm value, String language) { ValueConstant lang = getConstantLiteral(language.toLowerCase(), COL_TYPE.STRING); Predicate pred = typeFactory.getTypePredicate(COL_TYPE.LANG_STRING); return getImmutableFunctionalTerm(pred, value, lang); }
private void checkMutability(List<Term> terms) { for(Term term : terms) { if (term instanceof ImmutableFunctionalTerm) throw new IllegalArgumentException("Was expecting a mutable term, not a " + term.getClass()); else if (term instanceof Function) checkMutability(((Function) term).getTerms()); } }
@Override public ImmutableFunctionalTerm getImmutableTypedTerm(ImmutableTerm value, IRI datatypeIRI) { return getImmutableTypedTerm(value, typeFactory.getDatatype(datatypeIRI)); }
private URITemplatePredicate getURITemplatePredicate(int arity, List<? extends Term> terms) { String suffix = computeSuffix(terms.stream() .findFirst() .filter(t -> t instanceof Constant) .map(t -> (Constant) t)); return new URITemplatePredicateImpl(arity, suffix, typeFactory); }
@Override public ImmutableFunctionalTerm getImmutableUriTemplate(ImmutableTerm... terms) { return getImmutableUriTemplate(ImmutableList.copyOf(terms)); }
@Override public ValueConstant getConstantLiteral(String value, IRI type) { return getConstantLiteral(value, typeFactory.getDatatype(type)); }
@Override public ImmutableExpression getImmutableExpression(Expression expression) { if (GroundTermTools.isGroundTerm(expression)) { return new GroundExpressionImpl(expression.getFunctionSymbol(), (ImmutableList<? extends GroundTerm>)(ImmutableList<?>)convertTerms(expression)); } else { return new NonGroundExpressionImpl(expression.getFunctionSymbol(), convertTerms(expression)); } }
@Override public ImmutableFunctionalTerm getImmutableFunctionalTerm(Predicate functor, ImmutableTerm... terms) { return getImmutableFunctionalTerm(functor, ImmutableList.copyOf(terms)); }
@Override public Function getBNodeTemplate(Term... terms) { Predicate pred = new BNodePredicateImpl(terms.length); return getFunction(pred, terms); }