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/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..d74ec0a --- /dev/null +++ b/src/main/java/models/terms/meta/MetaDynaimcDependencyTerm.java @@ -0,0 +1,108 @@ +package models.terms.meta; + +import com.google.common.collect.TreeMultiset; + +import java.util.ArrayList; +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; + } + + @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) { + return null; + } + + @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..91ede03 100644 --- a/src/main/java/models/terms/meta/MetaDynamicDependency.java +++ b/src/main/java/models/terms/meta/MetaDynamicDependency.java @@ -5,7 +5,9 @@ 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 +23,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) { @@ -58,7 +63,6 @@ @Override protected Set isMatchedBy(RDLTerm another, MatchConstraint constraint, int depth) { - // TODO 自動生成されたメソッド・スタブ return null; } @@ -69,4 +73,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/MetaRDLTerm.java b/src/main/java/models/terms/meta/MetaRDLTerm.java index 9ceb9f4..fe0bc80 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,19 +112,6 @@ @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 ""; - } - } - - @Override public String toStringWithOrder() { switch(termType) { case META_DEPENDENCY: