diff --git a/src/models/terms/DependencyTerm.java b/src/models/terms/DependencyTerm.java index d7be3ac..153c5d7 100644 --- a/src/models/terms/DependencyTerm.java +++ b/src/models/terms/DependencyTerm.java @@ -25,7 +25,7 @@ } @Override - public boolean isLinearRightNormal() { + public boolean isLinearRightNormalized() { return isLinearRightNormal(0); } @@ -43,10 +43,10 @@ return; } DependencyTerm dependencyTerm = (DependencyTerm) dependingTerm; - if(! dependencyTerm.isLinearRightNormal()) { + if(! dependencyTerm.isLinearRightNormalized()) { dependencyTerm.selfLinearRightNormalize(); } - if(! isLinearRightNormal()) { + if(! isLinearRightNormalized()) { EvaluatableTerm childArgumentTerm = dependencyTerm.getArgumentTerm(); DependencyTerm nextDependencyTerm = new DependencyTerm(childArgumentTerm, dependedVariable, argumentTerm); this.dependingTerm = dependencyTerm.getDependingTerm(); diff --git a/src/models/terms/EvaluatableTerm.java b/src/models/terms/EvaluatableTerm.java index 624f6f6..d75d77b 100644 --- a/src/models/terms/EvaluatableTerm.java +++ b/src/models/terms/EvaluatableTerm.java @@ -10,7 +10,13 @@ super(symbol, order); } - public abstract boolean isLinearRightNormal(); + public abstract boolean isLinearRightNormalized(); + public LinearRightNormalizedType getLinearRightNormalizedType() { + if (isLinearRightNormalized()) { + return LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED; + } + return LinearRightNormalizedType.NOT_LINEAR_RIGHT_NORMALIZED; + } public abstract EvaluatableTerm linearRightNormalize(); public abstract void selfLinearRightNormalize(); diff --git a/src/models/terms/LinearRightNormalizedType.java b/src/models/terms/LinearRightNormalizedType.java new file mode 100644 index 0000000..e043c08 --- /dev/null +++ b/src/models/terms/LinearRightNormalizedType.java @@ -0,0 +1,9 @@ +package models.terms; + +public enum LinearRightNormalizedType { + + LINEAR_RIGHT_NORMALIZED, + NOT_LINEAR_RIGHT_NORMALIZED, + UNDEFINED + +} diff --git a/src/models/terms/ResourceConstant.java b/src/models/terms/ResourceConstant.java index 1cdddfd..a7c2d1b 100644 --- a/src/models/terms/ResourceConstant.java +++ b/src/models/terms/ResourceConstant.java @@ -23,7 +23,7 @@ } @Override - public boolean isLinearRightNormal() { + public boolean isLinearRightNormalized() { return true; } diff --git a/src/models/terms/ResourceVariable.java b/src/models/terms/ResourceVariable.java index 909da7e..819f362 100644 --- a/src/models/terms/ResourceVariable.java +++ b/src/models/terms/ResourceVariable.java @@ -26,7 +26,7 @@ } @Override - public boolean isLinearRightNormal() { + public boolean isLinearRightNormalized() { return true; } diff --git a/src/models/terms/SetEvaluatableTerm.java b/src/models/terms/SetEvaluatableTerm.java index 5a70374..5a9c1c9 100644 --- a/src/models/terms/SetEvaluatableTerm.java +++ b/src/models/terms/SetEvaluatableTerm.java @@ -41,8 +41,8 @@ } @Override - public boolean isLinearRightNormal() { - return term.isLinearRightNormal(); + public boolean isLinearRightNormalized() { + return term.isLinearRightNormalized(); } diff --git a/src/models/terms/meta/MetaRDLTerm.java b/src/models/terms/meta/MetaRDLTerm.java index 6a78803..1d170a1 100644 --- a/src/models/terms/meta/MetaRDLTerm.java +++ b/src/models/terms/meta/MetaRDLTerm.java @@ -10,6 +10,7 @@ import models.terms.Dependency; import models.terms.DependencyTerm; import models.terms.EvaluatableTerm; +import models.terms.LinearRightNormalizedType; import models.terms.RDLTerm; import models.terms.ResourceVariable; import models.terms.SetEvaluatableTerm; @@ -17,32 +18,15 @@ @Getter public class MetaRDLTerm extends RDLTerm { - protected static enum TermType { - META_RDL_TERM(RDLTerm.class), - META_DEPENDENCY(Dependency.class), - META_DEPENDENCY_LIST(Dependency.class), - META_DEPENDENCY_VARIABLE(Dependency.class), - META_DEPENDENCY_TERM(DependencyTerm.class), - META_DEPENDENCY_TERM_VARIABLE(DependencyTerm.class), - META_EVALUATABLE_TERM_VARIABLE(EvaluatableTerm.class), - META_EVALUATABLE_TERM_SET(SetEvaluatableTerm.class), - META_EVALUATABLE_TERM_SET_VARIABLE(SetEvaluatableTerm.class), - META_RESOURCE_VARIABLE(ResourceVariable.class); - - @Getter - private Class baseTermClass; - - private TermType(Class clazz) { - this.baseTermClass = clazz; - } - - } - protected TermType termType; + protected LinearRightNormalizedType linearRightNormalizedType; protected MetaRDLTerm(Symbol symbol, TermType termType) { super(symbol, -1); this.termType = termType; + if (isResourceVariable()) { + linearRightNormalizedType = LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED; + } } //dependency @@ -175,6 +159,9 @@ if (this.getChildren().size() != another.getChildren().size()) { return false; } + if (isDependencyTerm() && (! islinearRightNormalizedMatchedBy(another))) { + return false; + } for (int i = 0; i < this.getChildren().size(); i++) { RDLTerm child = (RDLTerm) this.getChild(i); RDLTerm anotherChild = (RDLTerm) another.getChild(i); @@ -212,6 +199,28 @@ return checkTermType(ResourceVariable.class); } + public void setLinearRightNormalizedType(LinearRightNormalizedType next) { + if (isDependency()) { + return; + } + this.linearRightNormalizedType = next; + } + + protected boolean islinearRightNormalizedMatchedBy(RDLTerm another) { + if (linearRightNormalizedType != LinearRightNormalizedType.UNDEFINED) { + if (another instanceof DependencyTerm) { + if (((DependencyTerm) another).getLinearRightNormalizedType() != linearRightNormalizedType) { + return false; + } + } + else if (another instanceof MetaRDLTerm) { + if (((MetaRDLTerm) another).getLinearRightNormalizedType() != linearRightNormalizedType) { + return false; + } + } + } + return true; + } @Override public String toString() { @@ -262,4 +271,25 @@ return null; } + protected static enum TermType { + META_RDL_TERM(RDLTerm.class), + META_DEPENDENCY(Dependency.class), + META_DEPENDENCY_LIST(Dependency.class), + META_DEPENDENCY_VARIABLE(Dependency.class), + META_DEPENDENCY_TERM(DependencyTerm.class), + META_DEPENDENCY_TERM_VARIABLE(DependencyTerm.class), + META_EVALUATABLE_TERM_VARIABLE(EvaluatableTerm.class), + META_EVALUATABLE_TERM_SET(SetEvaluatableTerm.class), + META_EVALUATABLE_TERM_SET_VARIABLE(SetEvaluatableTerm.class), + META_RESOURCE_VARIABLE(ResourceVariable.class); + + @Getter + private Class baseTermClass; + + private TermType(Class clazz) { + this.baseTermClass = clazz; + } + + } + } diff --git a/src/models/terms/meta/MetaVariable.java b/src/models/terms/meta/MetaVariable.java index 3d44a2b..e9bc690 100644 --- a/src/models/terms/meta/MetaVariable.java +++ b/src/models/terms/meta/MetaVariable.java @@ -62,6 +62,10 @@ return false; } + if (! islinearRightNormalizedMatchedBy(another)) { + return false; + } + if (! binding.containsKey(this.variableName)) { binding.put(this.variableName, another); return true; diff --git a/src/tests/terms/LinearRightNormalTest.java b/src/tests/terms/LinearRightNormalTest.java index c5e7846..27e464b 100644 --- a/src/tests/terms/LinearRightNormalTest.java +++ b/src/tests/terms/LinearRightNormalTest.java @@ -5,9 +5,14 @@ import org.junit.jupiter.api.Test; import models.algebra.Type; +import models.algebra.Variable; import models.dataConstraintModel.DataConstraintModel; import models.terms.EvaluatableTerm; +import models.terms.LinearRightNormalizedType; import models.terms.ResourceVariable; +import models.terms.meta.MetaEvaluatableTermVariable; +import models.terms.meta.MetaRDLTerm; +import models.terms.meta.MetaResourceVariable; public class LinearRightNormalTest { @@ -29,13 +34,13 @@ EvaluatableTerm te2 = EvaluatableTerm.of(c, d, te1); EvaluatableTerm te3 = EvaluatableTerm.of(a, b, te2); //[a:b->[c:d->[e:f->g]]] - assertEquals(te3.isLinearRightNormal(), true); + assertEquals(te3.isLinearRightNormalized(), true); EvaluatableTerm te4 = EvaluatableTerm.of(a, b, c); EvaluatableTerm te5 = EvaluatableTerm.of(te4, d, e); EvaluatableTerm te6 = EvaluatableTerm.of(te5, f, g); //[[[a:b->c]:d->e]:f->g] - assertEquals(te6.isLinearRightNormal(), false); + assertEquals(te6.isLinearRightNormalized(), false); } @Test @@ -53,9 +58,38 @@ EvaluatableTerm te2 = EvaluatableTerm.of(te1, d, e); EvaluatableTerm te3 = EvaluatableTerm.of(te2, f, g); - assertEquals(te3.isLinearRightNormal(), false); + assertEquals(te3.isLinearRightNormalized(), false); te3.selfLinearRightNormalize(); - assertEquals(te3.isLinearRightNormal(), true); + assertEquals(te3.isLinearRightNormalized(), true); + } + + @Test + void linearRightNomalizedMatchTest() { + ResourceVariable a = EvaluatableTerm.of("A", INT, 2); + ResourceVariable b = EvaluatableTerm.of("B", INT, 2); + ResourceVariable c = EvaluatableTerm.of("C", INT, 2); + ResourceVariable d = EvaluatableTerm.of("D", INT, 2); + ResourceVariable e = EvaluatableTerm.of("E", INT, 2); + ResourceVariable f = EvaluatableTerm.of("F", INT, 2); + ResourceVariable g = EvaluatableTerm.of("G", INT, 1); + + EvaluatableTerm te1 = EvaluatableTerm.of(a, b, c); + EvaluatableTerm te2 = EvaluatableTerm.of(te1, d, e); + EvaluatableTerm te3 = EvaluatableTerm.of(te2, f, g); + + MetaEvaluatableTermVariable metaTerm = new MetaEvaluatableTermVariable(new Variable("x")); + MetaResourceVariable metaA = new MetaResourceVariable(new Variable("ma")); + MetaResourceVariable metaB = new MetaResourceVariable(new Variable("mb")); + MetaResourceVariable metaC = new MetaResourceVariable(new Variable("mc")); + MetaRDLTerm metaTerm2 = new MetaRDLTerm(metaA, metaB, metaC); + metaTerm2.setLinearRightNormalizedType(LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED); + + + metaTerm.setLinearRightNormalizedType(LinearRightNormalizedType.LINEAR_RIGHT_NORMALIZED); + assertEquals(metaTerm.isMatchedBy(te3), false); + te3.selfLinearRightNormalize(); + assertEquals(metaTerm.isMatchedBy(te3), true); + assertEquals(metaTerm2.isMatchedBy(te1), true); } }