/** * Immutable fields, can be shared. */ @Override public ConstructionNode clone() { return new ConstructionNodeImpl(projectedVariables, substitution, optionalModifiers, nullabilityEvaluator); }
@Override public IQTree applyDescendingSubstitution( ImmutableSubstitution<? extends VariableOrGroundTerm> descendingSubstitution, Optional<ImmutableExpression> constraint, IQTree child) { return applyDescendingSubstitution(descendingSubstitution, child, (c, r) -> propagateDescendingSubstitutionToChild(c, r, constraint)); }
@AssistedInject private ConstructionNodeImpl(@Assisted ImmutableSet<Variable> projectedVariables, @Assisted ImmutableSubstitution<ImmutableTerm> substitution, TermNullabilityEvaluator nullabilityEvaluator) { this.projectedVariables = projectedVariables; this.substitution = substitution; this.nullabilityEvaluator = nullabilityEvaluator; this.optionalModifiers = Optional.empty(); this.childVariables = extractChildVariables(projectedVariables, substitution); validate(); }
getVariables()); newSubstitutions = traverseConstructionNode(relevantSubstitution, substitution, projectedVariables, newProjectedVariables); } catch (QueryNodeSubstitutionException e) { Optional<ImmutableQueryModifiers> newOptionalModifiers = updateOptionalModifiers(optionalModifiers, descendingSubstitution, substitutionToPropagate); ConstructionNode newConstructionNode = new ConstructionNodeImpl(newProjectedVariables, newSubstitutions.bindings, newOptionalModifiers, nullabilityEvaluator);
/** * * TODO: explain * */ private NewSubstitutionPair traverseConstructionNode( ImmutableSubstitution<? extends ImmutableTerm> tau, ImmutableSubstitution<? extends ImmutableTerm> formerTheta, ImmutableSet<Variable> formerV, ImmutableSet<Variable> newV) throws QueryNodeSubstitutionException { ImmutableSubstitution<ImmutableTerm> eta = ImmutableUnificationTools.computeMGUS(formerTheta, tau) .orElseThrow(() -> new QueryNodeSubstitutionException("The descending substitution " + tau + " is incompatible with " + this)); // Due to the current implementation of MGUS, the normalization should have no effect // (already in a normal form). Here for safety. ImmutableSubstitution<? extends ImmutableTerm> normalizedEta = normalizeEta(eta, newV); ImmutableSubstitution<ImmutableTerm> newTheta = extractNewTheta(normalizedEta, newV); ImmutableSubstitution<? extends ImmutableTerm> delta = computeDelta(formerTheta, newTheta, normalizedEta, formerV); return new NewSubstitutionPair(newTheta, delta); }
QueryNode childNode, IntermediateQuery query) { ImmutableSubstitution<ImmutableTerm> localSubstitution = getSubstitution(); ImmutableSet<Variable> boundVariables = localSubstitution.getImmutableMap().keySet(); newSubstitutionMapBuilder.build()); ConstructionNode newConstructionNode = new ConstructionNodeImpl(projectedVariables, newSubstitution, getOptionalModifiers(), nullabilityEvaluator);
@AssistedInject private ConstructionNodeImpl(@Assisted ImmutableSet<Variable> projectedVariables, @Assisted ImmutableSubstitution<ImmutableTerm> substitution, TermNullabilityEvaluator nullabilityEvaluator, ImmutableUnificationTools unificationTools, ConstructionNodeTools constructionNodeTools, ImmutableSubstitutionTools substitutionTools, SubstitutionFactory substitutionFactory, TermFactory termFactory, IntermediateQueryFactory iqFactory, ImmutabilityTools immutabilityTools, ExpressionEvaluator expressionEvaluator, CoreUtilsFactory coreUtilsFactory, OntopModelSettings settings) { super(substitutionFactory, iqFactory); this.projectedVariables = projectedVariables; this.substitution = substitution; this.nullabilityEvaluator = nullabilityEvaluator; this.unificationTools = unificationTools; this.constructionNodeTools = constructionNodeTools; this.substitutionTools = substitutionTools; this.substitutionFactory = substitutionFactory; this.termFactory = termFactory; this.nullValue = termFactory.getNullConstant(); this.iqFactory = iqFactory; this.immutabilityTools = immutabilityTools; this.expressionEvaluator = expressionEvaluator; this.coreUtilsFactory = coreUtilsFactory; this.childVariables = extractChildVariables(projectedVariables, substitution); if (settings.isTestModeEnabled()) validateNode(); }
.collect(ImmutableCollectors.toMap())); ImmutableSubstitution<NonFunctionalTerm> deltaC = extractDescendingSubstitution(newEta, v -> v, thetaC, thetaCBar, projectedVariables); ImmutableSubstitution<ImmutableTerm> gamma = extractDescendingSubstitution(deltaC, thetaFBar::apply, thetaF, thetaFBar, ImmutableSubstitution<NonFunctionalTerm> newDeltaC = gamma.getNonFunctionalTermFragment(); Optional<ImmutableExpression> f = computeF(m, thetaFBar, gamma, newDeltaC);
@Override public IQTree propagateDownConstraint(ImmutableExpression constraint, IQTree child) { try { Optional<ImmutableExpression> childConstraint = computeChildConstraint(substitution, Optional.of(constraint)); IQTree newChild = childConstraint .map(child::propagateDownConstraint) .orElse(child); return iqFactory.createUnaryIQTree(this, newChild); } catch (EmptyTreeException e) { return iqFactory.createEmptyNode(projectedVariables); } }
private Optional<ImmutableExpression> computeF(ImmutableMultimap<ImmutableTerm, ImmutableFunctionalTerm> m, ImmutableSubstitution<ImmutableFunctionalTerm> thetaFBar, ImmutableSubstitution<ImmutableTerm> gamma, ImmutableSubstitution<NonFunctionalTerm> newDeltaC) { ImmutableSet<Map.Entry<Variable, ImmutableFunctionalTerm>> thetaFBarEntries = thetaFBar.getImmutableMap().entrySet(); Stream<ImmutableExpression> thetaFRelatedExpressions = m.entries().stream() .filter(e -> !thetaFBarEntries.contains(e)) .map(e -> createEquality(thetaFBar.apply(e.getKey()), e.getValue())); Stream<ImmutableExpression> blockedExpressions = gamma.getImmutableMap().entrySet().stream() .filter(e -> !newDeltaC.isDefining(e.getKey())) .map(e -> createEquality(e.getKey(), e.getValue())); return immutabilityTools.foldBooleanExpressions(Stream.concat(thetaFRelatedExpressions, blockedExpressions)); }
@Override public IQTree applyDescendingSubstitutionWithoutOptimizing( ImmutableSubstitution<? extends VariableOrGroundTerm> descendingSubstitution, IQTree child) { return applyDescendingSubstitution(descendingSubstitution, child, (c, r) -> Optional.of(r.delta) .filter(delta -> !delta.isEmpty()) .map(c::applyDescendingSubstitutionWithoutOptimizing) .orElse(c)); }
private VariableNullability updateVariableNullability( ImmutableSubstitution<ImmutableTerm> nonNestedSubstitution, VariableNullability childNullability) { // TODO: find a better name ImmutableMap<Variable, Variable> nullabilityBindings = nonNestedSubstitution.getImmutableMap().entrySet().stream() .flatMap(e -> evaluateTermNullability(e.getValue(), childNullability, e.getKey()) .map(Stream::of) .orElseGet(Stream::empty)) .collect(ImmutableCollectors.toMap()); return childNullability.appendNewVariables(nullabilityBindings); }
/** * Without modifiers nor substitution. */ @AssistedInject private ConstructionNodeImpl(@Assisted ImmutableSet<Variable> projectedVariables, TermNullabilityEvaluator nullabilityEvaluator, ImmutableUnificationTools unificationTools, ConstructionNodeTools constructionNodeTools, ImmutableSubstitutionTools substitutionTools, SubstitutionFactory substitutionFactory, TermFactory termFactory, IntermediateQueryFactory iqFactory, ImmutabilityTools immutabilityTools, ExpressionEvaluator expressionEvaluator, CoreUtilsFactory coreUtilsFactory) { super(substitutionFactory, iqFactory); this.projectedVariables = projectedVariables; this.nullabilityEvaluator = nullabilityEvaluator; this.unificationTools = unificationTools; this.substitutionTools = substitutionTools; this.substitution = substitutionFactory.getSubstitution(); this.termFactory = termFactory; this.iqFactory = iqFactory; this.immutabilityTools = immutabilityTools; this.expressionEvaluator = expressionEvaluator; this.constructionNodeTools = constructionNodeTools; this.substitutionFactory = substitutionFactory; this.nullValue = termFactory.getNullConstant(); this.childVariables = extractChildVariables(projectedVariables, substitution); this.coreUtilsFactory = coreUtilsFactory; validateNode(); }
/** * * TODO: better handle the constraint * * Returns the new child */ private IQTree propagateDescendingSubstitutionToChild(IQTree child, PropagationResults<VariableOrGroundTerm> tauFPropagationResults, Optional<ImmutableExpression> constraint) throws EmptyTreeException { Optional<ImmutableExpression> descendingConstraint = computeChildConstraint(tauFPropagationResults.theta, constraint); return Optional.of(tauFPropagationResults.delta) .filter(delta -> !delta.isEmpty()) .map(delta -> child.applyDescendingSubstitution(delta, descendingConstraint)) .orElse(child); }
.map(e -> createEquality(thetaBar.apply(e.getKey()), tauF.apply(e.getValue()))), .map(e -> createEquality(tauCPropagationResults.delta.apply(e.getKey()), tauF.apply(e.getValue()))));
@AssistedInject private ConstructionNodeImpl(@Assisted ImmutableSet<Variable> projectedVariables, @Assisted ImmutableSubstitution<ImmutableTerm> substitution, @Assisted Optional<ImmutableQueryModifiers> optionalQueryModifiers, TermNullabilityEvaluator nullabilityEvaluator) { this.projectedVariables = projectedVariables; this.substitution = substitution; this.optionalModifiers = optionalQueryModifiers; this.nullabilityEvaluator = nullabilityEvaluator; this.childVariables = extractChildVariables(projectedVariables, substitution); validate(); }
/** * Without modifiers nor substitution. */ @AssistedInject private ConstructionNodeImpl(@Assisted ImmutableSet<Variable> projectedVariables, TermNullabilityEvaluator nullabilityEvaluator) { this.projectedVariables = projectedVariables; this.nullabilityEvaluator = nullabilityEvaluator; this.substitution = SUBSTITUTION_FACTORY.getSubstitution(); this.optionalModifiers = Optional.empty(); this.childVariables = extractChildVariables(projectedVariables, substitution); validate(); }