public Term convertToMutableTerm(ImmutableTerm term) { if (term instanceof Variable) return (Term) term; else if (term instanceof Constant) return (Term) term; else { return convertToMutableFunction((ImmutableFunctionalTerm) term); } }
/** * TODO: explain * */ public Optional<ImmutableSubstitution<ImmutableTerm>> computeMGU(ImmutableFunctionalTerm term1, ImmutableFunctionalTerm term2) { Substitution mutableSubstitution = unifierUtilities.getMGU(immutabilityTools.convertToMutableFunction(term1), immutabilityTools.convertToMutableFunction(term2)); if (mutableSubstitution == null) { return Optional.empty(); } return Optional.of(substitutionTools.convertMutableSubstitution(mutableSubstitution)); }
private List<Term> convertToMutableTerms(ImmutableList<? extends ImmutableTerm> terms) { List<Term> mutableList = new ArrayList<>(); Iterator<? extends ImmutableTerm> iterator = terms.iterator(); while (iterator.hasNext()) { ImmutableTerm nextTerm = iterator.next(); if (nextTerm instanceof ImmutableFunctionalTerm) { ImmutableFunctionalTerm term2Change = (ImmutableFunctionalTerm) nextTerm; Function newTerm = convertToMutableFunction(term2Change); mutableList.add(newTerm); } else { // Variables and constants are Term-instances mutableList.add((Term)nextTerm); } } return mutableList; }
/** * TODO: explain * */ public static Optional<ImmutableSubstitution<ImmutableTerm>> computeMGU(ImmutableFunctionalTerm term1, ImmutableFunctionalTerm term2) { Substitution mutableSubstitution = UnifierUtilities.getMGU(convertToMutableFunction(term1), convertToMutableFunction(term2)); if (mutableSubstitution == null) { return Optional.empty(); } return Optional.of(ImmutableSubstitutionTools.convertMutableSubstitution(mutableSubstitution)); }
public <T extends ImmutableTerm> Optional<ImmutableSubstitution<T>> computeMGU(ImmutableList<T> args1, ImmutableList<T> args2) { if (args1.size() != args2.size()) throw new IllegalArgumentException("The two argument lists must have the same size"); // TODO: avoid use it TemporaryFunctionSymbol functionSymbol = new TemporaryFunctionSymbol(args1.size(), typeFactory); Substitution mutableSubstitution = unifierUtilities.getMGU( immutabilityTools.convertToMutableFunction(functionSymbol, args1), immutabilityTools.convertToMutableFunction(functionSymbol, args2)); if (mutableSubstitution == null) { return Optional.empty(); } return Optional.of(substitutionTools.convertMutableSubstitution(mutableSubstitution)) .map(s -> (ImmutableSubstitution<T>)s); }
public Optional<ImmutableSubstitution<VariableOrGroundTerm>> computeAtomMGU(DataAtom atom1, DataAtom atom2) { Substitution mutableSubstitution = unifierUtilities.getMGU( immutabilityTools.convertToMutableFunction(atom1), immutabilityTools.convertToMutableFunction(atom2)); if (mutableSubstitution == null) { return Optional.empty(); } ImmutableMap.Builder<Variable, VariableOrGroundTerm> substitutionMapBuilder = ImmutableMap.builder(); for (Map.Entry<Variable, Term> entry : mutableSubstitution.getMap().entrySet()) { VariableOrGroundTerm value = ImmutabilityTools.convertIntoVariableOrGroundTerm(entry.getValue()); substitutionMapBuilder.put(entry.getKey(), value); } ImmutableSubstitution<VariableOrGroundTerm> immutableSubstitution = substitutionFactory.getSubstitution( substitutionMapBuilder.build()); return Optional.of(immutableSubstitution); }
public static Optional<ImmutableSubstitution<VariableOrGroundTerm>> computeAtomMGU(DataAtom atom1, DataAtom atom2) { Substitution mutableSubstitution = UnifierUtilities.getMGU( convertToMutableFunction(atom1), convertToMutableFunction(atom2)); if (mutableSubstitution == null) { return Optional.empty(); } ImmutableMap.Builder<Variable, VariableOrGroundTerm> substitutionMapBuilder = ImmutableMap.builder(); for (Map.Entry<Variable, Term> entry : mutableSubstitution.getMap().entrySet()) { VariableOrGroundTerm value = ImmutabilityTools.convertIntoVariableOrGroundTerm(entry.getValue()); substitutionMapBuilder.put(entry.getKey(), value); } ImmutableSubstitution<VariableOrGroundTerm> immutableSubstitution = new ImmutableSubstitutionImpl<>(substitutionMapBuilder.build()); return Optional.of(immutableSubstitution); }
/** * This method takes a immutable term and convert it into an old mutable function. */ public Function convertToMutableFunction(ImmutableFunctionalTerm functionalTerm) { return convertToMutableFunction(functionalTerm.getFunctionSymbol(), functionalTerm.getTerms()); }
/** * This method takes a immutable boolean term and convert it into an old mutable boolean function. */ public static Expression convertToMutableBooleanExpression(ImmutableExpression booleanExpression) { OperationPredicate pred = (OperationPredicate) booleanExpression.getFunctionSymbol(); ImmutableList<Term> otherTerms = booleanExpression.getTerms(); List<Term> mutableList = new ArrayList<>(); Iterator<Term> iterator = otherTerms.iterator(); while (iterator.hasNext()) { Term nextTerm = iterator.next(); if (nextTerm instanceof ImmutableFunctionalTerm) { ImmutableFunctionalTerm term2Change = (ImmutableFunctionalTerm) nextTerm; Function newTerm = convertToMutableFunction(term2Change); mutableList.add(newTerm); } else { mutableList.add(nextTerm); } } Expression mutFunc = TERM_FACTORY.getExpression(pred, mutableList); return mutFunc; }
/** * This method takes a immutable term and convert it into an old mutable function. */ public static Function convertToMutableFunction(ImmutableFunctionalTerm functionalTerm) { Predicate pred = functionalTerm.getFunctionSymbol(); ImmutableList<Term> otherTerms = functionalTerm.getTerms(); List<Term> mutableList = new ArrayList<>(); Iterator<Term> iterator = otherTerms.iterator(); while (iterator.hasNext()) { Term nextTerm = iterator.next(); if (nextTerm instanceof ImmutableFunctionalTerm) { ImmutableFunctionalTerm term2Change = (ImmutableFunctionalTerm) nextTerm; Function newTerm = convertToMutableFunction(term2Change); mutableList.add(newTerm); } else { mutableList.add(nextTerm); } } Function mutFunc = TERM_FACTORY.getFunction(pred, mutableList); return mutFunc; }
public Function convertToMutableFunction(DataAtom dataAtom) { return convertToMutableFunction(dataAtom.getPredicate(), dataAtom.getArguments()); }
CQIE newrule = DATALOG_FACTORY.getCQIE(ImmutabilityTools.convertToMutableFunction(substitutedHeadAtom), atoms);
Function newHead = immutabilityTools.convertToMutableFunction(head.atom.getPredicate(), substitutedHeadAtomArguments);
Function mutAt = ImmutabilityTools.convertToMutableFunction(projectionAtom); body.add(mutAt); return body; Function mutAt = ImmutabilityTools.convertToMutableFunction(atom); body.add(mutAt); return body; Function bodyAtom = ImmutabilityTools.convertToMutableFunction(freshHeadAtom); body.add(bodyAtom); return body;
try { Function mergedAtom = immutabilityTools.convertToMutableFunction( atom.getProjectionAtom().getPredicate(), atom.getSubstitutedTerms());
Function mutAt = immutabilityTools.convertToMutableFunction(projectionAtom); body.add(mutAt); return body; Function mutAt = immutabilityTools.convertToMutableFunction(atom); body.add(mutAt); return body; Function bodyAtom = immutabilityTools.convertToMutableFunction(freshHeadAtom); body.add(bodyAtom); return body;
Function constantFunction = immutabilityTools.convertToMutableFunction( uriTemplateMatcher.generateURIFunction(uri)); if (constantFunction.getArity() == 1 && unknownUrisToTemplates) {
IRI classIRI = ca.getConcept().getIRI(); Function head = atomFactory.getMutableTripleHeadAtom( immutabilityTools.convertToMutableFunction( uriTemplateMatcher.generateURIFunction(c.getIRI().getIRIString())), classIRI); CQIE rule = datalogFactory.getCQIE(head, Collections.emptyList());