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); } }
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 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); }
public Optional<ImmutableExpression> foldBooleanExpressions( ImmutableExpression... conjunctionOfExpressions) { return foldBooleanExpressions(ImmutableList.copyOf(conjunctionOfExpressions)); }
Function mutAt = ImmutabilityTools.convertToMutableFunction(projectionAtom); body.add(mutAt); return body; Function mutAt = ImmutabilityTools.convertToMutableFunction(atom); body.add(mutAt); return body; Expression mutFilter = ImmutabilityTools.convertToMutableBooleanExpression(filter2); Function newLJAtom = DATALOG_FACTORY.getSPARQLLeftJoin(atomsListLeft, atomsListRight, Optional.of(mutFilter)); body.add(newLJAtom); Function bodyAtom = ImmutabilityTools.convertToMutableFunction(freshHeadAtom); body.add(bodyAtom); return body;
public EvaluationResult evaluateExpression(ImmutableExpression expression) { Expression mutableExpression = ImmutabilityTools.convertToMutableBooleanExpression(expression); ImmutabilityTools.convertIntoImmutableTerm(evaluatedTerm)));
IRI classIRI = ca.getConcept().getIRI(); Function head = atomFactory.getMutableTripleHeadAtom( immutabilityTools.convertToMutableFunction( uriTemplateMatcher.generateURIFunction(c.getIRI().getIRIString())), classIRI); CQIE rule = datalogFactory.getCQIE(head, Collections.emptyList()); IRI propertyIRI = pa.getProperty().getIRI(); Function head = atomFactory.getMutableTripleHeadAtom( immutabilityTools.convertToMutableTerm(uriTemplateMatcher.generateURIFunction(s.getIRI().getIRIString())), propertyIRI, immutabilityTools.convertToMutableTerm(uriTemplateMatcher.generateURIFunction(o.getIRI().getIRIString()))); CQIE rule = datalogFactory.getCQIE(head, Collections.emptyList());
static ImmutableSubstitution<VariableOrGroundTerm> convertIntoVariableOrGroundTermSubstitution( ImmutableSubstitution<ImmutableTerm> substitution) { ImmutableMap.Builder<Variable, VariableOrGroundTerm> substitutionMapBuilder = ImmutableMap.builder(); for (Map.Entry<Variable, Term> entry : substitution.getMap().entrySet()) { VariableOrGroundTerm value = ImmutabilityTools.convertIntoVariableOrGroundTerm(entry.getValue()); substitutionMapBuilder.put(entry.getKey(), value); } return new ImmutableSubstitutionImpl<>(substitutionMapBuilder.build()); }
if (isNested) { ImmutableExpression filter2 = filter.get(); Function mutFilter = ImmutabilityTools.convertToMutableBooleanExpression(filter2); Function newJ = getSPARQLJoin(atoms, Optional.of(mutFilter)); body.add(newJ);
@Inject private TermFactoryImpl(TypeFactory typeFactory, OntopModelSettings settings) { // protected constructor prevents instantiation from other classes. this.typeFactory = typeFactory; RDFDatatype xsdBoolean = typeFactory.getXsdBooleanDatatype(); this.valueTrue = new ValueConstantImpl("true", xsdBoolean); this.valueFalse = new ValueConstantImpl("false", xsdBoolean); this.valueNull = new ValueConstantImpl("null", typeFactory.getXsdStringDatatype()); this.provenanceConstant = new ValueConstantImpl("ontop-provenance-constant", typeFactory.getXsdStringDatatype()); this.immutabilityTools = new ImmutabilityTools(this); this.type2FunctionSymbolMap = new HashMap<>(); this.isTestModeEnabled = settings.isTestModeEnabled(); this.templateCounter = new AtomicInteger(); this.templateSuffix = new ConcurrentHashMap<>(); }
public static Optional<ImmutableExpression> foldBooleanExpressions( ImmutableExpression... conjunctionOfExpressions) { return foldBooleanExpressions(ImmutableList.copyOf(conjunctionOfExpressions)); }
Function mutAt = immutabilityTools.convertToMutableFunction(projectionAtom); body.add(mutAt); return body; Function mutAt = immutabilityTools.convertToMutableFunction(atom); body.add(mutAt); return body; Expression mutFilter = immutabilityTools.convertToMutableBooleanExpression(filter2); Function newLJAtom = datalogFactory.getSPARQLLeftJoin(atomsListLeft, atomsListRight, Optional.of(mutFilter)); body.add(newLJAtom); Function bodyAtom = immutabilityTools.convertToMutableFunction(freshHeadAtom); body.add(bodyAtom); return body;
public EvaluationResult evaluateExpression(ImmutableExpression expression) { Expression mutableExpression = immutabilityTools.convertToMutableBooleanExpression(expression); immutabilityTools.convertIntoImmutableTerm(evaluatedTerm)), normalizer, termFactory);
ImmutableSubstitution<VariableOrGroundTerm> convertIntoVariableOrGroundTermSubstitution( ImmutableSubstitution<ImmutableTerm> substitution) { ImmutableMap<Variable, VariableOrGroundTerm> map = substitution.getImmutableMap().entrySet().stream() .collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> ImmutabilityTools.convertIntoVariableOrGroundTerm(e.getValue()))); return substitutionFactory.getSubstitution(map); }
if (isNested) { ImmutableExpression filter2 = filter.get(); Function mutFilter = immutabilityTools.convertToMutableBooleanExpression(filter2); Function newJ = getSPARQLJoin(atoms, Optional.of(mutFilter)); body.add(newJ);
/** * 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 Optional<ImmutableExpression> foldBooleanExpressions( Stream<ImmutableExpression> conjunctionOfExpressions) { return foldBooleanExpressions(conjunctionOfExpressions .collect(ImmutableCollectors.toList())); }
private ImmutableList<ImmutableTerm> convertTerms(Function functionalTermToClone) { ImmutableList.Builder<ImmutableTerm> builder = ImmutableList.builder(); for (Term term : functionalTermToClone.getTerms()) { builder.add(convertIntoImmutableTerm(term)); } return builder.build(); }
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); }
.collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> ImmutabilityTools.convertIntoVariableOrGroundTerm(e.getValue())))) .map(substitutionFactory::getSubstitution) .orElseThrow(AtomUnificationException::new);