diff --git a/src/models/meta/MetaDependencyTermVariable.java b/src/models/meta/MetaDependencyTermVariable.java index 3a248f3..7949701 100644 --- a/src/models/meta/MetaDependencyTermVariable.java +++ b/src/models/meta/MetaDependencyTermVariable.java @@ -1,22 +1,15 @@ package models.meta; import lombok.Getter; +import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; @Getter -public class MetaDependencyTermVariable extends MetaRDLTerm { +public class MetaDependencyTermVariable extends MetaVariable { - protected Variable variableName; - - public MetaDependencyTermVariable(Variable variableName, int order) { - super(new Symbol(":", 3), order, MetaRDLTerm.TermType.META_DEPENDENCY_TERM_VARIABLE); - this.variableName = variableName; - } - - @Override - public boolean isVariable() { - return true; + public MetaDependencyTermVariable(Variable variableName, OrderConstraint constraint, Expression order) { + super(new Symbol(":", 3), MetaRDLTerm.TermType.META_DEPENDENCY_TERM_VARIABLE, variableName, constraint, order); } } diff --git a/src/models/meta/MetaDependencyVariable.java b/src/models/meta/MetaDependencyVariable.java index 0d37cc0..5acf09d 100644 --- a/src/models/meta/MetaDependencyVariable.java +++ b/src/models/meta/MetaDependencyVariable.java @@ -1,23 +1,15 @@ package models.meta; import lombok.Getter; +import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; @Getter -public class MetaDependencyVariable extends MetaRDLTerm { +public class MetaDependencyVariable extends MetaVariable { - protected Variable variableName; - - public MetaDependencyVariable(Variable variableName, int order) { - super(new Symbol(":", 2), order, MetaRDLTerm.TermType.META_DEPENDENCY_VARIABLE); - this.variableName = variableName; + public MetaDependencyVariable(Variable variableName, OrderConstraint constraint, Expression order) { + super(new Symbol(":", 2), MetaRDLTerm.TermType.META_DEPENDENCY_VARIABLE, variableName, constraint, order); } - @Override - public boolean isVariable() { - return true; - } - - } diff --git a/src/models/meta/MetaRDLTerm.java b/src/models/meta/MetaRDLTerm.java index ae79d60..d18fad5 100644 --- a/src/models/meta/MetaRDLTerm.java +++ b/src/models/meta/MetaRDLTerm.java @@ -1,30 +1,45 @@ package models.meta; +import java.util.Map; + import exceptions.IllegalTypeException; import lombok.Getter; import models.Dependency; +import models.DependencyTerm; import models.EvaluatableTerm; import models.RDLTerm; import models.ResourceVariable; import models.algebra.Symbol; +import models.algebra.Variable; @Getter public class MetaRDLTerm extends RDLTerm { protected static enum TermType { - META_DEPENDENCY, - META_DEPENDENCY_LIST, - META_DEPENDENCY_VARIABLE, - META_DEPENDENCY_TERM, - META_DEPENDENCY_TERM_VARIABLE, - META_EVALUATABLE_TERM_VARIABLE, - META_RESOURCE_VARIABLE; + 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_RESOURCE_VARIABLE(ResourceVariable.class); + + private Class clazz; + + TermType(Class clazz) { + this.clazz = clazz; + } + + public Class getClazz() { + return this.clazz; + } + } protected TermType termType; - protected MetaRDLTerm(Symbol symbol, int order, TermType termType) { - super(symbol, order); + protected MetaRDLTerm(Symbol symbol, TermType termType) { + super(symbol, -1); this.termType = termType; } @@ -128,6 +143,30 @@ return false; } + public boolean isMatchedBy(RDLTerm another, Map binding, Map orderConstraint) { + if (! another.getClass().isAssignableFrom(this.termType.getClazz())) { + return false; + } + if (this.getChildren().size() != another.getChildren().size()) { + return false; + } + for (int i = 0; i < this.getChildren().size(); i++) { + RDLTerm child = (RDLTerm) this.getChild(i); + RDLTerm anotherChild = (RDLTerm) another.getChild(i); + if (child instanceof MetaRDLTerm) { + MetaRDLTerm metaChild = (MetaRDLTerm) child; + if (! metaChild.isMatchedBy(anotherChild, binding, orderConstraint)) { + return false; + } + } else { + if (!(child.equals(anotherChild))) { + return false; + } + } + } + return true; + } + @Override public String toString() { @@ -163,18 +202,18 @@ if(! (another instanceof MetaRDLTerm)) { return false; } - return false; + MetaRDLTerm anotherTerm = (MetaRDLTerm) another; + return super.equals(another) && termType == anotherTerm.getTermType(); } @Override public int hashCode() { - // TODO 自動生成されたメソッド・スタブ - return 0; + return (termType.toString() + toStringWithOrder()).hashCode(); } @Override public Object clone() { - // TODO 自動生成されたメソッド・スタブ + return null; } diff --git a/src/models/meta/MetaResourceVariable.java b/src/models/meta/MetaResourceVariable.java index 96731be..aebf565 100644 --- a/src/models/meta/MetaResourceVariable.java +++ b/src/models/meta/MetaResourceVariable.java @@ -1,23 +1,15 @@ package models.meta; import lombok.Getter; +import models.algebra.Expression; import models.algebra.Symbol; import models.algebra.Variable; @Getter -public class MetaResourceVariable extends MetaRDLTerm { - - protected Variable variableName; +public class MetaResourceVariable extends MetaVariable { - public MetaResourceVariable(Variable variableName, int order) { - super(new Symbol("", 0), order, MetaRDLTerm.TermType.META_RESOURCE_VARIABLE); - this.variableName = variableName; + public MetaResourceVariable(Variable variableName, OrderConstraint constraint, Expression order) { + super(new Symbol("", 0), MetaRDLTerm.TermType.META_RESOURCE_VARIABLE, variableName, constraint, order); } - @Override - public boolean isVariable() { - return true; - } - - } diff --git a/src/models/meta/MetaVariable.java b/src/models/meta/MetaVariable.java new file mode 100644 index 0000000..2cec266 --- /dev/null +++ b/src/models/meta/MetaVariable.java @@ -0,0 +1,187 @@ +package models.meta; + +import java.util.HashMap; +import java.util.Map; + +import lombok.Getter; +import models.RDLTerm; +import models.algebra.Constant; +import models.algebra.Expression; +import models.algebra.Symbol; +import models.algebra.Term; +import models.algebra.Variable; +import models.dataConstraintModel.DataConstraintModel; + +@Getter +public abstract class MetaVariable extends MetaRDLTerm { + + protected Variable variableName; + protected OrderConstraint constraint; + protected Variable orderVariable; + protected int orderConstant; + protected Expression orderExpression; + + protected MetaVariable(Symbol symbol, TermType termType, Variable name, OrderConstraint constraint, Expression order) { + super(symbol, termType); + this.variableName = name; + this.constraint = constraint; + this.orderExpression = order; + Map coefficients = new HashMap<>(); + int constant = getCoefficientAndConstantsFromExpression(order, coefficients, 1); + if (coefficients.size() > 1) { + // todo: create exception + throw new RuntimeException("Too many variables exception"); + } + if (coefficients.size() == 1) { + orderVariable = coefficients.keySet().iterator().next(); + if (coefficients.get(orderVariable) != 1) { + throw new RuntimeException("Coefficient not 1 exception"); + } + } else { + orderVariable = null; + } + orderConstant = constant; + } + + @Override + public boolean isVariable() { + return true; + } + + @Override + public boolean isMatchedBy(RDLTerm another, Map binding, + Map orderConstraint) { + if (! another.getClass().isAssignableFrom(this.termType.getClazz())) { + return false; + } + + if (! orderConstraintCheck(another, orderConstraint)) { + return false; + } + + if (! binding.containsKey(this.variableName)) { + binding.put(this.variableName, another); + return true; + } + return binding.get(this.variableName).equals(another); + } + + private boolean orderConstraintCheck(RDLTerm another, Map orderConstraints) { + if (orderVariable == null) { + switch (constraint) { + case ANY: + return true; + case EQ: + return another.getOrder() == orderConstant; + case GE: + return another.getOrder() >= orderConstant; + case GT: + return another.getOrder() > orderConstant; + case LE: + return another.getOrder() <= orderConstant; + case LT: + return another.getOrder() < orderConstant; + } + } else { + if (! orderConstraints.containsKey(orderVariable)) { + orderConstraints.put(orderVariable, new OrderVariableConstraint()); + } + var orderVarConst = orderConstraints.get(orderVariable); + return orderVarConst.setConstraint(another.getOrder() - orderConstant, constraint); + } + return false; + } + + private int getCoefficientAndConstantsFromExpression(Expression expression, Map coefficients, int curWeight) { + int res = 0; + if(expression instanceof Constant) { + return getConstantValue((Constant) expression) * curWeight; + } else if(expression instanceof Variable) { + coefficients.put((Variable) expression, coefficients.getOrDefault((Variable) expression, 0) + curWeight); + return 0; + } + Term term = (Term) expression; + Symbol symbol = term.getSymbol(); + if(symbol.equals(DataConstraintModel.add)) { + Expression c1 = term.getChild(0); + Expression c2 = term.getChild(1); + res += getCoefficientAndConstantsFromExpression(c1, coefficients, curWeight); + res += getCoefficientAndConstantsFromExpression(c2, coefficients, curWeight); + } else if(symbol.equals(DataConstraintModel.sub)) { + Expression c1 = term.getChild(0); + Expression c2 = term.getChild(1); + res += getCoefficientAndConstantsFromExpression(c1, coefficients, curWeight); + res += getCoefficientAndConstantsFromExpression(c2, coefficients, -curWeight); + } else if(symbol.equals(DataConstraintModel.mul)) { + Expression c1 = term.getChild(0); + Expression c2 = term.getChild(1); + if(c1.getVariables().size() == 0 && c2.getVariables().size() == 0) { + res += getCoefficientAndConstantsFromExpression(c1, coefficients, curWeight) * + getCoefficientAndConstantsFromExpression(c2, coefficients, curWeight); + } else if(c1.getVariables().size() == 0) { + res += getCoefficientAndConstantsFromExpression( + c2, + coefficients, + getCoefficientAndConstantsFromExpression(c1, coefficients, curWeight) + ); + } else if(c2.getVariables().size() == 0){ + res += getCoefficientAndConstantsFromExpression( + c1, + coefficients, + getCoefficientAndConstantsFromExpression(c2, coefficients, curWeight) + ); + } else { + throw new RuntimeException("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."); + } + return res; + + } + + private int getConstantValue(Constant constant) { + return Integer.parseInt((String) constant.getValue()); + } + + + @Override + public String toString() { + return variableName.toString(); + } + + @Override + public String toStringWithOrder() { + return toString() + "(" + orderExpression.toString() + ")"; + } + + @Override + public boolean equals(Object another) { + if (another instanceof MetaVariable) { + return false; + } + MetaVariable anotherVar = (MetaVariable) another; + return super.equals(another) + && variableName.equals(another) + && constraint == anotherVar.getConstraint() + && orderVariable.equals(anotherVar.getOrderVariable()) + && orderConstant == anotherVar.getOrderConstant(); + } + + @Override + public int hashCode() { + return (termType.name() + toString()).hashCode(); + } + + @Override + public Object clone() { + // TODO 自動生成されたメソッド・スタブ + return super.clone(); + } + + + +} diff --git a/src/models/meta/OrderConstraint.java b/src/models/meta/OrderConstraint.java new file mode 100644 index 0000000..000ca02 --- /dev/null +++ b/src/models/meta/OrderConstraint.java @@ -0,0 +1,12 @@ +package models.meta; + +public enum OrderConstraint { + + EQ, + LT, + LE, + GT, + GE, + ANY; + +} diff --git a/src/models/meta/OrderVariableConstraint.java b/src/models/meta/OrderVariableConstraint.java new file mode 100644 index 0000000..e4a1342 --- /dev/null +++ b/src/models/meta/OrderVariableConstraint.java @@ -0,0 +1,58 @@ +package models.meta; + +import lombok.NoArgsConstructor; + +@NoArgsConstructor +public class OrderVariableConstraint { + + // lower <= x <= upper + private int upper = 100000000; + private int lower = -1; + private boolean isOk = true; + + public boolean setConstraint(int value, OrderConstraint constraint) { + switch (constraint) { + case ANY: + return true; + case EQ: + return setEq(value); + case GE: + return setUpper(value); + case GT: + return setUpper(value - 1); + case LE: + return setLower(value); + case LT: + return setLower(value + 1); + } + return false; + } + + public boolean isOk() { + return isOk; + } + + + private boolean setEq(int eq) { + return setUpper(eq) && setLower(eq); + } + + private boolean setUpper(int upper) { + if (isOk && this.lower <= upper && upper <= this.upper) { + this.upper = upper; + return true; + } + isOk = false; + return false; + } + + private boolean setLower(int lower) { + if (isOk && this.lower <= lower && lower <= this.upper) { + this.lower = lower; + return true; + } + isOk = false; + return false; + } + +} diff --git a/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties index 6852089..e8ea7d7 100644 --- a/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties +++ b/target/classes/META-INF/maven/ResourceDependencyLogic/ResourceDependencyLogic/pom.properties @@ -1,5 +1,5 @@ #Generated by Maven Integration for Eclipse -#Thu Oct 16 19:30:41 JST 2025 +#Sat Oct 18 21:55:42 JST 2025 m2e.projectLocation=C\:\\pleiades\\2023-03\\myproject\\ResourceDependencyLogic m2e.projectName=ResourceDependencyLogic groupId=ResourceDependencyLogic