diff --git a/src/main/java/Main.java b/src/main/java/Main.java index fac8790..3637f9f 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -1,13 +1,14 @@ +import com.google.common.collect.TreeMultimap; + import java.util.HashMap; import java.util.Map; -import com.google.common.collect.TreeMultimap; - import constants.Types; import models.algebra.Constant; import models.algebra.Expression; import models.algebra.Type; import models.algebra.Variable; +import models.terms.meta.MetaDynaimcDependencyTerm; import models.terms.meta.MetaDynamicDependency; import models.terms.meta.MetaRDLTerm; import models.terms.meta.MetaResource; @@ -22,6 +23,7 @@ sandbox(); sandbox2(); sandbox3(); + sandbox4(); } @@ -61,4 +63,19 @@ System.out.println(d2.generate(0, 2, 2, null)); } + static void sandbox4() { + MetaDynaimcDependencyTerm t1 = new MetaDynaimcDependencyTerm((ci, cd, mi, md, contex) -> new MetaResource(new Variable("x" + ci))); + MetaDynaimcDependencyTerm t2 = new MetaDynaimcDependencyTerm(new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + if (curDepth == 0 && curIndex != 0 && curIndex % 2 == 0) { + return new MetaDynaimcDependencyTerm(this); + } + return new MetaResource(new Variable("x" + curDepth + "_" + curIndex)); + } + }); + System.out.println(t1.generate(0, 5, 0, null)); + System.out.println(t2.generate(0, 3, 2, null)); + } + } diff --git a/src/main/java/models/terms/Dependency.java b/src/main/java/models/terms/Dependency.java index 21307bc..d8f9fb2 100644 --- a/src/main/java/models/terms/Dependency.java +++ b/src/main/java/models/terms/Dependency.java @@ -38,6 +38,27 @@ } @Override + public int getMaxIndex() { + return 1 + dependedTerms.size(); + } + + @Override + public int getMaxDepth() { + int result = dependingTerm.getMaxDepth(); + if (! (dependingTerm instanceof Resource || dependingTerm instanceof ResourceConstant)) { + result++; + } + for (RDLTerm dependedTerm : dependedTerms) { + int dependedTermDepth = dependedTerm.getMaxDepth(); + if (! (dependedTerm instanceof Resource || dependedTerm instanceof ResourceConstant)) { + dependedTermDepth++; + } + result = Math.max(result, dependedTermDepth); + } + return result; + } + + @Override public int getTermOrder() { return getOrder() - 1; } diff --git a/src/main/java/models/terms/DependencyTerm.java b/src/main/java/models/terms/DependencyTerm.java index 5a66e06..8a3e0fe 100644 --- a/src/main/java/models/terms/DependencyTerm.java +++ b/src/main/java/models/terms/DependencyTerm.java @@ -61,6 +61,44 @@ this(dependingTerm, Arrays.asList(terms)); } + + @Override + public int getMaxIndex() { + int result = 1; + for (EvaluatableTerm dependedTerm : termPairs.keySet()) { + for (EvaluatableTerm argTerm : termPairs.get(dependedTerm)) { + result += 2; + } + } + return result; + } + + @Override + public int getMaxDepth() { + int result = 0; + if (dependingTerm instanceof Resource || dependingTerm instanceof ResourceConstant) { + result = dependingTerm.getMaxDepth(); + } else { + result = dependingTerm.getMaxDepth() + 1; + } + for (EvaluatableTerm dependedTerm : termPairs.keySet()) { + int dependedTermDepth = dependedTerm.getMaxDepth(); + if (! (dependedTerm instanceof Resource || dependedTerm instanceof ResourceConstant)) { + dependedTermDepth++; + } + result = Math.max(result, dependedTermDepth); + for (EvaluatableTerm argTerm : termPairs.get(dependedTerm)) { + int argTermDepth = dependedTerm.getMaxDepth(); + if (! (argTerm instanceof Resource || argTerm instanceof ResourceConstant)) { + argTermDepth++; + } + result = Math.max(result, argTermDepth); + } + } + + return result; + } + @Override public boolean isLinearRightNormalized() { return isLinearRightNormaled(0); diff --git a/src/main/java/models/terms/PrimedTerm.java b/src/main/java/models/terms/PrimedTerm.java index 2afd229..dc7eef1 100644 --- a/src/main/java/models/terms/PrimedTerm.java +++ b/src/main/java/models/terms/PrimedTerm.java @@ -13,6 +13,16 @@ this.primedTerm = term; this.isResource = term instanceof Resource; } + + @Override + public int getMaxIndex() { + return primedTerm.getMaxIndex(); + } + + @Override + public int getMaxDepth() { + return primedTerm.getMaxDepth(); + } @Override public String toString() { diff --git a/src/main/java/models/terms/RDLTerm.java b/src/main/java/models/terms/RDLTerm.java index 629839c..5e3ade5 100644 --- a/src/main/java/models/terms/RDLTerm.java +++ b/src/main/java/models/terms/RDLTerm.java @@ -20,6 +20,11 @@ return getOrder(); } + public abstract int getMaxIndex(); + + public abstract int getMaxDepth(); + + @Override public abstract String toString(); diff --git a/src/main/java/models/terms/Resource.java b/src/main/java/models/terms/Resource.java index e5274fb..7d64d72 100644 --- a/src/main/java/models/terms/Resource.java +++ b/src/main/java/models/terms/Resource.java @@ -17,6 +17,16 @@ } @Override + public int getMaxIndex() { + return 1; + } + + @Override + public int getMaxDepth() { + return 1; + } + + @Override public EvaluatableTerm linearRightNormalize() { return (Resource) clone(); } diff --git a/src/main/java/models/terms/ResourceConstant.java b/src/main/java/models/terms/ResourceConstant.java index 1158b84..46571be 100644 --- a/src/main/java/models/terms/ResourceConstant.java +++ b/src/main/java/models/terms/ResourceConstant.java @@ -23,6 +23,16 @@ } @Override + public int getMaxIndex() { + return 1; + } + + @Override + public int getMaxDepth() { + return 1; + } + + @Override public boolean isLinearRightNormalized() { return true; } diff --git a/src/main/java/models/terms/meta/MetaDependency.java b/src/main/java/models/terms/meta/MetaDependency.java index 7053d66..b25baaa 100644 --- a/src/main/java/models/terms/meta/MetaDependency.java +++ b/src/main/java/models/terms/meta/MetaDependency.java @@ -6,9 +6,11 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Collectors; import exceptions.SubstituteFailedException; import exceptions.SyntaxException; +import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; import models.terms.Dependency; @@ -19,7 +21,7 @@ public class MetaDependency extends MetaRDLTerm{ protected RDLTerm dependingTerm; - protected List dependedTerms; + protected List dependedTerms = new ArrayList<>(); protected MetaDependency() { super(new Symbol(":", -1), TermType.META_DEPENDENCY, -1); @@ -123,4 +125,10 @@ } } + + @Override + public String toString() { + return "[" + getChild(0).toString() + " : " + getChildren().stream().skip(1).map(Expression::toString).collect(Collectors.joining(",")) + "]"; + } + } diff --git a/src/main/java/models/terms/meta/MetaDependencyTerm.java b/src/main/java/models/terms/meta/MetaDependencyTerm.java index 7b3f30e..e0bb4e4 100644 --- a/src/main/java/models/terms/meta/MetaDependencyTerm.java +++ b/src/main/java/models/terms/meta/MetaDependencyTerm.java @@ -9,6 +9,8 @@ import java.util.Map; import java.util.Set; import java.util.TreeMap; +import java.util.stream.Collectors; +import java.util.stream.IntStream; import exceptions.SubstituteFailedException; import exceptions.SyntaxException; @@ -21,9 +23,17 @@ public class MetaDependencyTerm extends MetaRDLTerm{ + protected RDLTerm dependingTerm; + protected Map> termPairs = new TreeMap<>(); + + protected MetaDependencyTerm() { + super(new Symbol(":", -1), TermType.META_DEPENDENCY_TERM, -1); + } + public MetaDependencyTerm(RDLTerm dependingTerm, List terms) { super(new Symbol(":", -1), TermType.META_DEPENDENCY_TERM, -1); TreeMap> sortedMap = new TreeMap<>(); + this.dependingTerm = dependingTerm; addChild(dependingTerm); int size = dependingTerm.getSize(); for (int i = 0; i < terms.size() / 2; i++) { @@ -33,6 +43,7 @@ } for (RDLTerm dependedTerm: sortedMap.keySet()) { for (RDLTerm argTerm: sortedMap.get(dependedTerm)) { + termPairs.computeIfAbsent(dependedTerm, k -> TreeMultiset.create()).add(argTerm); addChild(dependedTerm); addChild(argTerm); size += dependedTerm.getSize(); @@ -141,5 +152,12 @@ throw new SubstituteFailedException(e.getMessage()); } } + + + @Override + public String toString() { + return "[" + getChild(0).toString() + " : " + IntStream.range(0, (getChildren().size() - 1) / 2) + .mapToObj(i -> getChild(i * 2 + 1).toString() + " -> " + getChild(i * 2 + 2)).collect(Collectors.joining(", ")) + "]"; + } } diff --git a/src/main/java/models/terms/meta/MetaDynaimcDependencyTerm.java b/src/main/java/models/terms/meta/MetaDynaimcDependencyTerm.java new file mode 100644 index 0000000..410e28b --- /dev/null +++ b/src/main/java/models/terms/meta/MetaDynaimcDependencyTerm.java @@ -0,0 +1,116 @@ +package models.terms.meta; + +import com.google.common.collect.TreeMultiset; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import exceptions.SyntaxException; +import models.algebra.Variable; +import models.terms.RDLTerm; + +public class MetaDynaimcDependencyTerm extends MetaDependencyTerm implements MetaDynamicTerm{ + + private final MetaTermGenerator generator; + + public MetaDynaimcDependencyTerm (MetaTermGenerator generator) { + this.generator = generator; + } + + public MetaDynaimcDependencyTerm(MetaTermGenerator generator, List terms) { + this.generator = generator; + if (terms.size() != 0 && terms.size() % 2 != 1) { + throw new SyntaxException(""); + } + this.dependingTerm = terms.size() > 0 ? terms.get(0) : null; + for (int i = 0; i < (terms.size() - 1) / 2; i++) { + RDLTerm dependedTerm = terms.get(i * 2 + 1); + RDLTerm argTerm = terms.get(i * 2 + 2); + this.termPairs.computeIfAbsent(dependedTerm, k -> TreeMultiset.create()).add(argTerm); + addChild(dependedTerm); + addChild(argTerm); + } + } + + @Override + public MetaRDLTerm generate(int depth, Map context) { + // TODO 自動生成されたメソッド・スタブ + return null; + } + + public MetaRDLTerm generate(int maxIndex, int maxDepth, Map context) { + return generate(1, maxIndex, maxDepth, context); + } + + @Override + public MetaRDLTerm generate(int depth, int maxIndex, int maxDepth, Map context) { + if (maxIndex % 2 == 0 && maxIndex <= 2) return null; + RDLTerm dependingTerm; + List termPairs = new ArrayList<>(); + if (this.dependingTerm != null) { + dependingTerm = this.dependingTerm; + } else { + dependingTerm = generator.generate(0, depth, maxIndex, maxDepth, context); + } + while (dependingTerm instanceof MetaDynamicTerm dynamicTerm) { + dependingTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context); + } + int index = 1; + for (RDLTerm dependedTerm : this.termPairs.keySet()) { + for (RDLTerm argTerm : this.termPairs.get(dependedTerm)) { + while (dependedTerm instanceof MetaDynamicTerm dynamicTerm) { + dependedTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context); + } + while (argTerm instanceof MetaDynamicTerm dynamicTerm) { + argTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context); + } + termPairs.add(dependedTerm); + termPairs.add(argTerm); + index+=2; + } + } + for (int i = 0; i < (maxIndex - index) / 2; i++) { + RDLTerm dependedTerm = generator.generate(i * 2 + 1, depth, maxIndex, maxDepth, context); + RDLTerm argTerm = generator.generate(i * 2 + 2, depth, maxIndex, maxDepth, context); + while (dependedTerm instanceof MetaDynamicTerm dynamicTerm) { + dependedTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context); + } + while (argTerm instanceof MetaDynamicTerm dynamicTerm) { + argTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context); + } + termPairs.add(dependedTerm); + termPairs.add(argTerm); + } + return new MetaDependencyTerm(dependingTerm, termPairs); + } + + @Override + protected Set isMatchedBy(RDLTerm another, Set constraint, int depth) { + int maxIndex = another.getMaxIndex(); + int maxDepth = another.getMaxDepth(); + MetaRDLTerm metaTerm = generate(maxIndex, maxDepth, new HashMap<>()); + return metaTerm.isMatchedBy(another, constraint, depth); + } + + @Override + protected RDLTerm substitute(Map binding, int depth) { + // TODO 自動生成されたメソッド・スタブ + return null; + } + + + @Override + public String toString() { + if (dependingTerm != null) { + return "[" + getChild(0).toString() + " : " + IntStream.range(0, (getChildren().size() - 1) / 2) + .mapToObj(i -> getChild(i * 2 + 1).toString() + " -> " + getChild(i * 2 + 2)).collect(Collectors.joining(", ")) + " ...? ]"; + } + return "[ ...? ]"; + } + +} diff --git a/src/main/java/models/terms/meta/MetaDynamicDependency.java b/src/main/java/models/terms/meta/MetaDynamicDependency.java index 97b02d3..e6050b3 100644 --- a/src/main/java/models/terms/meta/MetaDynamicDependency.java +++ b/src/main/java/models/terms/meta/MetaDynamicDependency.java @@ -2,10 +2,13 @@ import java.util.ArrayList; import java.util.Arrays; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Collectors; +import models.algebra.Expression; import models.algebra.Variable; import models.terms.RDLTerm; @@ -21,6 +24,9 @@ this.termGenerator = termGenerator; this.dependingTerm = terms.size() > 0 ? terms.get(0) : null; this.dependedTerms = terms.size() > 1 ? terms.stream().skip(1).toList() : List.of(); + for (RDLTerm term : terms) { + addChild(term); + } } public MetaDynamicDependency(MetaTermGenerator termGenerator, RDLTerm ...terms) { @@ -29,10 +35,9 @@ @Override public MetaRDLTerm generate(int depth, Map context) { - // TODO 自動生成されたメソッド・スタブ return null; } - + @Override public MetaDependency generate(int depth, int maxIndex, int maxDepth, Map context) { if (maxIndex < 2) return null; @@ -58,8 +63,10 @@ @Override protected Set isMatchedBy(RDLTerm another, MatchConstraint constraint, int depth) { - // TODO 自動生成されたメソッド・スタブ - return null; + int maxIndex = another.getMaxIndex(); + int maxDepth = another.getMaxDepth(); + MetaRDLTerm metaDep = generate(maxIndex, maxDepth, new HashMap<>()); + return metaDep.isMatchedBy(another, constraint, depth); } @Override @@ -69,4 +76,14 @@ } + @Override + public String toString() { + if (dependingTerm != null) { + return "[" + + getChild(0).toString() + " : " + + getChildren().stream().skip(1).map(Expression::toString).collect(Collectors.joining(",")) + + " ...? ]"; + } + return "[ ...? ]"; + } } diff --git a/src/main/java/models/terms/meta/MetaDynamicTerm.java b/src/main/java/models/terms/meta/MetaDynamicTerm.java index db8f017..d93fbdf 100644 --- a/src/main/java/models/terms/meta/MetaDynamicTerm.java +++ b/src/main/java/models/terms/meta/MetaDynamicTerm.java @@ -9,4 +9,8 @@ public MetaRDLTerm generate(int depth, Map context); public MetaRDLTerm generate(int depth, int maxIndex, int maxDepth, Map context); + default MetaRDLTerm generate(int maxIndex, int maxDepth, Map context) { + return generate(1, maxIndex, maxDepth, context); + } + } diff --git a/src/main/java/models/terms/meta/MetaRDLTerm.java b/src/main/java/models/terms/meta/MetaRDLTerm.java index 9ceb9f4..a528fed 100644 --- a/src/main/java/models/terms/meta/MetaRDLTerm.java +++ b/src/main/java/models/terms/meta/MetaRDLTerm.java @@ -4,11 +4,8 @@ import java.util.HashSet; import java.util.Map; import java.util.Set; -import java.util.stream.Collectors; -import java.util.stream.IntStream; import lombok.Getter; -import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; import models.terms.Dependency; @@ -115,18 +112,15 @@ @Override - public String toString() { - switch(termType) { - case META_DEPENDENCY: - return "[" + getChild(0).toString() + " : " + getChildren().stream().skip(1).map(Expression::toString).collect(Collectors.joining(",")) + "]"; - case META_DEPENDENCY_TERM: - return "[" + getChild(0).toString() + " : " + IntStream.range(0, (getChildren().size() - 1) / 2) - .mapToObj(i -> getChild(i * 2 + 1).toString() + " -> " + getChild(i * 2 + 2)).collect(Collectors.joining(",")) + "]"; - default: - return ""; - } + public int getMaxIndex() { + return -1; } - + + @Override + public int getMaxDepth() { + return -1; + } + @Override public String toStringWithOrder() { switch(termType) { diff --git a/src/test/java/terms/DependencyTermTest.java b/src/test/java/terms/DependencyTermTest.java index 7786338..392cd94 100644 --- a/src/test/java/terms/DependencyTermTest.java +++ b/src/test/java/terms/DependencyTermTest.java @@ -75,6 +75,25 @@ DependencyTerm t5 = new DependencyTerm(a, b, c, b, c); assertEquals(t5.toString(), "[a : b -> c, b -> c]"); + } + + @Test + void MaxIndexAndMaxDepthTest() { + DependencyTerm t1 = new DependencyTerm(a, b, c); + assertEquals(t1.getMaxIndex(), 3); + assertEquals(t1.getMaxDepth(), 1); + + DependencyTerm t2 = new DependencyTerm(a, b, c, d, e); + assertEquals(t2.getMaxIndex(), 5); + assertEquals(t2.getMaxDepth(), 1); + + DependencyTerm t3 = new DependencyTerm(t2, f, g); + assertEquals(t3.getMaxIndex(), 3); + assertEquals(t3.getMaxDepth(), 2); + + DependencyTerm t4 = new DependencyTerm(t3, t1, t2); + assertEquals(t4.getMaxIndex(), 3); + assertEquals(t4.getMaxDepth(), 3); } diff --git a/src/test/java/terms/DependencyTest.java b/src/test/java/terms/DependencyTest.java index ba660ef..ce97629 100644 --- a/src/test/java/terms/DependencyTest.java +++ b/src/test/java/terms/DependencyTest.java @@ -75,4 +75,20 @@ assertEquals(d4.toString(), "a : b, b, c, e"); } + @Test + void MaxIndexAndMaxDepthTest() { + Dependency d1 = new Dependency(a, b); + assertEquals(d1.getMaxIndex(), 2); + assertEquals(d1.getMaxDepth(), 1); + + Dependency d2 = new Dependency(d1, c); + assertEquals(d2.getMaxIndex(), 2); + assertEquals(d2.getMaxDepth(), 2); + + Dependency d3 = new Dependency(d2, e, f); + assertEquals(d3.getMaxIndex(), 3); + assertEquals(d3.getMaxDepth(), 3); + + } + } diff --git a/src/test/java/terms/meta/MetaDependencyTermTest.java b/src/test/java/terms/meta/MetaDependencyTermTest.java index e75916b..56dc7bf 100644 --- a/src/test/java/terms/meta/MetaDependencyTermTest.java +++ b/src/test/java/terms/meta/MetaDependencyTermTest.java @@ -13,11 +13,8 @@ import models.terms.Resource; import models.terms.meta.MatchConstraint; import models.terms.meta.MetaDependencyTerm; -import models.terms.meta.MetaDynamicTerm; import models.terms.meta.MetaRDLTerm; import models.terms.meta.MetaResource; -import models.terms.meta.MetaTermPairGenerator; -import models.terms.meta.MetaTermPairGenerator.TermPair; import models.terms.meta.OrderVariableConstraint; import utils.Utils; @@ -106,14 +103,4 @@ assertTrue(! tmp.isEmpty()); } - @Test - void DynamicMatchTest2() { - MetaResource x = new MetaResource(new Variable("x")); - MetaDynamicTerm mt1 = new MetaDynamicTerm(x, (MetaTermPairGenerator) (i, depth, isLast) -> new TermPair(new MetaResource(new Variable("x" + i)), new MetaResource(new Variable("y"+i)))); - DependencyTerm d1 = new DependencyTerm(a, b, c); - DependencyTerm d2 = new DependencyTerm(a, b, c, d, e); - assertTrue(! mt1.isMatchedBy(d1).isEmpty()); - assertTrue(! mt1.isMatchedBy(d2).isEmpty()); - } - } diff --git a/src/test/java/terms/meta/MetaDependencyTest.java b/src/test/java/terms/meta/MetaDependencyTest.java index 912c5fe..0cd4f8b 100644 --- a/src/test/java/terms/meta/MetaDependencyTest.java +++ b/src/test/java/terms/meta/MetaDependencyTest.java @@ -19,10 +19,8 @@ import models.terms.meta.MetaDependency; import models.terms.meta.MetaDependencyTerm; import models.terms.meta.MetaDependencyTermVariable; -import models.terms.meta.MetaDynamicTerm; import models.terms.meta.MetaRDLTerm; import models.terms.meta.MetaResource; -import models.terms.meta.MetaTermGenerator; import models.terms.meta.OrderVariableConstraint; import utils.Utils; @@ -154,27 +152,4 @@ assertTrue(! vd3.isMatchedBy(d4).isEmpty()); } - @Test - void DynamicMatchTest() { - MetaResource x = new MetaResource(new Variable("x")); - MetaDynamicTerm md1 = new MetaDynamicTerm(x, new MetaTermGenerator() { - @Override - public MetaRDLTerm generate(int index, int depth, boolean isLast) { - if (index != 0) { - return new MetaResource(new Variable("r" + index)); - } else { - return new MetaResource(new Variable("y")); - } - }}); - MetaRDLTerm md2 = new MetaDependency(new MetaResource(new Variable("y")), new MetaResource(new Variable("z"))); - Dependency d1 = new Dependency(a, b, c); - Dependency d2 = new Dependency(c, d); - Dependency d3 = new Dependency(b, d); - - Set tmp = md1.isMatchedBy(d1); - assertTrue(!tmp.isEmpty()); - assertTrue(! md2.isMatchedBy(d2, tmp).isEmpty()); - assertTrue(! md2.isMatchedBy(d3, tmp).isEmpty()); - } - } diff --git a/src/test/java/terms/meta/MetaDynamicDependencyTest.java b/src/test/java/terms/meta/MetaDynamicDependencyTest.java new file mode 100644 index 0000000..9f601e3 --- /dev/null +++ b/src/test/java/terms/meta/MetaDynamicDependencyTest.java @@ -0,0 +1,67 @@ +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 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.MetaDynamicDependency; +import models.terms.meta.MetaRDLTerm; +import models.terms.meta.MetaResource; +import models.terms.meta.MetaTermGenerator; +import utils.Utils; + +public class MetaDynamicDependencyTest { + + Resource a = new Resource("a", Utils.INT, 1); + Resource b = new Resource("b", Utils.INT, 1); + Resource c = new Resource("c", Utils.INT, 1); + Resource d = new Resource("d", Utils.INT, 1); + Resource e = new Resource("d", Utils.INT, 1); + Resource f = new Resource("d", Utils.INT, 1); + Resource g = new Resource("d", Utils.INT, 1); + + @Test + void DynamicDependencyMatchTest() { + MetaDynamicDependency md1 = new MetaDynamicDependency((ci, cd, mi, md, context) -> new MetaResource(new Variable("x" + ci))); + Dependency d1 = new Dependency(a, b, c, d); + assertFalse(md1.isMatchedBy(d1).isEmpty()); + + Dependency d2 = new Dependency(new Dependency(a, b), c); + Dependency d3 = new Dependency(d2, d, e); + MetaDynamicDependency md2 = new MetaDynamicDependency(new MetaTermGenerator() { + @Override + public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map context) { + if (curDepth != maxDepth && curIndex == 0) { + return new MetaDynamicDependency(this); + } + return new MetaResource(new Variable("x" + curDepth + "_" + curIndex)); + } + }); + assertFalse(md2.isMatchedBy(d2).isEmpty()); + assertFalse(md2.isMatchedBy(d3).isEmpty()); + + MetaResource x = new MetaResource(new Variable("x")); + MetaResource y = new MetaResource(new Variable("y")); + Dependency d4 = new Dependency(a, b); + MetaDynamicDependency md3 = new MetaDynamicDependency((ci, cd, mi, md, context) -> new MetaResource(new Variable("x" + ci)), x, y); + Set constraint = new MetaDependency(x, y).isMatchedBy(d4); + Dependency d5 = new Dependency(a, b, c); + constraint = md3.isMatchedBy(d5, constraint); + assertFalse(constraint.isEmpty()); + Map binding = new HashMap<>(); + binding.put(new Variable("x"), a); + binding.put(new Variable("y"), b); + binding.put(new Variable("x2"), c); + assertEquals(constraint.iterator().next().getBinding(), binding); + } + +} diff --git a/src/test/java/terms/meta/MetaDynamicTermTest.java b/src/test/java/terms/meta/MetaDynamicTermTest.java deleted file mode 100644 index ff9ef31..0000000 --- a/src/test/java/terms/meta/MetaDynamicTermTest.java +++ /dev/null @@ -1,160 +0,0 @@ -package terms.meta; -import static org.junit.jupiter.api.Assertions.*; - -import org.junit.jupiter.api.Test; - -import models.algebra.Constant; -import models.algebra.Variable; -import models.terms.Dependency; -import models.terms.DependencyTerm; -import models.terms.Resource; -import models.terms.meta.MatchConstraint; -import models.terms.meta.MetaDynamicTerm; -import models.terms.meta.MetaRDLTerm; -import models.terms.meta.MetaResource; -import models.terms.meta.MetaTermGenerator; -import utils.Utils; - -public class MetaDynamicTermTest { - - Resource a = new Resource("a", Utils.INT, 1); - Resource b = new Resource("b", Utils.INT, 1); - Resource c = new Resource("c", Utils.INT, 1); - Resource d = new Resource("d", Utils.INT, 1); - Resource e = new Resource("e", Utils.INT, 1); - Resource f = new Resource("f", Utils.INT, 1); - Resource g = new Resource("g", Utils.INT, 1); - Resource h = new Resource("h", Utils.INT, 1); - Resource i = new Resource("i", Utils.INT, 3); - Resource j = new Resource("j", Utils.INT, 2); - Resource k = new Resource("k", Utils.INT, 2); - Resource l = new Resource("l", Utils.INT, 1); - Resource m = new Resource("m", Utils.INT, 1); - Resource n = new Resource("n", Utils.INT, 0); - Resource o = new Resource("o", Utils.INT, 0); - - @Test - void GenerateTest1() { - MetaDynamicTerm mt1 = new MetaDynamicTerm( - new MetaTermGenerator() { - @Override - public MetaRDLTerm generate(int index, int depth, boolean isLast) { - if (isLast) { - return new MetaResource(new Variable("x")); - } - return new MetaDynamicTerm(this, new MetaResource(new Variable("y" + depth))); - } - }, - new MetaResource(new Variable("y")) - ); - Dependency d1 = new Dependency(a, b); - Dependency d2 = new Dependency(d1, c); - Dependency d3 = new Dependency(d2, d); - assertTrue(! mt1.isMatchedBy(d1).isEmpty()); - assertTrue(! mt1.isMatchedBy(d2).isEmpty()); - assertTrue(! mt1.isMatchedBy(d3).isEmpty()); - - MatchConstraint result = mt1.isMatchedBy(d3).iterator().next(); - MetaRDLTerm mt2 = mt1.dependencyGenerate(result.getBinding()); - assertTrue(mt2.isMatchedBy(d3, result).contains(result)); - - assertEquals(mt1.substitute(result.getBinding()), d3); - } - - @Test - void GenerateTest2() { - MetaDynamicTerm mt1 = new MetaDynamicTerm( - new MetaResource(new Variable("x")), - (MetaTermGenerator) (i, d, l) -> new MetaResource(new Variable("y" + i)) - ); - Dependency d1 = new Dependency(a, b); - Dependency d2 = new Dependency(a, b, c); - Dependency d3 = new Dependency(a, b, c, d); - - assertTrue(! mt1.isMatchedBy(d1).isEmpty()); - assertTrue(! mt1.isMatchedBy(d2).isEmpty()); - assertTrue(! mt1.isMatchedBy(d3).isEmpty()); - } - - @Test - void GenerateTest3() { - MetaDynamicTerm mt1 = new MetaDynamicTerm( - new MetaTermGenerator() { - @Override - public MetaRDLTerm generate(int index, int depth, boolean isLast) { - if (isLast) { - return new MetaResource(new Variable("x")); - } - return new MetaDynamicTerm(this, (MetaTermGenerator) (i, d, l) -> new MetaResource(new Variable("y" + (d+1) + "," + i))); - } - }, - (MetaTermGenerator) (i, d, l) -> new MetaResource(new Variable("y0," + i)) - ); - Dependency d1 = new Dependency(a, b, c, d); - Dependency d2 = new Dependency(d1, c, d); - assertTrue(! mt1.isMatchedBy(d1).isEmpty()); - assertTrue(! mt1.isMatchedBy(d2).isEmpty()); - - MatchConstraint result = mt1.isMatchedBy(d2).iterator().next(); - MetaRDLTerm mt2 = mt1.dependencyGenerate(result.getBinding()); - assertTrue(mt2.isMatchedBy(d2, result).contains(result)); - - assertEquals(mt1.substitute(result.getBinding()), d2); - } - - @Test - void GenerateTest4() { - MetaDynamicTerm mt1 = new MetaDynamicTerm( - new MetaTermGenerator() { - @Override - public MetaRDLTerm generate(int index, int depth, boolean isLast) { - if (isLast) { - return new MetaResource(new Variable("x")); - } - return new MetaDynamicTerm(this, new MetaResource(new Variable("y" + depth)), new MetaResource(new Variable("z" + depth))); - } - }, - new MetaResource(new Variable("y")), - new MetaResource(new Variable("z")) - ); - - DependencyTerm t1 = new DependencyTerm(a, b, c); - DependencyTerm t2 = new DependencyTerm(t1, d, e); - DependencyTerm t3 = new DependencyTerm(t2, d, e); - assertTrue(! mt1.isMatchedBy(t1).isEmpty()); - assertTrue(! mt1.isMatchedBy(t2).isEmpty()); - assertTrue(! mt1.isMatchedBy(t3).isEmpty()); - - MatchConstraint result = mt1.isMatchedBy(t3).iterator().next(); - assertTrue(! mt1.dependencyTermGenerate(result.getBinding()).isMatchedBy(t3, result).isEmpty()); - assertEquals(mt1.substitute(result.getBinding()), t3); - - } - - @Test - void GenerateTest5() { - MetaDynamicTerm mt1 = new MetaDynamicTerm( - new MetaTermGenerator() { - @Override - public MetaRDLTerm generate(int index, int depth, boolean isLast) { - if (isLast) { - return new MetaResource(new Variable("x"), new Variable("m")); - } - return new MetaDynamicTerm(this, new MetaResource(new Variable("y" + depth), new Variable("m-" + (depth+1))), new MetaResource(new Variable("z" + depth), new Variable("m-" + (depth+1)))); - } - }, - new MetaResource(new Variable("y"), new Constant("0")), - new MetaResource(new Variable("z"), new Constant("0")) - ); - - DependencyTerm t1 = new DependencyTerm(i, j, k); - DependencyTerm t2 = new DependencyTerm(t1, l, m); - DependencyTerm t3 = new DependencyTerm(t2, n, o); - assertTrue(! mt1.isMatchedBy(t3).isEmpty()); - - MatchConstraint result = mt1.isMatchedBy(t3).iterator().next(); - assertTrue(! mt1.dependencyTermGenerate(result.getBinding()).isMatchedBy(t3, result).isEmpty()); - assertEquals(mt1.substitute(result.getBinding()), t3); - } - -}