private Function negation(Function arg) { return (arg.getFunctionSymbol() == ExpressionOperation.NOT) ? (Function) arg.getTerm(0) : termFactory.getFunctionNOT(arg); }
private Term evalIsLiteral(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; return termFactory.getBooleanConstant(function.isDataTypeFunction()); } else { return term; } }
protected AbstractImmutableSubstitutionImpl(AtomFactory atomFactory, TermFactory termFactory, SubstitutionFactory substitutionFactory) { this.atomFactory = atomFactory; this.termFactory = termFactory; this.nullValue = termFactory.getNullConstant(); this.substitutionFactory = substitutionFactory; }
private Function getFreshAtom(Function a, String suffix) { List<Term> termscopy = new ArrayList<>(a.getArity()); for (Term t : a.getTerms()) { if (t instanceof Variable) { Variable v = (Variable)t; termscopy.add(termFactory.getVariable(v.getName() + suffix)); } else termscopy.add(t.clone()); } return termFactory.getFunction(a.getFunctionSymbol(), termscopy); }
private Term evalIsNumeric(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; return termFactory.getBooleanConstant(function.isDataTypeFunction() && isNumeric(function.getFunctionSymbol())); } else { return term; } }
private Term evalIsBlank(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function function = (Function) teval; Predicate predicate = function.getFunctionSymbol(); return termFactory.getBooleanConstant(predicate instanceof BNodePredicate); } return term; }
/** * Generates a new variable if a conflict is detected. */ public Variable generateNewVariableIfConflicting(Variable previousVariable) { Variable newVariable = previousVariable; while(knownVariables.contains(newVariable)) { newVariable = TERM_FACTORY.getVariable(previousVariable.getName() + SUFFIX_PREFIX + (count++)); } knownVariables.add(newVariable); return newVariable; }
/** * Determines if it is a unary function. */ private boolean isUnary(Function fun) { return fun.getArity() == 1; }
public CanonicalIRIMapping(CQIE mapping, Function uriTerm, Position termPosition) { this.mapping = mapping; this.uriTerm = uriTerm; this.templateURI = uriTerm.getTerm(0); this.termPosition = termPosition; }
private int getBodySize(List<? extends Function> atoms) { int counter = 0; for (Function atom : atoms) { Predicate predicate = atom.getFunctionSymbol(); if (predicate instanceof AtomPredicate) { counter++; } } return counter; } };
@Override public Expression f(Expression previousAtom, Function currentAtom) { return termFactory.getFunctionAND(previousAtom, currentAtom); } }, firstBooleanAtom);
public static boolean isVariableOnly(ImmutableCollection<? extends VariableOrGroundTerm> arguments) { for (VariableOrGroundTerm argument : arguments) { if (argument.isGround()) { return false; } } return true; } }
public static boolean areGroundTerms(Collection<? extends ImmutableTerm> terms) { for (ImmutableTerm term : terms) { if (!term.isGround()) { return false; } } return true; }
private Term evalIsIri(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function function = (Function) teval; Predicate predicate = function.getFunctionSymbol(); return termFactory.getBooleanConstant(predicate instanceof URITemplatePredicate); } return term; }
private Term evalIsLiteral(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; return TERM_FACTORY.getBooleanConstant(function.isDataTypeFunction()); } else { return term; } }
public Variable generateNewVariableFromVar(Variable previousVariable) { knownVariables.add(previousVariable); Variable newVariable; do { newVariable = termFactory.getVariable(previousVariable.getName() + SUFFIX_PREFIX + (count++)); } while(knownVariables.contains(newVariable)); knownVariables.add(newVariable); return newVariable; }
private Function negation(Function arg) { return (arg.getFunctionSymbol() == ExpressionOperation.NOT) ? (Function) arg.getTerm(0) : TERM_FACTORY.getFunctionNOT(arg); }
/** * Checks if the atom is unary or not. */ private static boolean isUnary(Function atom) { return atom.getArity() == 1 ? true : false; }
public static boolean isVariableOnly(ImmutableCollection<? extends VariableOrGroundTerm> arguments) { for (VariableOrGroundTerm argument : arguments) { if (argument.isGround()) { return false; } } return true; } }