diff --git a/src/Main.java b/src/Main.java index e02bf34..cae17f4 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,39 +1,45 @@ -import models.EvaluatableTerm; +import lombok.SneakyThrows; +import models.Dependency; import models.ResourceVariable; +import models.algebra.Expression; import models.algebra.Type; +import models.algebra.Variable; import models.dataConstraintModel.DataConstraintModel; +import models.dataFlowModel.DataTransferModel; +import models.meta.MetaDependencyVariable; +import models.meta.MetaRDLTerm; +import models.meta.MetaResourceVariable; +import models.meta.OrderConstraint; +import parser.Parser; +import parser.Parser.TokenStream; public class Main { + static TokenStream stream = new Parser.TokenStream(); + static Parser parser = new Parser(stream); + static DataTransferModel model = new DataTransferModel(); + public static void main(String[] args) { Type INT = DataConstraintModel.typeInt; - Type STR = DataConstraintModel.typeString; - 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, 1); - ResourceVariable f = EvaluatableTerm.of("F", INT, 1); - ResourceVariable g = EvaluatableTerm.of("G", INT, 1); - ResourceVariable h = EvaluatableTerm.of("H", INT, 1); - ResourceVariable i = EvaluatableTerm.of("I", INT, 0); + ResourceVariable a = new ResourceVariable("a", INT, 0); + ResourceVariable b = new ResourceVariable("b", INT, 0); + Dependency dep = new Dependency(a, b); + System.out.println(dep.toStringWithOrder()); - EvaluatableTerm te1 = EvaluatableTerm.of(g, h, i); - EvaluatableTerm te2 = EvaluatableTerm.of(a, b, c); - EvaluatableTerm te3 = EvaluatableTerm.of(te2, d, e); - EvaluatableTerm te4 = EvaluatableTerm.of(te3, f, te1); - - var te5 = te4.linearRightNormalize(); - System.out.println(te4.toString()); - System.out.println(te4.getOrder()); - te4.selfLinearRightNormalize(); - System.out.println(te4.toString()); - System.out.println(te4.isLinearRightNormal()); - System.out.println(te4.getOrder()); - System.out.println(te5.toString()); - + MetaDependencyVariable d = new MetaDependencyVariable(new Variable("d"), OrderConstraint.EQ, parse("0")); + MetaResourceVariable x = new MetaResourceVariable(new Variable("x"), OrderConstraint.EQ, parse("x")); + MetaResourceVariable y = new MetaResourceVariable(new Variable("y"), OrderConstraint.EQ, parse("x")); + MetaRDLTerm term = new MetaRDLTerm(x, x); + System.out.println(term.isMatchedBy(dep)); + } + @SneakyThrows + public static Expression parse(String expr) { + stream.addLine(expr); + return parser.parseTerm(stream, model); + } + } diff --git a/src/exceptions/CoefficientNotOneException.java b/src/exceptions/CoefficientNotOneException.java new file mode 100644 index 0000000..ddef07c --- /dev/null +++ b/src/exceptions/CoefficientNotOneException.java @@ -0,0 +1,13 @@ +package exceptions; + +public class CoefficientNotOneException extends RuntimeException { + + public CoefficientNotOneException(String msg) { + super(msg); + } + + public CoefficientNotOneException() { + super("Coefficient is not 1."); + } + +} diff --git a/src/exceptions/NonLinearExpressionException.java b/src/exceptions/NonLinearExpressionException.java new file mode 100644 index 0000000..fc56963 --- /dev/null +++ b/src/exceptions/NonLinearExpressionException.java @@ -0,0 +1,13 @@ +package exceptions; + +public class NonLinearExpressionException extends RuntimeException { + + public NonLinearExpressionException() { + super("This Expression is not linear"); + } + + public NonLinearExpressionException(String msg) { + super(msg); + } + +} diff --git a/src/exceptions/TooManyVariablesException.java b/src/exceptions/TooManyVariablesException.java new file mode 100644 index 0000000..407ca30 --- /dev/null +++ b/src/exceptions/TooManyVariablesException.java @@ -0,0 +1,13 @@ +package exceptions; + +public class TooManyVariablesException extends RuntimeException { + + public TooManyVariablesException(String msg) { + super(msg); + } + + public TooManyVariablesException() { + super("Too many variables"); + } + +} diff --git a/src/models/meta/MetaDependencyTermVariable.java b/src/models/meta/MetaDependencyTermVariable.java index 7949701..bbea73f 100644 --- a/src/models/meta/MetaDependencyTermVariable.java +++ b/src/models/meta/MetaDependencyTermVariable.java @@ -1,6 +1,7 @@ package models.meta; import lombok.Getter; +import models.algebra.Constant; import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; @@ -11,5 +12,13 @@ public MetaDependencyTermVariable(Variable variableName, OrderConstraint constraint, Expression order) { super(new Symbol(":", 3), MetaRDLTerm.TermType.META_DEPENDENCY_TERM_VARIABLE, variableName, constraint, order); } + + public MetaDependencyTermVariable(Variable variableName) { + super(new Symbol(":", 3), MetaRDLTerm.TermType.META_DEPENDENCY_TERM_VARIABLE, variableName, OrderConstraint.ANY, new Constant("0")); + } + + public MetaDependencyTermVariable(Variable variableName, Expression order) { + super(new Symbol(":", 3), MetaRDLTerm.TermType.META_DEPENDENCY_TERM_VARIABLE, variableName, OrderConstraint.EQ, order); + } } diff --git a/src/models/meta/MetaDependencyVariable.java b/src/models/meta/MetaDependencyVariable.java index 5acf09d..75aa7e7 100644 --- a/src/models/meta/MetaDependencyVariable.java +++ b/src/models/meta/MetaDependencyVariable.java @@ -1,6 +1,7 @@ package models.meta; import lombok.Getter; +import models.algebra.Constant; import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; @@ -11,5 +12,13 @@ public MetaDependencyVariable(Variable variableName, OrderConstraint constraint, Expression order) { super(new Symbol(":", 2), MetaRDLTerm.TermType.META_DEPENDENCY_VARIABLE, variableName, constraint, order); } + + public MetaDependencyVariable(Variable variableName) { + super(new Symbol(":", 2), MetaRDLTerm.TermType.META_DEPENDENCY_VARIABLE, variableName, OrderConstraint.ANY, new Constant("0")); + } + + public MetaDependencyVariable(Variable variableName, Expression order) { + super(new Symbol(":", 2), MetaRDLTerm.TermType.META_DEPENDENCY_VARIABLE, variableName, OrderConstraint.EQ, order); + } } diff --git a/src/models/meta/MetaEvaluatableTermVariable.java b/src/models/meta/MetaEvaluatableTermVariable.java new file mode 100644 index 0000000..5c36b1e --- /dev/null +++ b/src/models/meta/MetaEvaluatableTermVariable.java @@ -0,0 +1,22 @@ +package models.meta; + +import models.algebra.Constant; +import models.algebra.Expression; +import models.algebra.Symbol; +import models.algebra.Variable; + +public class MetaEvaluatableTermVariable extends MetaVariable { + + public MetaEvaluatableTermVariable(Variable variableName, OrderConstraint constraint, Expression order) { + super(new Symbol(":", 2), MetaRDLTerm.TermType.META_EVALUATABLE_TERM_VARIABLE, variableName, constraint, order); + } + + public MetaEvaluatableTermVariable(Variable variableName) { + super(new Symbol(":", 2), MetaRDLTerm.TermType.META_EVALUATABLE_TERM_VARIABLE, variableName, OrderConstraint.ANY, new Constant("0")); + } + + public MetaEvaluatableTermVariable(Variable variableName, Expression order) { + super(new Symbol(":", 2), MetaRDLTerm.TermType.META_EVALUATABLE_TERM_VARIABLE, variableName, OrderConstraint.EQ, order); + } + +} diff --git a/src/models/meta/MetaRDLTerm.java b/src/models/meta/MetaRDLTerm.java index d18fad5..dedfb77 100644 --- a/src/models/meta/MetaRDLTerm.java +++ b/src/models/meta/MetaRDLTerm.java @@ -1,5 +1,6 @@ package models.meta; +import java.util.HashMap; import java.util.Map; import exceptions.IllegalTypeException; @@ -16,6 +17,7 @@ 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), @@ -143,6 +145,10 @@ return false; } + public boolean isMatchedBy(RDLTerm another) { + return isMatchedBy(another, new HashMap<>(), new HashMap<>()); + } + public boolean isMatchedBy(RDLTerm another, Map binding, Map orderConstraint) { if (! another.getClass().isAssignableFrom(this.termType.getClazz())) { return false; diff --git a/src/models/meta/MetaRDLTermVariable.java b/src/models/meta/MetaRDLTermVariable.java new file mode 100644 index 0000000..dd74db0 --- /dev/null +++ b/src/models/meta/MetaRDLTermVariable.java @@ -0,0 +1,22 @@ +package models.meta; + +import models.algebra.Constant; +import models.algebra.Expression; +import models.algebra.Symbol; +import models.algebra.Variable; + +public class MetaRDLTermVariable extends MetaVariable { + + public MetaRDLTermVariable(Variable variableName, OrderConstraint constraint, Expression order) { + super(new Symbol("", -1), MetaRDLTerm.TermType.META_RDL_TERM, variableName, constraint, order); + } + + public MetaRDLTermVariable(Variable variableName) { + super(new Symbol("", -1), MetaRDLTerm.TermType.META_RDL_TERM, variableName, OrderConstraint.ANY, new Constant("0")); + } + + public MetaRDLTermVariable(Variable variableName, Expression order) { + super(new Symbol("", -1), MetaRDLTerm.TermType.META_RDL_TERM, variableName, OrderConstraint.EQ, order); + } + +} diff --git a/src/models/meta/MetaResourceVariable.java b/src/models/meta/MetaResourceVariable.java index aebf565..c3534f7 100644 --- a/src/models/meta/MetaResourceVariable.java +++ b/src/models/meta/MetaResourceVariable.java @@ -1,6 +1,7 @@ package models.meta; import lombok.Getter; +import models.algebra.Constant; import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; @@ -12,4 +13,11 @@ super(new Symbol("", 0), MetaRDLTerm.TermType.META_RESOURCE_VARIABLE, variableName, constraint, order); } + public MetaResourceVariable(Variable variableName) { + super(new Symbol("", 0), MetaRDLTerm.TermType.META_RESOURCE_VARIABLE, variableName, OrderConstraint.ANY, new Constant("0")); + } + + public MetaResourceVariable(Variable variableName, Expression order) { + super(new Symbol("", 0), MetaRDLTerm.TermType.META_RESOURCE_VARIABLE, variableName, OrderConstraint.EQ, order); + } } diff --git a/src/models/meta/MetaVariable.java b/src/models/meta/MetaVariable.java index 2cec266..9e97762 100644 --- a/src/models/meta/MetaVariable.java +++ b/src/models/meta/MetaVariable.java @@ -3,6 +3,9 @@ import java.util.HashMap; import java.util.Map; +import exceptions.CoefficientNotOneException; +import exceptions.NonLinearExpressionException; +import exceptions.TooManyVariablesException; import lombok.Getter; import models.RDLTerm; import models.algebra.Constant; @@ -30,12 +33,12 @@ int constant = getCoefficientAndConstantsFromExpression(order, coefficients, 1); if (coefficients.size() > 1) { // todo: create exception - throw new RuntimeException("Too many variables exception"); + throw new TooManyVariablesException("Too many variables"); } if (coefficients.size() == 1) { orderVariable = coefficients.keySet().iterator().next(); if (coefficients.get(orderVariable) != 1) { - throw new RuntimeException("Coefficient not 1 exception"); + throw new CoefficientNotOneException(); } } else { orderVariable = null; @@ -51,7 +54,7 @@ @Override public boolean isMatchedBy(RDLTerm another, Map binding, Map orderConstraint) { - if (! another.getClass().isAssignableFrom(this.termType.getClazz())) { + if (! this.termType.getClazz().isAssignableFrom(another.getClass())) { return false; } @@ -131,13 +134,13 @@ getCoefficientAndConstantsFromExpression(c2, coefficients, curWeight) ); } else { - throw new RuntimeException("Order expression must be linear expression."); + throw new NonLinearExpressionException("Order expression must be linear expression."); } } else if(symbol.equals(DataConstraintModel.minus)) { Expression c1 = term.getChild(0); res += getCoefficientAndConstantsFromExpression(c1, coefficients, -curWeight); } else { - throw new RuntimeException("Order expression must be linear expression."); + throw new NonLinearExpressionException("Order expression must be linear expression."); } return res; diff --git a/src/tests/Utils.java b/src/tests/Utils.java new file mode 100644 index 0000000..d9e754e --- /dev/null +++ b/src/tests/Utils.java @@ -0,0 +1,31 @@ +package tests; + +import models.algebra.Expression; +import models.algebra.Type; +import models.dataConstraintModel.DataConstraintModel; +import models.dataFlowModel.DataTransferModel; +import parser.Parser; +import parser.Parser.TokenStream; +import parser.exceptions.ExpectedColon; +import parser.exceptions.ExpectedDoubleQuotation; +import parser.exceptions.ExpectedRightBracket; +import parser.exceptions.WrongJsonExpression; + +public class Utils { + + public static Type INT = DataConstraintModel.typeInt; + private static TokenStream stream = new Parser.TokenStream(); + private static Parser parser = new Parser(stream); + private static DataTransferModel model = new DataTransferModel(); + + public static Expression parse(String expr) { + stream.addLine(expr); + try { + return parser.parseTerm(stream, model); + } catch (ExpectedRightBracket | WrongJsonExpression | ExpectedColon | ExpectedDoubleQuotation e) { + e.printStackTrace(); + return null; + } + } + +} diff --git a/src/tests/meta/MetaResourceVariableTest.java b/src/tests/meta/MetaResourceVariableTest.java new file mode 100644 index 0000000..56036ae --- /dev/null +++ b/src/tests/meta/MetaResourceVariableTest.java @@ -0,0 +1,50 @@ +package tests.meta; + +import static org.junit.jupiter.api.Assertions.*; +import static tests.Utils.*; + +import org.junit.jupiter.api.Test; + +import models.Dependency; +import models.DependencyTerm; +import models.ResourceVariable; +import models.algebra.Variable; +import models.meta.MetaDependencyTermVariable; +import models.meta.MetaDependencyVariable; +import models.meta.MetaEvaluatableTermVariable; +import models.meta.MetaRDLTermVariable; +import models.meta.MetaResourceVariable; + +public class MetaResourceVariableTest { + + @Test + void MetaResourceVariableMathcingWithoutOrder() { + ResourceVariable a = new ResourceVariable("a", INT, 0); + ResourceVariable b = new ResourceVariable("b", INT, 0); + ResourceVariable c = new ResourceVariable("c", INT, 0); + Dependency dep = new Dependency(a, b); + DependencyTerm depTerm = new DependencyTerm(dep, c); + + MetaResourceVariable x = new MetaResourceVariable(new Variable("x")); + MetaDependencyVariable d = new MetaDependencyVariable(new Variable("d")); + MetaDependencyTermVariable dte = new MetaDependencyTermVariable(new Variable("dte")); + MetaEvaluatableTermVariable te = new MetaEvaluatableTermVariable(new Variable("te")); + MetaRDLTermVariable t = new MetaRDLTermVariable(new Variable("t")); + + // a matches x(resource variable) + assertTrue(x.isMatchedBy(a)); + // a does not match d(dependency) + assertFalse(d.isMatchedBy(a)); + // a does not match dte(dependency term) + assertFalse(dte.isMatchedBy(a)); + // a matches te(evaluatable term) + assertTrue(te.isMatchedBy(a)); + // a matches t(term) + assertTrue(t.isMatchedBy(a)); + // [a : b] does not match x(resource variable) + assertFalse(x.isMatchedBy(dep)); + // [a : b -> c] does not match x(resource variable) + assertFalse(x.isMatchedBy(depTerm)); + } + +} diff --git a/target/classes/Main.class b/target/classes/Main.class index f6b89b4..e839b6f 100644 --- a/target/classes/Main.class +++ b/target/classes/Main.class Binary files differ