public Optional<ImmutableExpression> foldBooleanExpressions( ImmutableExpression... conjunctionOfExpressions) { return foldBooleanExpressions(ImmutableList.copyOf(conjunctionOfExpressions)); }
public static Optional<ImmutableExpression> foldBooleanExpressions( ImmutableExpression... conjunctionOfExpressions) { return foldBooleanExpressions(ImmutableList.copyOf(conjunctionOfExpressions)); }
private ImmutableExpression getCombinedExpression(ImmutableExpression expressionToPropagate, JoinOrFilterNode recipientNode) { Optional<ImmutableExpression> recipientNodeFormerExpression = recipientNode.getOptionalFilterCondition(); if (recipientNodeFormerExpression.isPresent()) { return ImmutabilityTools.foldBooleanExpressions(recipientNodeFormerExpression.get(), expressionToPropagate) .orElseThrow(() -> new IllegalStateException("Folding two existing expressions should produce an expression")); } return expressionToPropagate; }
public Optional<ImmutableExpression> foldBooleanExpressions( Stream<ImmutableExpression> conjunctionOfExpressions) { return foldBooleanExpressions(conjunctionOfExpressions .collect(ImmutableCollectors.toList())); }
public static Optional<ImmutableExpression> foldBooleanExpressions( Stream<ImmutableExpression> conjunctionOfExpressions) { return foldBooleanExpressions(conjunctionOfExpressions .collect(ImmutableCollectors.toList())); }
private ImmutableExpression getCombinedExpression(ImmutableExpression expressionToPropagate, JoinOrFilterNode recipientNode) { Optional<ImmutableExpression> recipientNodeFormerExpression = recipientNode.getOptionalFilterCondition(); if (recipientNodeFormerExpression.isPresent()) { return immutabilityTools.foldBooleanExpressions(recipientNodeFormerExpression.get(), expressionToPropagate) .orElseThrow(() -> new IllegalStateException("Folding two existing expressions should produce an expression")); } return expressionToPropagate; }
private ImmutableExpression convertIntoBooleanExpression(Collection<VariableGroundTermPair> pairs) { ImmutableList.Builder<ImmutableExpression> booleanExpressionBuilder = ImmutableList.builder(); for (VariableGroundTermPair pair : pairs ) { booleanExpressionBuilder.add(TERM_FACTORY.getImmutableExpression( ExpressionOperation.EQ, pair.variable, pair.groundTerm)); } Optional<ImmutableExpression> optionalFoldExpression = ImmutabilityTools.foldBooleanExpressions( booleanExpressionBuilder.build()); return optionalFoldExpression.get(); }
private ImmutableExpression computeExpression(ImmutableList<? extends VariableOrGroundTerm> formerRightArguments, ImmutableList<? extends VariableOrGroundTerm> newRightArguments) { Stream<ImmutableExpression> expressions = IntStream.range(0, formerRightArguments.size()) .filter(i -> !formerRightArguments.get(i).equals(newRightArguments.get(i))) .boxed() .map(i -> termFactory.getImmutableExpression(EQ, newRightArguments.get(i), formerRightArguments.get(i))); return immutabilityTools.foldBooleanExpressions(expressions) .orElseThrow(() -> new MinorOntopInternalBugException("A boolean expression was expected")); }
private ImmutableExpression computeExpression(ImmutableList<? extends VariableOrGroundTerm> formerRightArguments, ImmutableList<? extends VariableOrGroundTerm> newRightArguments) { Stream<ImmutableExpression> expressions = IntStream.range(0, formerRightArguments.size()) .filter(i -> !formerRightArguments.get(i).equals(newRightArguments.get(i))) .boxed() .map(i -> termFactory.getImmutableExpression(EQ, newRightArguments.get(i), formerRightArguments.get(i))); return ImmutabilityTools.foldBooleanExpressions(expressions) .orElseThrow(() -> new MinorOntopInternalBugException("A boolean expression was expected")); }
private ImmutableExpression convertIntoEqualities(ImmutableMap<Integer, VariableRenaming> renamingMap) { if (renamingMap.isEmpty()) { throw new IllegalArgumentException("The renaming map must not be empty"); } ImmutableList.Builder<ImmutableExpression> equalityBuilder = ImmutableList.builder(); for (VariableRenaming renaming : renamingMap.values()) { equalityBuilder.add(TERM_FACTORY.getImmutableExpression(ExpressionOperation.EQ, renaming.originalVariable, renaming.newVariable)); } return ImmutabilityTools.foldBooleanExpressions(equalityBuilder.build()).get(); }
private void updateIndirectRecipientNode(QueryTreeComponent treeComponent, QueryNode targetNode, Collection<ImmutableExpression> additionalExpressions) { ImmutableExpression foldedExpression = immutabilityTools.foldBooleanExpressions( ImmutableList.copyOf(additionalExpressions)).get(); FilterNode newFilterNode = iqFactory.createFilterNode(foldedExpression); treeComponent.insertParent(targetNode, newFilterNode); }
private void updateIndirectRecipientNode(QueryTreeComponent treeComponent, QueryNode targetNode, Collection<ImmutableExpression> additionalExpressions) { ImmutableExpression foldedExpression = ImmutabilityTools.foldBooleanExpressions( ImmutableList.copyOf(additionalExpressions)).get(); FilterNode newFilterNode = iqFactory.createFilterNode(foldedExpression); treeComponent.insertParent(targetNode, newFilterNode); }
private Optional<ImmutableExpression> getRetainedSubExpression (ImmutableSet<ImmutableExpression> propagatedExpressions, CommutativeJoinOrFilterNode provider) { ImmutableExpression fullBooleanExpression = provider.getOptionalFilterCondition() .orElseThrow(() -> new IllegalStateException("The provider is expected to have a filtering condition")); // conjuncts which will not be propagated up from this child return immutabilityTools.foldBooleanExpressions( fullBooleanExpression.flattenAND().stream() .filter(e -> !propagatedExpressions.contains(e)) ); }
@SuppressWarnings("OptionalUsedAsFieldOrParameterType") private Optional<ImmutableExpression> applyRightSubstitutionToLJCondition( Optional<ImmutableExpression> ljCondition, ImmutableSubstitution<ImmutableTerm> selectedSubstitution, ImmutableSet<Variable> leftVariables) { Stream<ImmutableExpression> equalitiesToInsert = selectedSubstitution.getImmutableMap().entrySet().stream() .filter(e -> leftVariables.contains(e.getKey())) .map(e -> termFactory.getImmutableExpression(EQ, e.getKey(), e.getValue())); return immutabilityTools.foldBooleanExpressions( Stream.concat( ljCondition .map(selectedSubstitution::applyToBooleanExpression) .map(Stream::of) .orElseGet(Stream::empty), equalitiesToInsert)); }
private Optional<ImmutableExpression> getRetainedSubExpression (ImmutableSet<ImmutableExpression> propagatedExpressions, CommutativeJoinOrFilterNode provider) { ImmutableExpression fullBooleanExpression = provider.getOptionalFilterCondition() .orElseThrow(() -> new IllegalStateException("The provider is expected to have a filtering condition")); // conjuncts which will not be propagated up from this child return ImmutabilityTools.foldBooleanExpressions( fullBooleanExpression.flattenAND().stream() .filter(e -> !propagatedExpressions.contains(e)) ); }
/** * TODO: explain */ private static void updateNewJoinLikeNode(QueryTreeComponent treeComponent, JoinLikeNode originalNode, ImmutableExpression newEqualities) { Optional<ImmutableExpression> optionalOriginalFilterCondition = originalNode.getOptionalFilterCondition(); ImmutableExpression newFilteringCondition; if (optionalOriginalFilterCondition.isPresent()) { newFilteringCondition = ImmutabilityTools.foldBooleanExpressions(optionalOriginalFilterCondition.get(), newEqualities).get(); } else { newFilteringCondition = newEqualities; } JoinLikeNode newNode = originalNode.changeOptionalFilterCondition(Optional.of(newFilteringCondition)); treeComponent.replaceNode(originalNode, newNode); }
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)); }
private Optional<ImmutableExpression> computeNonOptimizedCondition(Optional<ImmutableExpression> initialJoiningCondition, ImmutableSubstitution<? extends ImmutableTerm> substitution, InjectiveVar2VarSubstitution freshRenaming) { Stream<ImmutableExpression> expressions = Stream.concat( initialJoiningCondition .map(substitution::applyToBooleanExpression) .map(ImmutableExpression::flattenAND) .orElseGet(ImmutableSet::of) .stream(), freshRenaming.getImmutableMap().entrySet().stream() .map(r -> termFactory.getImmutableExpression(EQ, substitution.applyToVariable(r.getKey()), r.getValue()))); return getImmutabilityTools().foldBooleanExpressions(expressions); }
/** * TODO: explain */ protected Optional<ExpressionEvaluator.EvaluationResult> computeAndEvaluateNewCondition( ImmutableSubstitution<? extends ImmutableTerm> substitution, Optional<ImmutableExpression> optionalNewEqualities) { Optional<ImmutableExpression> updatedExistingCondition = getOptionalFilterCondition() .map(substitution::applyToBooleanExpression); Optional<ImmutableExpression> newCondition = immutabilityTools.foldBooleanExpressions( Stream.concat( Stream.of(updatedExistingCondition), Stream.of(optionalNewEqualities)) .filter(Optional::isPresent) .map(Optional::get) .flatMap(e -> e.flattenAND().stream())); return newCondition .map(cond -> createExpressionEvaluator() .evaluateExpression(cond)); }
private N createNewFocusNodeWithAdditionalConditions(PullVariableOutOfSubTreeProposal<N> proposal) { N focusNode = proposal.getFocusNode(); Stream<ImmutableExpression> newConditions = proposal.getRenamingSubstitution().getImmutableMap().entrySet().stream() .map(e -> TERM_FACTORY.getImmutableExpression(EQ, e.getKey(), e.getValue())); Stream<ImmutableExpression> otherConditions = focusNode.getOptionalFilterCondition() .map(exp -> exp.flattenAND().stream()) .orElseGet(Stream::of); return (N) focusNode.changeOptionalFilterCondition( ImmutabilityTools.foldBooleanExpressions(Stream.concat(otherConditions, newConditions))); }