private static Set<Variable> getVariables(Function atom) { Set<Variable> set = new HashSet<>(); for (Term t : atom.getTerms()) if (t instanceof Variable) set.add((Variable)t); return set; }
private static void collectVariables(Set<Term> vars, Function atom) { Deque<Term> terms = new LinkedList<>(atom.getTerms()); while (!terms.isEmpty()) { Term t = terms.pollFirst(); if (t instanceof Variable) vars.add(t); else if (!(t instanceof Constant)) terms.addAll(((Function)t).getTerms()); } } /*
public static void addReferencedVariablesTo(Collection<Variable> vars, Function f) { for (Term t : f.getTerms()) { if (t instanceof Variable) vars.add((Variable)t); else if (t instanceof Function) addReferencedVariablesTo(vars, (Function)t); // else (t instanceof BNode) || (t instanceof IRIConstant) || (t instanceof ValueConstant) // no-op } }
private static ImmutableList<ImmutableTerm> convertTerms(Function functionalTermToClone) { ImmutableList.Builder<ImmutableTerm> builder = ImmutableList.builder(); for (Term term : functionalTermToClone.getTerms()) { builder.add(ImmutabilityTools.convertIntoImmutableTerm(term)); } return builder.build(); }
private ImmutableList<ImmutableTerm> convertTerms(Function functionalTermToClone) { ImmutableList.Builder<ImmutableTerm> builder = ImmutableList.builder(); for (Term term : functionalTermToClone.getTerms()) { builder.add(convertIntoImmutableTerm(term)); } return builder.build(); }
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()); } }
private ImmutableList<ImmutableTerm> convertTerms(Function functionalTermToClone) { ImmutableList.Builder<ImmutableTerm> builder = ImmutableList.builder(); for (Term term : functionalTermToClone.getTerms()) { builder.add(immutabilityTools.convertIntoImmutableTerm(term)); } return builder.build(); }
public static void addReferencedVariablesTo(Collection<Variable> vars, Function f) { for (Term t : f.getTerms()) { if (t instanceof Variable) vars.add((Variable)t); else if (t instanceof Function) addReferencedVariablesTo(vars, (Function)t); // else (t instanceof BNode) || (t instanceof URIConstant) || (t instanceof ValueConstant) // no-op } }
private static ImmutableMap<CQIE, ImmutableList<Optional<TermType>>> extractTermTypeMap(Collection<CQIE> rules) throws IncompatibleTermException { return rules.stream() .collect(ImmutableCollectors.toMap( // Key mapper rule -> rule, // Value mapper rule -> rule.getHead().getTerms().stream() .map(TermTypeInferenceTools::inferType) .collect(ImmutableCollectors.toList()) )); }
private static ImmutableMap<CQIE, ImmutableList<Optional<TermType>>> extractTermTypeMap(Collection<CQIE> rules) throws IncompatibleTermException { return rules.stream() .collect(ImmutableCollectors.toMap( // Key mapper rule -> rule, // Value mapper rule -> rule.getHead().getTerms().stream() .map(TermTypeInferenceTools::inferType) .collect(ImmutableCollectors.toList()) )); }
private ImmutableMap<CQIE, ImmutableList<Optional<TermType>>> extractTermTypeMap(Collection<CQIE> rules) throws IncompatibleTermException { return rules.stream() .collect(ImmutableCollectors.toMap( // Key mapper rule -> rule, // Value mapper rule -> rule.getHead().getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .map(termTypeInferenceTools::inferType) .collect(ImmutableCollectors.toList()) )); }
private Optional<IRI> extractIRI(Function atom) { return Optional.of(atom.getFunctionSymbol()) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> (RDFAtomPredicate) p) .flatMap(p -> { ImmutableList<ImmutableTerm> arguments = atom.getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .collect(ImmutableCollectors.toList()); return p.getClassIRI(arguments) .map(Optional::of) .orElseGet(() -> p.getPropertyIRI(arguments)); }); }
private ImmutableList<Function> getHaving(List<Function> body) { for (Function atom : body) { if (atom.getFunctionSymbol() == DatalogAlgebraOperatorPredicates.SPARQL_HAVING) { return convert(atom.getTerms()); } } return ImmutableList.of(); }
private Optional<IRI> extractPropertyIRI(Function rdfDataAtom) { if (rdfDataAtom.getFunctionSymbol() instanceof RDFAtomPredicate) { RDFAtomPredicate rdfAtomPredicate = (RDFAtomPredicate) rdfDataAtom.getFunctionSymbol(); ImmutableList<ImmutableTerm> arguments = rdfDataAtom.getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .collect(ImmutableCollectors.toList()); return rdfAtomPredicate.getPropertyIRI(arguments); } return Optional.empty(); }
private Optional<IRI> extractClassIRI(Function rdfDataAtom) { if (rdfDataAtom.getFunctionSymbol() instanceof RDFAtomPredicate) { RDFAtomPredicate rdfAtomPredicate = (RDFAtomPredicate) rdfDataAtom.getFunctionSymbol(); ImmutableList<ImmutableTerm> arguments = rdfDataAtom.getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .collect(ImmutableCollectors.toList()); return rdfAtomPredicate.getClassIRI(arguments); } return Optional.empty(); } }
private ImmutableList<Function> getHaving(List<Function> body) { for (Function atom : body) { if (atom.getFunctionSymbol().equals(datalogFactory.getSparqlHavingPredicate())) { return convert(atom.getTerms()); } } return ImmutableList.of(); }
@Override public Function applyToMutableFunctionalTerm(Function mutableFunctionalTerm) { if (isEmpty()) return mutableFunctionalTerm; List<Term> transformedSubTerms = new ArrayList<>(); for (Term subTerm : mutableFunctionalTerm.getTerms()) { transformedSubTerms.add(applyToMutableTerm(subTerm)); } Predicate functionSymbol = mutableFunctionalTerm.getFunctionSymbol(); return TERM_FACTORY.getFunction(functionSymbol, transformedSubTerms); }
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); }
public static GroundTerm castIntoGroundTerm(Term term) throws NonGroundTermException{ if (term instanceof GroundTerm) return (GroundTerm) term; if (term instanceof Function) { Function functionalTerm = (Function) term; // Recursive return new GroundFunctionalTermImpl(functionalTerm.getFunctionSymbol(), castIntoGroundTerms(functionalTerm.getTerms())); } throw new NonGroundTermException(term + " is not a ground term"); }