From 0574744921f5ae90629f2059122c5e8442e93c99 Mon Sep 17 00:00:00 2001 From: Riccardo Azzolini Date: Sat, 6 Oct 2018 16:22:55 +0200 Subject: [PATCH] Create PatternUtils helper class --- .../warppi/math/rules/dsl/PatternUtils.java | 72 +++++++++++++++++++ .../warppi/math/rules/dsl/VisitorPattern.java | 36 ---------- .../math/rules/dsl/patterns/SumPattern.java | 6 +- 3 files changed, 74 insertions(+), 40 deletions(-) create mode 100644 core/src/main/java/it/cavallium/warppi/math/rules/dsl/PatternUtils.java diff --git a/core/src/main/java/it/cavallium/warppi/math/rules/dsl/PatternUtils.java b/core/src/main/java/it/cavallium/warppi/math/rules/dsl/PatternUtils.java new file mode 100644 index 00000000..7911fe5c --- /dev/null +++ b/core/src/main/java/it/cavallium/warppi/math/rules/dsl/PatternUtils.java @@ -0,0 +1,72 @@ +package it.cavallium.warppi.math.rules.dsl; + +import it.cavallium.warppi.math.Function; +import it.cavallium.warppi.math.FunctionOperator; +import it.cavallium.warppi.math.functions.Subtraction; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * Contains helper methods which are useful for writing patterns. + */ +public class PatternUtils { + /** + * Gathers captured sub-functions from two matches, checking for equality + * of ones with the same name. + * + * @param match1 Sub-functions from one match. + * @param match2 Sub-functions from the other match. + * @return A Map containing all sub-functions, or an empty + * Optional if the same name is used to refer to + * non-equal sub-functions in the two matches. + */ + public static Optional> mergeMatches( + final Map match1, + final Map match2 + ) { + if (!checkSubFunctionEquality(match1, match2)) { + return Optional.empty(); + } + + final Map merged = new HashMap<>(); + merged.putAll(match1); + merged.putAll(match2); + return Optional.of(merged); + } + + private static boolean checkSubFunctionEquality( + final Map match1, + final Map match2 + ) { + for (final Map.Entry leftSubFunction : match1.entrySet()) { + final String key = leftSubFunction.getKey(); + if (match2.containsKey(key) + && !match2.get(key).equals(leftSubFunction.getValue())) { + return false; + } + } + return true; + } + + /** + * Tries to match the given patterns against the two parameters of a FunctionOperator. + * + * @param functionOperator The FunctionOperator to be matched. + * @param pattern1 The Pattern used to match functionOperator.parameter1. + * @param pattern2 The Pattern used to match functionOperator.parameter2. + * @return The combined result of the two matches. + * @see #mergeMatches(Map, Map) + */ + public static Optional> matchFunctionOperatorParameters( + final FunctionOperator functionOperator, + final Pattern pattern1, + final Pattern pattern2 + ) { + return pattern1.match(functionOperator.getParameter1()) + .flatMap(match1 -> pattern2.match(functionOperator.getParameter2()) + .flatMap(match2 -> mergeMatches(match1, match2)) + ); + } +} diff --git a/core/src/main/java/it/cavallium/warppi/math/rules/dsl/VisitorPattern.java b/core/src/main/java/it/cavallium/warppi/math/rules/dsl/VisitorPattern.java index 999dbead..eabf331a 100644 --- a/core/src/main/java/it/cavallium/warppi/math/rules/dsl/VisitorPattern.java +++ b/core/src/main/java/it/cavallium/warppi/math/rules/dsl/VisitorPattern.java @@ -9,7 +9,6 @@ import it.cavallium.warppi.math.functions.equations.EquationsSystem; import it.cavallium.warppi.math.functions.equations.EquationsSystemPart; import it.cavallium.warppi.math.functions.trigonometry.*; -import java.util.HashMap; import java.util.Map; import java.util.Optional; @@ -22,41 +21,6 @@ public abstract class VisitorPattern implements Pattern, FunctionVisitorMap containing all sub-functions, or an empty - * Optional if the same name is used to refer to - * non-equal sub-functions in the two matches. - */ - protected Optional> mergeMatches( - final Map match1, - final Map match2 - ) { - if (!checkSubFunctionEquality(match1, match2)) { - return Optional.empty(); - } - - final Map merged = new HashMap<>(); - merged.putAll(match1); - merged.putAll(match2); - return Optional.of(merged); - } - - private boolean checkSubFunctionEquality(final Map match1, final Map match2) { - for (Map.Entry leftSubFunction : match1.entrySet()) { - final String key = leftSubFunction.getKey(); - if (match2.containsKey(key) - && !match2.get(key).equals(leftSubFunction.getValue())) { - return false; - } - } - return true; - } - @Override public Optional> visit(final ArcCosine arcCosine) { return Optional.empty(); diff --git a/core/src/main/java/it/cavallium/warppi/math/rules/dsl/patterns/SumPattern.java b/core/src/main/java/it/cavallium/warppi/math/rules/dsl/patterns/SumPattern.java index babe2cb8..b174c01c 100644 --- a/core/src/main/java/it/cavallium/warppi/math/rules/dsl/patterns/SumPattern.java +++ b/core/src/main/java/it/cavallium/warppi/math/rules/dsl/patterns/SumPattern.java @@ -4,6 +4,7 @@ import it.cavallium.warppi.math.Function; import it.cavallium.warppi.math.MathContext; import it.cavallium.warppi.math.functions.Sum; import it.cavallium.warppi.math.rules.dsl.Pattern; +import it.cavallium.warppi.math.rules.dsl.PatternUtils; import it.cavallium.warppi.math.rules.dsl.VisitorPattern; import java.util.Map; @@ -23,10 +24,7 @@ public class SumPattern extends VisitorPattern { @Override public Optional> visit(final Sum sum) { - return left.match(sum.getParameter1()) - .flatMap(leftMatch -> right.match(sum.getParameter2()) - .flatMap(rightMatch -> mergeMatches(leftMatch, rightMatch)) - ); + return PatternUtils.matchFunctionOperatorParameters(sum, left, right); } @Override