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/MetaDynaimcDependencyTerm.java b/src/main/java/models/terms/meta/MetaDynaimcDependencyTerm.java index d74ec0a..410e28b 100644 --- a/src/main/java/models/terms/meta/MetaDynaimcDependencyTerm.java +++ b/src/main/java/models/terms/meta/MetaDynaimcDependencyTerm.java @@ -3,6 +3,7 @@ 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; @@ -41,6 +42,10 @@ // 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) { @@ -86,7 +91,10 @@ @Override protected Set isMatchedBy(RDLTerm another, Set constraint, int depth) { - return null; + int maxIndex = another.getMaxIndex(); + int maxDepth = another.getMaxDepth(); + MetaRDLTerm metaTerm = generate(maxIndex, maxDepth, new HashMap<>()); + return metaTerm.isMatchedBy(another, constraint, depth); } @Override diff --git a/src/main/java/models/terms/meta/MetaDynamicDependency.java b/src/main/java/models/terms/meta/MetaDynamicDependency.java index 91ede03..e6050b3 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.HashMap; import java.util.List; import java.util.Map; import java.util.Set; @@ -34,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; @@ -63,7 +63,10 @@ @Override protected Set isMatchedBy(RDLTerm another, MatchConstraint constraint, int depth) { - return null; + int maxIndex = another.getMaxIndex(); + int maxDepth = another.getMaxDepth(); + MetaRDLTerm metaDep = generate(maxIndex, maxDepth, new HashMap<>()); + return metaDep.isMatchedBy(another, constraint, depth); } @Override 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 fe0bc80..a528fed 100644 --- a/src/main/java/models/terms/meta/MetaRDLTerm.java +++ b/src/main/java/models/terms/meta/MetaRDLTerm.java @@ -112,6 +112,16 @@ @Override + public int getMaxIndex() { + return -1; + } + + @Override + public int getMaxDepth() { + return -1; + } + + @Override public String toStringWithOrder() { switch(termType) { case META_DEPENDENCY: 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); - } - -}