diff --git a/src/main/java/inference/In.java b/src/main/java/inference/In.java new file mode 100644 index 0000000..b354543 --- /dev/null +++ b/src/main/java/inference/In.java @@ -0,0 +1,182 @@ +package inference; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import models.algebra.Constant; +import models.algebra.Variable; +import models.formulas.meta.MetaEquationFormula; +import models.terms.EvaluatableTerm; +import models.terms.RDLTerm; +import models.terms.meta.MatchConstraint; +import models.terms.meta.MetaDependencyTerm; +import models.terms.meta.MetaDynamicDependencyTerm; +import models.terms.meta.MetaEvaluatableTermVariable; +import models.terms.meta.MetaRDLTerm; +import models.terms.meta.MetaResource; +import models.terms.meta.MetaTermGenerator; + + +@RequiredArgsConstructor +@Getter +public class In { + + private final EvaluatableTerm leftSideHand; + private final EvaluatableTerm rightSideHand; + + private static final MetaDependencyTerm domainMembershipConclusionLeftSideHand = new MetaDynamicDependencyTerm( + new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + context.put("1-" + curDepth, curIndex); + context.put("depth1", maxDepth); + if (curDepth == maxDepth && curIndex == 0) { + return new MetaEvaluatableTermVariable(new Variable("ue1")); + } else if (curIndex == 0) { + return new MetaDynamicDependencyTerm(this); + } + int used = (Integer) context.getOrDefault("used1", 4); + context.put("used1", used + 1); + curIndex -= 1; + if (curIndex % 2 == 0) { + return new MetaEvaluatableTermVariable(new Variable("te" + used / 2)); + } + return new MetaEvaluatableTermVariable(new Variable("ue" + used / 2)); + } + } + ); + + private static final MetaDependencyTerm domainMembershipConclusionRightSideHand = new MetaDynamicDependencyTerm( + new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + context.put("2-" + curDepth, curIndex); + context.put("depth2", maxDepth); + if (curDepth == maxDepth && curIndex == 0) { + return new MetaEvaluatableTermVariable(new Variable("te1")); + } else if (curIndex == 0) { + return new MetaDynamicDependencyTerm(this); + } + int used = (Integer) context.getOrDefault("used2", 4); + context.put("used2", used + 1); + curIndex -= 1; + if (curIndex % 2 == 0) { + return new MetaEvaluatableTermVariable(new Variable("te" + used / 2)); + } + return new MetaEvaluatableTermVariable(new Variable("ue" + used / 2)); + } + } + ); + + private static final MetaDynamicDependencyTerm domainMembershipAssumptionLeftSideHand = new MetaDynamicDependencyTerm( + new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + if (curIndex - 1 >= (Integer) context.get("1-" + curDepth)) { + return null; + } + if (curIndex == 0 && curDepth == maxDepth) { + return new MetaDependencyTerm( + new MetaEvaluatableTermVariable(new Variable("se")), + new MetaEvaluatableTermVariable(new Variable("te1")), + new MetaEvaluatableTermVariable(new Variable("ue1")) + ); + } + else if (curIndex == 0) { + return new MetaDynamicDependencyTerm(this); + } + curIndex -= 1; + int used = (Integer) context.getOrDefault("used3", 4); + context.put("used3", used + 1); + if (curIndex % 2 == 0) { + return new MetaEvaluatableTermVariable(new Variable("te" + used / 2)); + } + return new MetaEvaluatableTermVariable(new Variable("ue" + used / 2)); + } + } + ); + + private static final MetaEvaluatableTermVariable codomainMembershipConclusionLeftSideHand = new MetaEvaluatableTermVariable(new Variable("ve")); + private static final MetaEvaluatableTermVariable codomainMembershipConclusionRightSideHand = new MetaEvaluatableTermVariable(new Variable("se")); + + public Set deriveRule() { + Set result = new HashSet<>(); + result.addAll(deriveByDomainMemberShip()); + result.addAll(deriveByCodomainMemberShip()); + return result; + } + + private Set deriveByDomainMemberShip() { + Set result = new HashSet<>(); + Set leftMatchResult = domainMembershipConclusionLeftSideHand.isMatchedBy(leftSideHand); + Set rightMatchResult = domainMembershipConclusionRightSideHand.isMatchedBy(rightSideHand, leftMatchResult); + for (MatchConstraint constraint: rightMatchResult) { + int used1 = (Integer) constraint.getContext().getOrDefault("used1", 1); + int used2 = (Integer) constraint.getContext().getOrDefault("used2", 1); + int depth1 = (Integer) constraint.getContext().get("depth1"); + int depth2 = (Integer) constraint.getContext().get("depth2"); + if (used1 != used2) { + continue; + } + if (depth1 != depth2) { + continue; + } + boolean flg = false; + for (int i = 1; i < depth1; i++) { + int d1 = (Integer) constraint.getContext().get("1-" + i); + int d2 = (Integer) constraint.getContext().get("2-" + i); + if (d1 != d2) { + flg = true; + break; + } + } + if (flg) continue; + Map mapping = new HashMap<>(); + for (Variable variable: constraint.getBinding().keySet()) { + mapping.put(new MetaEvaluatableTermVariable(variable), constraint.getBinding().get(variable)); + } + MetaRDLTerm left = (MetaRDLTerm)domainMembershipAssumptionLeftSideHand.generate(10000, depth1, constraint.cloneContext()).replace(mapping); + MetaResource right = new MetaResource(new Variable("c"), new Constant("0")); + result.add(new MetaEquationFormula(left, right)); + } + return result; + } + + private Set deriveByCodomainMemberShip() { + Set result = new HashSet<>(); + Set leftMatchResult = codomainMembershipConclusionLeftSideHand.isMatchedBy(leftSideHand); + Set rightMatchResult = codomainMembershipConclusionRightSideHand.isMatchedBy(rightSideHand, leftMatchResult); + for (MatchConstraint constraint : rightMatchResult) { + Map mapping = new HashMap<>(); + for (Variable variable: constraint.getBinding().keySet()) { + mapping.put(new MetaEvaluatableTermVariable(variable), constraint.getBinding().get(variable)); + } + MetaRDLTerm left = new MetaDynamicDependencyTerm( + new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + curIndex -= 1; + if (curIndex % 2 == 0) { + return new MetaEvaluatableTermVariable(new Variable("te" + curIndex / 2)); + } + return new MetaEvaluatableTermVariable(new Variable("ue" + curIndex / 2)); + } + }, + constraint.getBinding().get(codomainMembershipConclusionRightSideHand.getVariableName()) + ); + result.add(new MetaEquationFormula(left, constraint.getBinding().get(codomainMembershipConclusionLeftSideHand.getVariableName()))); + } + return result; + } + + + @Override + public String toString() { + return leftSideHand.toString() + " in " + rightSideHand.toString(); + } + +} diff --git a/src/main/java/inference/InferenceRule.java b/src/main/java/inference/InferenceRule.java index d653954..3a65936 100644 --- a/src/main/java/inference/InferenceRule.java +++ b/src/main/java/inference/InferenceRule.java @@ -10,7 +10,11 @@ import exceptions.SubstituteFailedException; import lombok.Getter; import models.formulas.Formula; +import models.formulas.meta.MetaDependencyFormula; import models.formulas.meta.MetaFormula; +import models.terms.DependencyTerm; +import models.terms.EvaluatableTerm; +import models.terms.Resource; import models.terms.meta.MatchConstraint; import models.terms.meta.MetaRDLTerm; import models.terms.meta.MetaVariable; @@ -96,7 +100,6 @@ } protected Set apply(List assumptions, MatchConstraint constraint) { - Map context = new HashMap<>(); if (assumptions.size() < getAssumptionSize()) { return new HashSet<>(); } @@ -104,7 +107,7 @@ Set result = new HashSet<>(); result.add(constraint); for (int i = 0; i < getAssumptionSize(); i++) { - result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result, context); + result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result); if (result.isEmpty()) { return new HashSet<>(); } @@ -118,7 +121,7 @@ for (int j = 0; j < this.repetitionAssumptions.size(); j++) { Formula assumption = assumptions.get(this.assumptions.size() + i * this.repetitionAssumptions.size() + j); MetaFormula metaAssumption = metaAssumptions.get(j); - result = metaAssumption.isMatchedBy(assumption, result, context); + result = metaAssumption.isMatchedBy(assumption, result); if (result.isEmpty()) { return new HashSet<>(); } @@ -130,9 +133,9 @@ try { int maxIndex = conclusionMaxIndexCalculator != null ? conclusionMaxIndexCalculator.calculate(assumptions) : 0; int maxDepth = conclusionMaxDepthCalculator != null ? conclusionMaxDepthCalculator.calculate(assumptions) : 1; - context.put("maxIndex", maxIndex); - context.put("maxDepth", maxDepth); - subRes.add(conclusion.substitution(con.getBinding(), context)); + con.getContext().put("maxIndex", maxIndex); + con.getContext().put("maxDepth", maxDepth); + subRes.add(conclusion.substitution(con.getBinding(), con.getContext())); } catch (SubstituteFailedException e) { continue; } @@ -140,6 +143,28 @@ return subRes; } + private static Set requiredAssumptions(EvaluatableTerm term) { + if (term instanceof Resource) { + return new HashSet<>(); + } + DependencyTerm depTerm = (DependencyTerm) term; + Set result = new HashSet<>(); + EvaluatableTerm dependingTerm = depTerm.getDependingTerm(); + List dependedTerms = depTerm.getDependedTerms(); + List argumentTerms = depTerm.getArgumentTerms(); + if (dependingTerm instanceof Resource) { + result.add(new MetaDependencyFormula(dependingTerm, dependedTerms)); + for (int i = 0; i < dependedTerms.size(); i++) { + EvaluatableTerm dependedTerm = dependedTerms.get(i); + EvaluatableTerm argTerm = argumentTerms.get(i); + In in = new In(dependedTerm, argTerm); + } + } + + return result; + } + + public int getAssumptionSize() { return this.assumptions.size(); } diff --git a/src/main/java/inference/axioms/MapComposition.java b/src/main/java/inference/axioms/MapComposition.java index e6f30b0..e15b026 100644 --- a/src/main/java/inference/axioms/MapComposition.java +++ b/src/main/java/inference/axioms/MapComposition.java @@ -126,7 +126,7 @@ return new HashSet<>(); } for (int i = 0; i < 2; i++) { - matchResult = this.assumptions.get(i).isMatchedBy(assumptions.get(i), matchResult, context); + matchResult = this.assumptions.get(i).isMatchedBy(assumptions.get(i), matchResult); if (matchResult.isEmpty()) { return new HashSet<>(); } diff --git a/src/main/java/inference/axioms/RedundancyElimination.java b/src/main/java/inference/axioms/RedundancyElimination.java index 3d28f79..e30ff40 100644 --- a/src/main/java/inference/axioms/RedundancyElimination.java +++ b/src/main/java/inference/axioms/RedundancyElimination.java @@ -75,7 +75,7 @@ Set result = new HashSet<>(); result.add(constraint); for (int i = 0; i < getAssumptionSize(); i++) { - result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result, context); + result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result); if (result.isEmpty()) { return new HashSet<>(); } @@ -89,7 +89,7 @@ for (int j = 0; j < this.repetitionAssumptions.size(); j++) { Formula assumption = assumptions.get(this.assumptions.size() + i * this.repetitionAssumptions.size() + j); MetaFormula metaAssumption = metaAssumptions.get(j); - result = metaAssumption.isMatchedBy(assumption, result, context); + result = metaAssumption.isMatchedBy(assumption, result); if (result.isEmpty()) { return new HashSet<>(); } diff --git a/src/main/java/inference/axioms/RightNormalization.java b/src/main/java/inference/axioms/RightNormalization.java index f3b5427..c214870 100644 --- a/src/main/java/inference/axioms/RightNormalization.java +++ b/src/main/java/inference/axioms/RightNormalization.java @@ -155,7 +155,7 @@ result.add(constraint); Map context = new HashMap<>(); for (int i = 0; i < 3; i++) { - result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result, context); + result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result); if (result.isEmpty()) { return new HashSet<>(); } diff --git a/src/main/java/inference/axioms/UncurriedMapping.java b/src/main/java/inference/axioms/UncurriedMapping.java index 5854252..2c168c7 100644 --- a/src/main/java/inference/axioms/UncurriedMapping.java +++ b/src/main/java/inference/axioms/UncurriedMapping.java @@ -114,7 +114,7 @@ for (int i = 0; i < getAssumptionSize(); i++) { context.put("maxOrder", maxOrder); - result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result, context); + result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result); if (result.isEmpty()) { return new HashSet<>(); } diff --git a/src/main/java/inference/axioms/Uncurrying.java b/src/main/java/inference/axioms/Uncurrying.java index da1d0a2..93f0dc0 100644 --- a/src/main/java/inference/axioms/Uncurrying.java +++ b/src/main/java/inference/axioms/Uncurrying.java @@ -1,5 +1,4 @@ package inference.axioms; -import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -191,14 +190,13 @@ protected Set apply(List assumptions, MatchConstraint constraint) { Set result = new HashSet<>(); - Map context = new HashMap<>(); result.add(constraint); if (assumptions.size() < 2) { return new HashSet<>(); } for (int i = 0; i < 3; i++) { - result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result, context); + result = this.assumptions.get(i).isMatchedBy(assumptions.get(i), result); if (result.isEmpty()) { return new HashSet<>(); } @@ -218,7 +216,7 @@ ), new MetaEvaluatableTermVariable(new Variable("x" + d + "_" + i), ExpressionUtils.parse("n-" + (depth - d))) ); - result = mef.isMatchedBy(assumption, result, context); + result = mef.isMatchedBy(assumption, result); if (result.isEmpty()) { return new HashSet<>(); } @@ -231,11 +229,11 @@ try { int maxIndex = 10000; int maxDepth = depth; - context.put("maxIndex", maxIndex); - context.put("maxDepth", maxDepth); - context.put("m", con.getOrderConstraint().get(new Variable("m")).getOrder()); - context.put("n", con.getOrderConstraint().get(new Variable("n")).getOrder()); - subRes.add(conclusion.substitution(con.getBinding(), context)); + con.getContext().put("maxIndex", maxIndex); + con.getContext().put("maxDepth", maxDepth); + con.getContext().put("m", con.getOrderConstraint().get(new Variable("m")).getOrder()); + con.getContext().put("n", con.getOrderConstraint().get(new Variable("n")).getOrder()); + subRes.add(conclusion.substitution(con.getBinding(), con.getContext())); } catch (SubstituteFailedException e) { continue; } diff --git a/src/main/java/models/formulas/meta/MetaDependencyFormula.java b/src/main/java/models/formulas/meta/MetaDependencyFormula.java index e0095f7..9006d47 100644 --- a/src/main/java/models/formulas/meta/MetaDependencyFormula.java +++ b/src/main/java/models/formulas/meta/MetaDependencyFormula.java @@ -37,25 +37,25 @@ this.dependency = dependency; } - public MetaDependencyFormula(MetaRDLTerm dependingTerm, List dependedTerms) { + public MetaDependencyFormula(RDLTerm dependingTerm, List dependedTerms) { this.dependency = new MetaDependency(dependingTerm, dependedTerms); } - public MetaDependencyFormula(MetaRDLTerm dependingTerm, MetaRDLTerm ...dependedTerms) { + public MetaDependencyFormula(RDLTerm dependingTerm, RDLTerm ...dependedTerms) { this(dependingTerm, Arrays.asList(dependedTerms)); } - public MetaDependencyFormula(MetaRDLTerm dependingTerm, MetaTermGenerator generator) { + public MetaDependencyFormula(RDLTerm dependingTerm, MetaTermGenerator generator) { this.dependency = new MetaDynamicDependency(generator, dependingTerm); } @Override - public Set isMatchedBy(Formula formula, MatchConstraint constraint, Map context) { + public Set isMatchedBy(Formula formula, MatchConstraint constraint) { if (! (formula instanceof DependencyFormula)) { return new HashSet<>(); } DependencyFormula dep = (DependencyFormula) formula; - return dependency.isMatchedBy(dep.getDependency(), constraint, context); + return dependency.isMatchedBy(dep.getDependency(), constraint); } @@ -65,7 +65,7 @@ } @Override - public MetaDependencyFormula replace(Map mapping) { + public MetaDependencyFormula replace(Map mapping) { return new MetaDependencyFormula(this.dependency.replace(mapping)); } diff --git a/src/main/java/models/formulas/meta/MetaEquationFormula.java b/src/main/java/models/formulas/meta/MetaEquationFormula.java index ca3c2bb..b048a56 100644 --- a/src/main/java/models/formulas/meta/MetaEquationFormula.java +++ b/src/main/java/models/formulas/meta/MetaEquationFormula.java @@ -18,47 +18,80 @@ @Getter public class MetaEquationFormula extends MetaFormula { - private MetaRDLTerm leftSideHand; - private MetaRDLTerm rightSideHand; + private RDLTerm leftSideHand; + private RDLTerm rightSideHand; - public MetaEquationFormula(MetaRDLTerm left, MetaRDLTerm right) { + public MetaEquationFormula(RDLTerm left, RDLTerm right) { if (! left.isEvaluatableTerm()) { throw new IllegalTypeException(); } if (! right.isEvaluatableTerm()) { throw new IllegalTypeException(); } - this.leftSideHand = left; this.rightSideHand = right; } @Override - public Set isMatchedBy(Formula formula, MatchConstraint constraint, Map context) { + public Set isMatchedBy(Formula formula, MatchConstraint constraint) { Set result = new HashSet<>(); if (! (formula instanceof EquationFormula)) { return result; } + result.add(constraint); EquationFormula eq = (EquationFormula) formula; - result = leftSideHand.isMatchedBy(eq.getLeftSideHand(), constraint, context); - return rightSideHand.isMatchedBy(eq.getRightSideHand(), result, context); + if (leftSideHand instanceof MetaRDLTerm metaLeft) { + result = metaLeft.isMatchedBy(eq.getLeftSideHand(), result); + } else { + if (! leftSideHand.equals(eq.getLeftSideHand())) { + return new HashSet<>(); + } + } + if (rightSideHand instanceof MetaRDLTerm metaRight) { + result = metaRight.isMatchedBy(eq.getRightSideHand(), result); + } else { + if (! rightSideHand.equals(eq.getRightSideHand())) { + return new HashSet<>(); + } + } + return result; } @Override public EquationFormula substitution(Map binding, Map context) { - return new EquationFormula((EvaluatableTerm) leftSideHand.substitute(binding, context), (EvaluatableTerm) rightSideHand.substitute(binding, context)); + RDLTerm left = leftSideHand; + RDLTerm right = rightSideHand; + if (leftSideHand instanceof MetaRDLTerm metaLeft) { + left = metaLeft.substitute(binding, context); + } + if (rightSideHand instanceof MetaRDLTerm metaRight) { + right = metaRight.substitute(binding, context); + } + return new EquationFormula((EvaluatableTerm) left, (EvaluatableTerm) right); } @Override - public MetaEquationFormula replace(Map mapping) { - return new MetaEquationFormula(this.leftSideHand.replace(mapping), this.rightSideHand.replace(mapping)); + public MetaEquationFormula replace(Map mapping) { + RDLTerm left = leftSideHand; + RDLTerm right = rightSideHand; + if (leftSideHand instanceof MetaRDLTerm metaLeft) { + left = metaLeft.replace(mapping); + } + if (rightSideHand instanceof MetaRDLTerm metaRight) { + right = metaRight.replace(mapping); + } + return new MetaEquationFormula(left, right); } @Override public Set getAllVariables() { Set result = new HashSet<>(); - result.addAll(this.leftSideHand.getAllVariables()); - result.addAll(this.rightSideHand.getAllVariables()); + if (leftSideHand instanceof MetaRDLTerm metaLeft) { + result.addAll(metaLeft.getAllVariables()); + } + if (rightSideHand instanceof MetaRDLTerm metaRight) { + result.addAll(metaRight.getAllVariables()); + } return result; } diff --git a/src/main/java/models/formulas/meta/MetaFormula.java b/src/main/java/models/formulas/meta/MetaFormula.java index 3cbc04f..b004432 100644 --- a/src/main/java/models/formulas/meta/MetaFormula.java +++ b/src/main/java/models/formulas/meta/MetaFormula.java @@ -1,6 +1,5 @@ package models.formulas.meta; -import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; @@ -12,21 +11,13 @@ import models.terms.meta.MetaRDLTerm; import models.terms.meta.MetaVariable; -public abstract class MetaFormula { +public abstract class MetaFormula extends Formula{ public Set isMatchedBy(Formula formula) { - return isMatchedBy(formula, new MatchConstraint(new HashMap<>(), new HashMap<>())); + return isMatchedBy(formula, MatchConstraint.createDefault()); } - public Set isMatchedBy(Formula formula, Map context) { - return isMatchedBy(formula, MatchConstraint.createDefault(), context); - } - - public abstract Set isMatchedBy(Formula formula, MatchConstraint constraint, Map context); - - public Set isMatchedBy(Formula formula, MatchConstraint constraint) { - return isMatchedBy(formula, constraint, new HashMap<>()); - } + public abstract Set isMatchedBy(Formula formula, MatchConstraint constraint); public Set isMatchedBy(Formula formula, Set constraints) { @@ -37,23 +28,11 @@ return result; } - public Set isMatchedBy(Formula formula, Set constraints, Map context) { - Set result = new HashSet<>(); - for (MatchConstraint constraint: constraints) { - result.addAll(isMatchedBy(formula, constraint, context)); - } - return result; - } - public abstract Formula substitution(Map binding, Map context); public abstract Set getSubTerms(Class clazz); - public abstract MetaFormula replace(Map mapping); + public abstract MetaFormula replace(Map mapping); public abstract Set getAllVariables(); - public abstract String toString(); - public abstract boolean equals(Object another); - public abstract int hashCode(); - } diff --git a/src/main/java/models/terms/RDLTerm.java b/src/main/java/models/terms/RDLTerm.java index eb2a8e9..e45cd6b 100644 --- a/src/main/java/models/terms/RDLTerm.java +++ b/src/main/java/models/terms/RDLTerm.java @@ -24,6 +24,26 @@ public abstract int getMaxDepth(); + public boolean isVariable() { + return false; + } + + public boolean isDependency() { + return this instanceof Dependency; + } + + public boolean isEvaluatableTerm() { + return this instanceof EvaluatableTerm; + } + + public boolean isDependencyTerm() { + return this instanceof DependencyTerm; + } + + public boolean isResource() { + return this instanceof Resource; + } + @Override public abstract String toString(); diff --git a/src/main/java/models/terms/meta/MatchConstraint.java b/src/main/java/models/terms/meta/MatchConstraint.java index 5d40446..4c8dfb0 100644 --- a/src/main/java/models/terms/meta/MatchConstraint.java +++ b/src/main/java/models/terms/meta/MatchConstraint.java @@ -15,10 +15,12 @@ private final Map binding; private final Map orderConstraint; + private final Map context; public MatchConstraint(MatchConstraint constraint) { this.binding = constraint.getBinding(); this.orderConstraint = constraint.getOrderConstraint(); + this.context = constraint.cloneContext(); } public Map getBinding() { @@ -44,9 +46,17 @@ public void setOrderConstraint(Variable key, OrderConstraint constraint, int value) { this.orderConstraint.get(key).setConstraint(value, constraint); } + + public Map getContext() { + return this.context; + } + public Map cloneContext() { + return new HashMap<>(this.context); + } + public static MatchConstraint createDefault() { - return new MatchConstraint(new HashMap<>(), new HashMap<>()); + return new MatchConstraint(new HashMap<>(), new HashMap<>(), new HashMap<>()); } } diff --git a/src/main/java/models/terms/meta/MetaDependency.java b/src/main/java/models/terms/meta/MetaDependency.java index 857186b..ee84213 100644 --- a/src/main/java/models/terms/meta/MetaDependency.java +++ b/src/main/java/models/terms/meta/MetaDependency.java @@ -44,7 +44,7 @@ } @Override - public Set isMatchedBy(RDLTerm another, MatchConstraint constraint, Map context) { + public Set isMatchedBy(RDLTerm another, MatchConstraint constraint) { Set result = new HashSet<>(); if (! another.getClass().isAssignableFrom(this.termType.getBaseTermClass())) { return result; @@ -66,8 +66,8 @@ MetaRDLTerm metaChild = (MetaRDLTerm) dependingChild; return metaChild.isMatchedBy(anotherDependingChild, constraint); } else { - if (!(dependingChild.equals(anotherDependingChild))) { - return new HashSet<>(); + if (dependingChild.equals(anotherDependingChild)) { + return new HashSet<>(Set.of(constraint)); } } return new HashSet<>(); @@ -128,20 +128,14 @@ } @Override - public MetaRDLTerm replace(Map mapping) { + public MetaRDLTerm replace(Map mapping) { RDLTerm dependingTerm = this.dependingTerm; List dependedTerms = new ArrayList<>(); if (dependingTerm instanceof MetaRDLTerm metaTerm) { - if (mapping.containsKey(metaTerm)) { - metaTerm = mapping.get(metaTerm); - } dependingTerm = metaTerm.replace(mapping); } for (RDLTerm term : this.dependedTerms) { if (term instanceof MetaRDLTerm metaTerm) { - if (mapping.containsKey(metaTerm)) { - metaTerm = mapping.get(metaTerm); - } term = metaTerm.replace(mapping); } dependedTerms.add(term); diff --git a/src/main/java/models/terms/meta/MetaDependencyTerm.java b/src/main/java/models/terms/meta/MetaDependencyTerm.java index 525cbd2..93519f9 100644 --- a/src/main/java/models/terms/meta/MetaDependencyTerm.java +++ b/src/main/java/models/terms/meta/MetaDependencyTerm.java @@ -57,7 +57,7 @@ } @Override - public Set isMatchedBy(RDLTerm another, MatchConstraint constraint, Map context) { + public Set isMatchedBy(RDLTerm another, MatchConstraint constraint) { Set result = new HashSet<>(); if (! another.getClass().isAssignableFrom(this.termType.getBaseTermClass())) { return result; @@ -76,8 +76,8 @@ MetaRDLTerm metaChild = (MetaRDLTerm) dependingChild; return metaChild.isMatchedBy(anotherDependingChild, constraint); } else { - if (!(dependingChild.equals(anotherDependingChild))) { - return new HashSet<>(); + if (dependingChild.equals(anotherDependingChild)) { + return new HashSet<>(List.of(constraint)); } } return new HashSet<>(); @@ -153,30 +153,19 @@ } @Override - public MetaRDLTerm replace(Map mapping) { + public MetaRDLTerm replace(Map mapping) { RDLTerm dependingTerm = this.dependingTerm; List termPairs = new ArrayList<>(); if (dependingTerm instanceof MetaRDLTerm metaTerm) { - if (mapping.containsKey(metaTerm)) { - metaTerm = mapping.get(metaTerm); - } dependingTerm = metaTerm.replace(mapping); } for (RDLTerm dependedTerm : this.termPairs.keySet()) { - RDLTerm nextDependedTerm; - if (dependedTerm instanceof MetaRDLTerm metaTerm) { - if (mapping.containsKey(metaTerm)) { - metaTerm = mapping.get(metaTerm); - } + RDLTerm nextDependedTerm = dependedTerm; + if (nextDependedTerm instanceof MetaRDLTerm metaTerm) { nextDependedTerm = metaTerm.replace(mapping); - } else { - nextDependedTerm = dependedTerm; } for (RDLTerm argTerm : this.termPairs.get(dependedTerm)) { if (argTerm instanceof MetaRDLTerm metaTerm) { - if (mapping.containsKey(metaTerm)) { - metaTerm = mapping.get(metaTerm); - } argTerm = metaTerm.replace(mapping); } termPairs.add(nextDependedTerm); diff --git a/src/main/java/models/terms/meta/MetaDynamicDependency.java b/src/main/java/models/terms/meta/MetaDynamicDependency.java index fc837ff..7b1c29f 100644 --- a/src/main/java/models/terms/meta/MetaDynamicDependency.java +++ b/src/main/java/models/terms/meta/MetaDynamicDependency.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.Arrays; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -65,11 +66,21 @@ @Override - public Set isMatchedBy(RDLTerm another, MatchConstraint constraint, Map context) { + public Set isMatchedBy(RDLTerm another, MatchConstraint constraint) { int maxIndex = another.getMaxIndex(); int maxDepth = another.getMaxDepth(); - MetaRDLTerm metaDep = generate(maxIndex, maxDepth, context); - return metaDep.isMatchedBy(another, constraint); + Set result = new HashSet<>(); + if (maxDepth == 1) { + MetaRDLTerm metaDep = generate(maxIndex, maxDepth, constraint.getContext()); + return metaDep.isMatchedBy(another, constraint); + } + for (int i = maxDepth; i > 1; i--) { + MatchConstraint newConstraint = new MatchConstraint(constraint); + MetaRDLTerm metaDep = generate(maxIndex, i, newConstraint.getContext()); + Set res = metaDep.isMatchedBy(another, newConstraint); + result.addAll(res); + } + return result; } @Override diff --git a/src/main/java/models/terms/meta/MetaDynamicDependencyTerm.java b/src/main/java/models/terms/meta/MetaDynamicDependencyTerm.java index 4a5217a..52e0de6 100644 --- a/src/main/java/models/terms/meta/MetaDynamicDependencyTerm.java +++ b/src/main/java/models/terms/meta/MetaDynamicDependencyTerm.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.Arrays; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -66,6 +67,9 @@ while (dependingTerm instanceof MetaDynamicTerm dynamicTerm) { dependingTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context); } + if (maxIndex == 1) { + return (MetaRDLTerm) dependingTerm; + } int index = 1; for (RDLTerm dependedTerm : this.termPairs.keySet()) { for (RDLTerm argTerm : this.termPairs.get(dependedTerm)) { @@ -98,15 +102,23 @@ termPairs.add(dependedTerm); termPairs.add(argTerm); } + if (termPairs.isEmpty()) { + return (MetaRDLTerm) dependingTerm; + } return new MetaDependencyTerm(dependingTerm, termPairs); } @Override - public Set isMatchedBy(RDLTerm another, MatchConstraint constraint, Map context) { + public Set isMatchedBy(RDLTerm another, MatchConstraint constraint) { int maxIndex = another.getMaxIndex(); int maxDepth = another.getMaxDepth(); - MetaRDLTerm metaTerm = generate(maxIndex, maxDepth, context); - return metaTerm.isMatchedBy(another, constraint); + Set result = new HashSet<>(); + for (int i = maxDepth; i > 0; i--) { + MatchConstraint newConstraint = new MatchConstraint(constraint); + MetaRDLTerm metaTerm = generate(maxIndex, i, newConstraint.getContext()); + result.addAll(metaTerm.isMatchedBy(another, newConstraint)); + } + return result; } @Override diff --git a/src/main/java/models/terms/meta/MetaRDLTerm.java b/src/main/java/models/terms/meta/MetaRDLTerm.java index c8827ba..7fd1acb 100644 --- a/src/main/java/models/terms/meta/MetaRDLTerm.java +++ b/src/main/java/models/terms/meta/MetaRDLTerm.java @@ -32,31 +32,15 @@ return isMatchedBy(another, MatchConstraint.createDefault()); } - public Set isMatchedBy(RDLTerm another, Map context) { - return isMatchedBy(another, MatchConstraint.createDefault(), context); - } - public Set isMatchedBy(RDLTerm another, Set constraints) { Set result = new HashSet<>(); for (MatchConstraint constraint : constraints) { - result.addAll(isMatchedBy(another, constraint, new HashMap<>())); + result.addAll(isMatchedBy(another, constraint)); } return result; } - public Set isMatchedBy(RDLTerm another, Set constraints, Map context) { - Set result = new HashSet<>(); - for (MatchConstraint constraint : constraints) { - result.addAll(isMatchedBy(another, constraint, context)); - } - return result; - } - - public Set isMatchedBy(RDLTerm another, MatchConstraint constraint) { - return isMatchedBy(another, constraint, new HashMap<>()); - } - - abstract public Set isMatchedBy(RDLTerm another, MatchConstraint constraint, Map context); + public abstract Set isMatchedBy(RDLTerm another, MatchConstraint constraint); public RDLTerm substitute(Map binding) { @@ -128,7 +112,7 @@ return -1; } - public abstract MetaRDLTerm replace(Map mapping); + public abstract RDLTerm replace(Map mapping); @Override public String toStringWithOrder() { diff --git a/src/main/java/models/terms/meta/MetaResource.java b/src/main/java/models/terms/meta/MetaResource.java index 2385c19..f98039d 100644 --- a/src/main/java/models/terms/meta/MetaResource.java +++ b/src/main/java/models/terms/meta/MetaResource.java @@ -28,7 +28,7 @@ } @Override - public Set isMatchedBy(RDLTerm another, MatchConstraint constraint, Map context) { + public Set isMatchedBy(RDLTerm another, MatchConstraint constraint) { Set result = new HashSet<>(); Map binding = constraint.getBinding(); Map orderConstraint = constraint.getOrderConstraint(); @@ -46,10 +46,10 @@ if (! binding.containsKey(this.variableName)) { binding.put(this.variableName, another); - result.add(new MatchConstraint(binding, orderConstraint)); + result.add(new MatchConstraint(binding, orderConstraint, constraint.cloneContext())); } else if (binding.get(this.variableName).equals(another)) { - result.add(new MatchConstraint(binding, orderConstraint)); + result.add(new MatchConstraint(binding, orderConstraint, constraint.cloneContext())); } return result; } diff --git a/src/main/java/models/terms/meta/MetaVariable.java b/src/main/java/models/terms/meta/MetaVariable.java index 56f3237..5d2541a 100644 --- a/src/main/java/models/terms/meta/MetaVariable.java +++ b/src/main/java/models/terms/meta/MetaVariable.java @@ -75,7 +75,7 @@ } @Override - public Set isMatchedBy(RDLTerm another, MatchConstraint constraint, Map context) { + public Set isMatchedBy(RDLTerm another, MatchConstraint constraint) { Set result = new HashSet<>(); Map binding = constraint.getBinding(); Map orderConstraint = constraint.getOrderConstraint(); @@ -93,10 +93,10 @@ if (! binding.containsKey(this.variableName)) { binding.put(this.variableName, another); - result.add(new MatchConstraint(binding, orderConstraint)); + result.add(new MatchConstraint(binding, orderConstraint, constraint.cloneContext())); } else if (binding.get(this.variableName).equals(another)) { - result.add(new MatchConstraint(binding, orderConstraint)); + result.add(new MatchConstraint(binding, orderConstraint, constraint.cloneContext())); } return result; } @@ -138,11 +138,15 @@ public abstract MetaVariable cloneWithName(String name); @Override - public MetaRDLTerm replace(Map mapping) { - if (mapping.containsKey(this)) { - return mapping.get(this).replace(mapping); + public RDLTerm replace(Map mapping) { + RDLTerm v = this; + if (mapping.containsKey(v)) { + v = mapping.get(v); + if (v instanceof MetaRDLTerm metaTerm) { + v = metaTerm.replace(mapping); + } } - return this; + return v; } diff --git a/src/test/java/inferencerule/InTest.java b/src/test/java/inferencerule/InTest.java new file mode 100644 index 0000000..9375fb9 --- /dev/null +++ b/src/test/java/inferencerule/InTest.java @@ -0,0 +1,82 @@ +package inferencerule; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.Set; + +import org.junit.jupiter.api.Test; + +import inference.In; +import models.algebra.Constant; +import models.algebra.Variable; +import models.formulas.meta.MetaEquationFormula; +import models.terms.DependencyTerm; +import models.terms.Resource; +import models.terms.meta.MetaDependencyTerm; +import models.terms.meta.MetaEvaluatableTermVariable; +import models.terms.meta.MetaResource; + +public class InTest { + + Resource a = new Resource("a", 1); + Resource b = new Resource("b", 1); + Resource c = new Resource("c", 1); + Resource d = new Resource("d", 1); + Resource e = new Resource("e", 1); + Resource f = new Resource("f", 1); + Resource g = new Resource("g", 1); + Resource h = new Resource("h", 1); + Resource i = new Resource("i", 1); + Resource j = new Resource("j", 1); + + + @Test + void DomainMemberShipDeriveTest() { + DependencyTerm t1 = new DependencyTerm(a, b, c); + DependencyTerm t2 = new DependencyTerm(d, b, c); + In in1 = new In(t1, t2); + Set res1 = in1.deriveRule(); + assertFalse(res1.isEmpty()); + MetaEvaluatableTermVariable se = new MetaEvaluatableTermVariable(new Variable("se")); + MetaResource C = new MetaResource(new Variable("c"), new Constant("0")); + MetaDependencyTerm mt1 = new MetaDependencyTerm(se, d, a); + MetaDependencyTerm mt2 = new MetaDependencyTerm(mt1, b, c); + MetaEquationFormula eq1 = new MetaEquationFormula(mt2, C); + //domain membership + assertTrue(res1.contains(eq1)); + + + In in2 = new In(a, b); + Set res2 = in2.deriveRule(); + assertFalse(res2.isEmpty()); + MetaDependencyTerm mt3 = new MetaDependencyTerm(se, b, a); + assertTrue(res2.contains(new MetaEquationFormula(mt3, C))); + + DependencyTerm t3 = new DependencyTerm(a, b, c); + DependencyTerm t4 = new DependencyTerm(d, e, f); + DependencyTerm t5 = new DependencyTerm(t3, g, h); + DependencyTerm t6 = new DependencyTerm(t4, g, h); + In in3 = new In(t5, t6); + Set res3 = in3.deriveRule(); + assertFalse(res3.isEmpty()); + MetaDependencyTerm mt4 = new MetaDependencyTerm(new MetaDependencyTerm(se, t4, t3), g, h); + assertTrue(res3.contains(new MetaEquationFormula(mt4, C))); + + DependencyTerm t7 = new DependencyTerm(a, b, c, d, e); + DependencyTerm t8 = new DependencyTerm(f, b, c, d, e); + In in4 = new In(t7, t8); + Set res4 = in4.deriveRule(); + assertFalse(res4.isEmpty()); + MetaDependencyTerm mt5 = new MetaDependencyTerm(new MetaDependencyTerm(se, f, a), b, c, d, e); + assertTrue(res4.contains(new MetaEquationFormula(mt5, C))); + + DependencyTerm t9 = new DependencyTerm(new DependencyTerm(a, b, c, d, e), f, g, h, i); + DependencyTerm t10 = new DependencyTerm(new DependencyTerm(j, b, c, d, e), f, g, h, i); + In in5 = new In(t9, t10); + Set res5 = in5.deriveRule(); + assertFalse(res5.isEmpty()); + MetaDependencyTerm mt6 = new MetaDependencyTerm(new MetaDependencyTerm(new MetaDependencyTerm(se, j, a), b, c, d, e), f, g, h, i); + assertTrue(res5.contains(new MetaEquationFormula(mt6, C))); + } + +} diff --git a/src/test/java/terms/meta/MetaDependencyTermTest.java b/src/test/java/terms/meta/MetaDependencyTermTest.java index 16e9a7e..1824c8b 100644 --- a/src/test/java/terms/meta/MetaDependencyTermTest.java +++ b/src/test/java/terms/meta/MetaDependencyTermTest.java @@ -1,12 +1,12 @@ package terms.meta; import static org.junit.jupiter.api.Assertions.*; -import org.junit.jupiter.api.Test; - import java.util.HashMap; import java.util.Map; import java.util.Set; +import org.junit.jupiter.api.Test; + import models.algebra.Variable; import models.terms.DependencyTerm; import models.terms.RDLTerm; @@ -51,7 +51,7 @@ correctBinding.put(w.getVariableName(), b); correctBinding.put(p.getVariableName(), c); mt4.toString(); - Set tmp = mt1.isMatchedBy(t1, new MatchConstraint(binding, orderConstraint)); + Set tmp = mt1.isMatchedBy(t1, new MatchConstraint(binding, orderConstraint, new HashMap<>())); assertTrue(! tmp.isEmpty()); tmp = mt2.isMatchedBy(t1, tmp); assertTrue(! tmp.isEmpty()); @@ -77,7 +77,7 @@ MetaRDLTerm mt2 = new MetaDependencyTerm(x, v, w, y, z); Map binding = new HashMap<>(); Map orderConstraint = new HashMap<>(); - Set tmp = mt1.isMatchedBy(t1, new MatchConstraint(binding, orderConstraint)); + Set tmp = mt1.isMatchedBy(t1, new MatchConstraint(binding, orderConstraint, new HashMap<>())); assertTrue(! tmp.isEmpty()); tmp = mt2.isMatchedBy(t2, tmp); assertTrue(! tmp.isEmpty()); @@ -122,5 +122,29 @@ assertEquals(t3.replace(Map.of(x, p, y, q, z, r, w, s)), t4); } + @Test + void SpecificTermMatchTest() { + Resource a = new Resource("a", 1); + Resource b = new Resource("b", 1); + Resource c = new Resource("c", 1); + Resource d = new Resource("d", 1); + Resource e = new Resource("e", 1); + Resource f = new Resource("f", 1); + MetaResource x = new MetaResource(new Variable("x")); + MetaResource y = new MetaResource(new Variable("y")); + + MetaDependencyTerm mdt = new MetaDependencyTerm(a, b, c); + DependencyTerm dt1 = new DependencyTerm(a, b, c); + DependencyTerm dt2 = new DependencyTerm(d, e, f); + DependencyTerm dt3 = new DependencyTerm(d, e, c); + MetaDependencyTerm mdt2 = new MetaDependencyTerm(x, y, c); + + assertFalse(mdt.isMatchedBy(dt1).isEmpty()); + assertTrue(mdt.isMatchedBy(dt2).isEmpty()); + + assertFalse(mdt2.isMatchedBy(dt1).isEmpty()); + assertTrue(mdt2.isMatchedBy(dt2).isEmpty()); + assertFalse(mdt2.isMatchedBy(dt3).isEmpty()); + } } diff --git a/src/test/java/terms/meta/MetaDependencyTest.java b/src/test/java/terms/meta/MetaDependencyTest.java index 08173dd..cc60e00 100644 --- a/src/test/java/terms/meta/MetaDependencyTest.java +++ b/src/test/java/terms/meta/MetaDependencyTest.java @@ -2,13 +2,13 @@ import static org.junit.jupiter.api.Assertions.*; import static utils.Utils.*; -import org.junit.jupiter.api.Test; - import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; +import org.junit.jupiter.api.Test; + import models.algebra.Constant; import models.algebra.Variable; import models.terms.Dependency; @@ -58,11 +58,11 @@ Map binding = new HashMap<>(); Map orderConst = new HashMap<>(); Set tmp = new HashSet<>(); - tmp = mt1.isMatchedBy(d1, new MatchConstraint(binding, orderConst)); + tmp = mt1.isMatchedBy(d1, new MatchConstraint(binding, orderConst, new HashMap<>())); assertTrue(! tmp.isEmpty()); assertEquals(tmp.iterator().next().getBinding().get(p.getVariableName()), a); assertEquals(tmp.iterator().next().getBinding().get(q.getVariableName()), b); - tmp = mt2.isMatchedBy(d2, new MatchConstraint(binding, orderConst)); + tmp = mt2.isMatchedBy(d2, new MatchConstraint(binding, orderConst, new HashMap<>())); assertTrue(!tmp.isEmpty()); tmp = mt3.isMatchedBy(d2, tmp); assertTrue(!tmp.isEmpty()); @@ -180,4 +180,27 @@ assertEquals(md5.replace(Map.of(z, w)), md6); } + @Test + void SpecificTermMatchTest() { + Resource a = new Resource("a", 1); + Resource b = new Resource("b", 1); + Resource c = new Resource("c", 1); + Resource d = new Resource("d", 1); + MetaResource x = new MetaResource(new Variable("x")); + + MetaDependency md1 = new MetaDependency(a, b); + MetaDependency md2 = new MetaDependency(a, x); + Dependency d1 = new Dependency(a, b); + Dependency d2 = new Dependency(a, c); + Dependency d3 = new Dependency(c, d); + + assertFalse(md1.isMatchedBy(d1).isEmpty()); + assertTrue(md1.isMatchedBy(d2).isEmpty()); + assertTrue(md1.isMatchedBy(d3).isEmpty()); + assertFalse(md2.isMatchedBy(d1).isEmpty()); + assertFalse(md2.isMatchedBy(d2).isEmpty()); + assertTrue(md2.isMatchedBy(d3).isEmpty()); + + } + } diff --git a/src/test/java/terms/meta/MetaDynamicDependencyTermTest.java b/src/test/java/terms/meta/MetaDynamicDependencyTermTest.java new file mode 100644 index 0000000..604dafa --- /dev/null +++ b/src/test/java/terms/meta/MetaDynamicDependencyTermTest.java @@ -0,0 +1,56 @@ +package terms.meta; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.Map; + +import org.junit.jupiter.api.Test; + +import models.algebra.Variable; +import models.terms.DependencyTerm; +import models.terms.Resource; +import models.terms.meta.MetaDynamicDependencyTerm; +import models.terms.meta.MetaEvaluatableTermVariable; +import models.terms.meta.MetaRDLTerm; +import models.terms.meta.MetaTermGenerator; + +public class MetaDynamicDependencyTermTest { + + Resource a = new Resource("a", 1); + Resource b = new Resource("b", 1); + Resource c = new Resource("c", 1); + Resource d = new Resource("d", 1); + Resource e = new Resource("e", 1); + Resource f = new Resource("f", 1); + Resource g = new Resource("g", 1); + Resource h = new Resource("h", 1); + + @Test + void DynamicMatchTest() { + MetaDynamicDependencyTerm mdt1 = new MetaDynamicDependencyTerm( + new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + if (curDepth == maxDepth && curIndex == 0) { + return new MetaEvaluatableTermVariable(new Variable("t")); + } + if (curIndex == 0) { + return new MetaDynamicDependencyTerm(this); + } + curIndex -= 1; + if (curIndex % 2 == 0) { + return new MetaEvaluatableTermVariable(new Variable("s" + curDepth + "_" + curIndex)); + } + return new MetaEvaluatableTermVariable(new Variable("u" + curDepth + "_" + curIndex)); + } + } + ); + DependencyTerm t1 = new DependencyTerm(a, b, c); + DependencyTerm t2 = new DependencyTerm(t1, b, c); + assertFalse(mdt1.isMatchedBy(t1).isEmpty()); + assertFalse(mdt1.isMatchedBy(t2).isEmpty()); + assertEquals(mdt1.isMatchedBy(t2).size(), 2); + } + + +} diff --git a/src/test/java/terms/meta/MetaDynamicDependencyTest.java b/src/test/java/terms/meta/MetaDynamicDependencyTest.java index 441bd2d..ba8c937 100644 --- a/src/test/java/terms/meta/MetaDynamicDependencyTest.java +++ b/src/test/java/terms/meta/MetaDynamicDependencyTest.java @@ -1,20 +1,22 @@ package terms.meta; import static org.junit.jupiter.api.Assertions.*; -import org.junit.jupiter.api.Test; - import java.util.HashMap; import java.util.Map; import java.util.Set; +import org.junit.jupiter.api.Test; + import models.algebra.Variable; import models.terms.Dependency; import models.terms.RDLTerm; import models.terms.Resource; import models.terms.meta.MatchConstraint; import models.terms.meta.MetaDependency; +import models.terms.meta.MetaDependencyVariable; import models.terms.meta.MetaDynamicDependency; import models.terms.meta.MetaRDLTerm; +import models.terms.meta.MetaRDLTermVariable; import models.terms.meta.MetaResource; import models.terms.meta.MetaTermGenerator; @@ -87,4 +89,29 @@ assertEquals(generated, d2); } + @Test + void DynamiMatchTest() { + MetaDynamicDependency md1 = new MetaDynamicDependency( + new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + if (curDepth == maxDepth - 1 && curIndex == 0) { + return new MetaDependencyVariable(new Variable("d")); + } + if (curIndex == 0) { + return new MetaDynamicDependency(this); + } + return new MetaRDLTermVariable(new Variable("x")); + } + } + ); + + Dependency d1 = new Dependency(a, b); + Dependency d2 = new Dependency(d1, b); + Dependency d3 = new Dependency(d2, b); + assertFalse(md1.isMatchedBy(d2).isEmpty()); + assertFalse(md1.isMatchedBy(d3).isEmpty()); + System.out.println(md1.isMatchedBy(d3)); + } + } diff --git a/src/test/java/terms/meta/MetaResourceVariableTest.java b/src/test/java/terms/meta/MetaResourceVariableTest.java index 30c3bf7..ff7c7c4 100644 --- a/src/test/java/terms/meta/MetaResourceVariableTest.java +++ b/src/test/java/terms/meta/MetaResourceVariableTest.java @@ -3,10 +3,10 @@ import static org.junit.jupiter.api.Assertions.*; import static utils.Utils.*; -import org.junit.jupiter.api.Test; - import java.util.Map; +import org.junit.jupiter.api.Test; + import models.algebra.Variable; import models.terms.Dependency; import models.terms.DependencyTerm; @@ -168,4 +168,5 @@ assertEquals(x.replace(Map.of(x, y)), y); } + }