diff --git a/reactor/.idea/libraries/com_google_collections_google_collections_1_0.xml b/reactor/.idea/libraries/com_google_collections_google_collections_1_0.xml new file mode 100644 index 00000000..42947474 --- /dev/null +++ b/reactor/.idea/libraries/com_google_collections_google_collections_1_0.xml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/reactor/.idea/libraries/lib.xml b/reactor/.idea/libraries/lib.xml deleted file mode 100644 index 72e3b2ee..00000000 --- a/reactor/.idea/libraries/lib.xml +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - - - - - \ No newline at end of file diff --git a/reactor/.idea/modules.xml b/reactor/.idea/modules.xml index 04f1eb91..415bf452 100644 --- a/reactor/.idea/modules.xml +++ b/reactor/.idea/modules.xml @@ -3,6 +3,8 @@ + + \ No newline at end of file diff --git a/reactor/.idea/uiDesigner.xml b/reactor/.idea/uiDesigner.xml new file mode 100644 index 00000000..e96534fb --- /dev/null +++ b/reactor/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/reactor/API/API.iml b/reactor/API/API.iml index c90834f2..e6f15ad7 100644 --- a/reactor/API/API.iml +++ b/reactor/API/API.iml @@ -7,5 +7,6 @@ + \ No newline at end of file diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/AbstractConstraint.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/AbstractConstraint.java index 129bc8b2..4a3ece03 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/AbstractConstraint.java +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/AbstractConstraint.java @@ -48,8 +48,8 @@ public abstract class AbstractConstraint implements ComputingItem { return (Constraint) this; } - public AutoConstraint asAutoConstraint() { - return (AutoConstraint) this; + public BuiltinConstraint asAutoConstraint() { + return (BuiltinConstraint) this; } protected void registerHandler(ComputingSession session, Instructible instructible) { diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/AutoConstraint.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/BuiltinConstraint.java similarity index 85% rename from reactor/API/src/jetbrains/mps/logic/reactor/constraint/AutoConstraint.java rename to reactor/API/src/jetbrains/mps/logic/reactor/constraint/BuiltinConstraint.java index c6870020..de1317f7 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/AutoConstraint.java +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/BuiltinConstraint.java @@ -6,7 +6,7 @@ package jetbrains.mps.logic.reactor.constraint; /** * A constraint that is provided by a solver. Can be either told or asked for a constraint. */ -public interface AutoConstraint extends Constraint { +public interface BuiltinConstraint extends Constraint { public Queryable solver(ComputingSession session); diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingSession.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingSession.java index 40f1da6c..4783706a 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingSession.java +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingSession.java @@ -45,7 +45,7 @@ public class ComputingSession { } - public boolean ask(AutoConstraint autoConstraint, Object... arg) { + public boolean ask(BuiltinConstraint autoConstraint, Object... arg) { Queryable solver = solver(autoConstraint); if (solver == null) { throw new IllegalStateException("no solver for '" + autoConstraint.symbol() + "'"); @@ -72,8 +72,8 @@ public class ComputingSession { return null; } - public AutoConstraint lookupAutoConstraint(Class clazz) { - for (Map.Entry e : solvers.entrySet()) { + public BuiltinConstraint lookupAutoConstraint(Class clazz) { + for (Map.Entry e : solvers.entrySet()) { if (clazz.isAssignableFrom(e.getKey().solverClass())) { return e.getKey(); } @@ -88,7 +88,7 @@ public class ComputingSession { return handlers.get(constraint); } - protected Queryable solver(AutoConstraint constraint) { + protected Queryable solver(BuiltinConstraint constraint) { if (!(solvers.containsKey(constraint))) { throw new IllegalStateException("no handler: " + constraint); } @@ -99,13 +99,13 @@ public class ComputingSession { handlers.put(constraint, instructible); } - protected void registerSolver(AutoConstraint constraint, Queryable queryable) { + protected void registerSolver(BuiltinConstraint constraint, Queryable queryable) { solvers.put(constraint, queryable); } private Map handlers = new HashMap(); - private Map solvers = new HashMap(); + private Map solvers = new HashMap(); private final ComputingTracer tracer; } diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingTracer.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingTracer.java index f2ab9f53..d4ee2854 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingTracer.java +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ComputingTracer.java @@ -5,8 +5,8 @@ package jetbrains.mps.logic.reactor.constraint; public interface ComputingTracer { - public void askSuccess(AutoConstraint autoConstraint, Object... args); + public void askSuccess(BuiltinConstraint autoConstraint, Object... args); - public void askFailure(AutoConstraint autoConstraint, Object... args); + public void askFailure(BuiltinConstraint autoConstraint, Object... args); } diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ConstraintSymbol.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ConstraintSymbol.java new file mode 100644 index 00000000..9d7ed7ed --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/ConstraintSymbol.java @@ -0,0 +1,74 @@ +package jetbrains.mps.logic.reactor.constraint; + +/*Generated by MPS */ + + +/** + * TODO: move to the constraint model + */ +public class ConstraintSymbol { + + public static ConstraintSymbol symbol(String id, int arity) { + return new ConstraintSymbol(id, arity, false); + } + + public static ConstraintSymbol builtinSymbol(String id, int arity) { + return new ConstraintSymbol(id, arity, true); + } + + private ConstraintSymbol(String id, int arity, boolean builtin) { + this.id = id; + this.arity = arity; + this.builtin = builtin; + } + + public String id() { + return id; + } + + public int arity() { + return arity; + } + + public boolean isBuiltin() { + return builtin; + } + + @Override + public String toString() { + return id; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + + ConstraintSymbol that = (ConstraintSymbol) o; + if ((id != null ? !(id.equals(that.id)) : that.id != null)) { + return false; + } + if (arity != that.arity) { + return false; + } + + return true; + } + + @Override + public int hashCode() { + int result = 17; + result = 43 * result + ((id != null ? String.valueOf(id).hashCode() : 0)); + result = 31 * result + 37 * arity; + return result; + } + + private String id; + private int arity; + + private boolean builtin; +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/Queryable.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/Queryable.java index aab792be..53a00f58 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/Queryable.java +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/Queryable.java @@ -5,6 +5,6 @@ package jetbrains.mps.logic.reactor.constraint; public interface Queryable extends Instructible { - public boolean ask(AutoConstraint autoConstraint, Object... arg); + public boolean ask(BuiltinConstraint autoConstraint, Object... arg); } diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/StandardBuiltinConstraint.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/StandardBuiltinConstraint.java new file mode 100644 index 00000000..c4ffe626 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/StandardBuiltinConstraint.java @@ -0,0 +1,18 @@ +package jetbrains.mps.logic.reactor.constraint; + +/*Generated by MPS */ + + +public class StandardBuiltinConstraint { + + public static final ConstraintSymbol UNIFICATION = ConstraintSymbol.builtinSymbol("=", 2); + + public static final ConstraintSymbol EQUALS = ConstraintSymbol.builtinSymbol("==", 2); + + public static final ConstraintSymbol ASSERT = ConstraintSymbol.builtinSymbol("assert", 1); + + public static final ConstraintSymbol FREE = ConstraintSymbol.builtinSymbol("isVar", 1); + + public static final ConstraintSymbol BOUND = ConstraintSymbol.builtinSymbol("isNonVar", 1); + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/AbstractConstraintOccurrence.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/AbstractConstraintOccurrence.java new file mode 100644 index 00000000..f05c4a16 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/AbstractConstraintOccurrence.java @@ -0,0 +1,34 @@ +package jetbrains.mps.logic.reactor.constraint.occurrence; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.ConstraintSymbol; +import java.util.List; +import java.util.Collections; +import java.util.Arrays; + +public abstract class AbstractConstraintOccurrence { + + protected AbstractConstraintOccurrence(ConstraintSymbol symbol, Object... arg) { + this.symbol = symbol; + this.arg = arg; + } + + public ConstraintSymbol symbol() { + return symbol; + } + + public List arguments() { + return (arg != null ? Collections.unmodifiableList(Arrays.asList(arg)) : Collections.emptyList()); + } + + public abstract ConstraintKind kind(); + + @Override + public String toString() { + return getClass().getSimpleName() + " (" + symbol + ")" + "/" + arg.length; + } + + private final ConstraintSymbol symbol; + private Object[] arg; +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/BuiltinConstraintOccurrence.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/BuiltinConstraintOccurrence.java new file mode 100644 index 00000000..3234f4c3 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/BuiltinConstraintOccurrence.java @@ -0,0 +1,34 @@ +package jetbrains.mps.logic.reactor.constraint.occurrence; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.ConstraintSymbol; + +public class BuiltinConstraintOccurrence extends AbstractConstraintOccurrence { + + public static BuiltinConstraintOccurrence unitary(ConstraintSymbol symbol, Object arg) { + if (symbol.arity() != 1) { + throw new IllegalArgumentException("arity mismatch"); + } + + return new BuiltinConstraintOccurrence(symbol, arg); + } + + public static BuiltinConstraintOccurrence binary(ConstraintSymbol symbol, Object arg1, Object arg2) { + if (symbol.arity() != 2) { + throw new IllegalArgumentException("arity mismatch"); + } + + return new BuiltinConstraintOccurrence(symbol, arg1, arg2); + } + + @Override + public ConstraintKind kind() { + return ConstraintKind.BUILTIN; + } + + private BuiltinConstraintOccurrence(ConstraintSymbol symbol, Object... arg) { + super(symbol, arg); + } + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/ConstraintKind.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/ConstraintKind.java new file mode 100644 index 00000000..b5af2257 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/ConstraintKind.java @@ -0,0 +1,13 @@ +package jetbrains.mps.logic.reactor.constraint.occurrence; + +/*Generated by MPS */ + + +@Deprecated +public enum ConstraintKind { + BUILTIN(), + USER(), + LOGICAL(), + JAVA(); + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/ConstraintOccurrence.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/ConstraintOccurrence.java new file mode 100644 index 00000000..22ecc00d --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/ConstraintOccurrence.java @@ -0,0 +1,38 @@ +package jetbrains.mps.logic.reactor.constraint.occurrence; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.ConstraintSymbol; + +public class ConstraintOccurrence extends AbstractConstraintOccurrence { + + public static ConstraintOccurrence singleton(String id) { + return new ConstraintOccurrence(ConstraintSymbol.symbol(id, 0)); + } + + public static ConstraintOccurrence unitary(String id, Object arg) { + return new ConstraintOccurrence(ConstraintSymbol.symbol(id, 1), arg); + } + + public static ConstraintOccurrence binary(String id, Object arg1, Object arg2) { + return new ConstraintOccurrence(ConstraintSymbol.symbol(id, 2), arg1, arg2); + } + + public static ConstraintOccurrence ternary(String id, Object arg1, Object arg2, Object arg3) { + return new ConstraintOccurrence(ConstraintSymbol.symbol(id, 3), arg1, arg2, arg3); + } + + public static ConstraintOccurrence nary(String id, Object... args) { + return new ConstraintOccurrence(ConstraintSymbol.symbol(id, args.length), args); + } + + @Override + public ConstraintKind kind() { + return ConstraintKind.USER; + } + + private ConstraintOccurrence(ConstraintSymbol symbol, Object... args) { + super(symbol, args); + } + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/InvalidConstraintException.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/InvalidConstraintException.java new file mode 100644 index 00000000..d6888d1e --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/InvalidConstraintException.java @@ -0,0 +1,16 @@ +package jetbrains.mps.logic.reactor.constraint.occurrence; + +/*Generated by MPS */ + + +public class InvalidConstraintException extends Exception { + + public InvalidConstraintException(String message) { + super(message); + } + + public InvalidConstraintException(String message, Throwable ex) { + super(message, ex); + } + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/JavaConstraintOccurrence.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/JavaConstraintOccurrence.java new file mode 100644 index 00000000..d66d5f3f --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/JavaConstraintOccurrence.java @@ -0,0 +1,25 @@ +package jetbrains.mps.logic.reactor.constraint.occurrence; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.ConstraintSymbol; + +public class JavaConstraintOccurrence extends AbstractConstraintOccurrence { + + public static JavaConstraintOccurrence nary(String template, Object... args) { + return new JavaConstraintOccurrence(template, args); + } + + private JavaConstraintOccurrence(String template, Object... args) { + super(ConstraintSymbol.symbol(template, args.length), args); + } + + public ConstraintKind kind() { + return ConstraintKind.JAVA; + } + + public String toJavaString() { + return String.valueOf(symbol()); + } + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/LogicalConstraintOccurence.java b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/LogicalConstraintOccurence.java new file mode 100644 index 00000000..d2451385 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/LogicalConstraintOccurence.java @@ -0,0 +1,26 @@ +package jetbrains.mps.logic.reactor.constraint.occurrence; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.StandardBuiltinConstraint; +import jetbrains.mps.logic.reactor.constraint.ConstraintSymbol; + +public class LogicalConstraintOccurence extends AbstractConstraintOccurrence { + + public static LogicalConstraintOccurence bound(Object logical) { + return new LogicalConstraintOccurence(StandardBuiltinConstraint.BOUND, logical); + } + + public static LogicalConstraintOccurence free(Object logical) { + return new LogicalConstraintOccurence(StandardBuiltinConstraint.FREE, logical); + } + + private LogicalConstraintOccurence(ConstraintSymbol symbol, Object logical) { + super(symbol, logical); + } + + public ConstraintKind kind() { + return ConstraintKind.LOGICAL; + } + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/trace.info b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/trace.info new file mode 100644 index 00000000..cb96c730 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/occurrence/trace.info @@ -0,0 +1,213 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/trace.info b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/trace.info index 1a2d5b3f..df2c3046 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/constraint/trace.info +++ b/reactor/API/src/jetbrains/mps/logic/reactor/constraint/trace.info @@ -9,12 +9,13 @@ + - - + + @@ -26,6 +27,96 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -38,7 +129,7 @@ - + @@ -58,49 +149,49 @@ - - + + - + - + - + - + - + - + - + - + - + - + - + - + @@ -112,7 +203,7 @@ - + @@ -127,7 +218,7 @@ - + @@ -140,24 +231,24 @@ - + - + - + - + @@ -196,7 +287,7 @@ - + @@ -219,7 +310,7 @@ - + @@ -238,7 +329,7 @@ - + @@ -299,7 +390,7 @@ - + @@ -310,7 +401,7 @@ - + diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/rule/ConstraintRegistry.java b/reactor/API/src/jetbrains/mps/logic/reactor/rule/ConstraintRegistry.java new file mode 100644 index 00000000..26a5d746 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/rule/ConstraintRegistry.java @@ -0,0 +1,106 @@ +package jetbrains.mps.logic.reactor.rule; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.BuiltinConstraint; +import jetbrains.mps.logic.reactor.constraint.ConstraintSymbol; +import jetbrains.mps.logic.reactor.constraint.occurrence.AbstractConstraintOccurrence; +import jetbrains.mps.logic.reactor.constraint.occurrence.InvalidConstraintException; +import java.util.Arrays; +import java.util.Set; +import java.util.Collections; +import java.util.HashSet; +import java.util.Map; +import java.util.HashMap; + +public abstract class ConstraintRegistry { + + public abstract BuiltinConstraint findBuiltinConstraint(ConstraintSymbol symbol); + + public void checkValidConstraint(AbstractConstraintOccurrence cst) throws InvalidConstraintException { + switch (cst.kind()) { + case USER: + boolean matches = cst.symbol().arity() == cst.arguments().size(); + if (!(matches)) { + throw new InvalidConstraintException("arity mismatch for " + String.valueOf(cst.symbol())); + } + + if (userConstraintArgTypes.containsKey(cst.symbol())) { + if (!(Arrays.equals(argType(cst), userConstraintArgTypes.get(cst.symbol())))) { + throw new InvalidConstraintException("argument type mismatch for " + String.valueOf(cst.symbol())); + } + } + break; + + case BUILTIN: + if (cst.arguments().size() != cst.symbol().arity()) { + throw new InvalidConstraintException("arity mismatch for " + String.valueOf(cst.symbol())); + } + break; + + case JAVA: + // FIXME: implement me + break; + + default: + } + + for (Object arg : cst.arguments()) { + if (arg == null) { + throw new InvalidConstraintException("argument is null in " + String.valueOf(cst.symbol())); + } + } + } + + public Set constraintSymbols() { + return Collections.unmodifiableSet(userConstraintArgTypes.keySet()); + } + + public Set builtinConstraintSymbols() { + return Collections.unmodifiableSet(builtinSymbols); + } + + public Class[] getUserConstraintArgTypes(Object id) { + if (!(userConstraintArgTypes.containsKey(id))) { + throw new IllegalArgumentException("no such ID: " + id); + } + return userConstraintArgTypes.get(id); + } + + public void introduceConstraint(AbstractConstraintOccurrence cst) throws InvalidConstraintException { + checkValidConstraint(cst); + switch (cst.kind()) { + case USER: + userConstraintArgTypes.put(cst.symbol(), argType(cst)); + break; + + case LOGICAL: + // fall through + case BUILTIN: + builtinSymbols.add(cst.symbol()); + break; + + case JAVA: + // FIXME implement me + break; + + default: + throw new IllegalArgumentException("unknown constraint kind '" + cst.kind() + "'"); + } + } + + private Class[] argType(AbstractConstraintOccurrence cst) { + Class[] argType = new Class[cst.arguments().size()]; + int i = 0; + for (Object arg : cst.arguments()) { + if (arg != null) { + argType[i++] = arg.getClass(); + } + } + return argType; + } + + private Set builtinSymbols = new HashSet(); + + private Map[]> userConstraintArgTypes = new HashMap[]>(); +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/rule/InvalidRuleException.java b/reactor/API/src/jetbrains/mps/logic/reactor/rule/InvalidRuleException.java new file mode 100644 index 00000000..c35b2642 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/rule/InvalidRuleException.java @@ -0,0 +1,16 @@ +package jetbrains.mps.logic.reactor.rule; + +/*Generated by MPS */ + + +public class InvalidRuleException extends Exception { + + public InvalidRuleException(String message) { + super(message); + } + + public InvalidRuleException(String message, Throwable throwable) { + super(message, throwable); + } + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/rule/Rule.java b/reactor/API/src/jetbrains/mps/logic/reactor/rule/Rule.java new file mode 100644 index 00000000..33a9eda2 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/rule/Rule.java @@ -0,0 +1,31 @@ +package jetbrains.mps.logic.reactor.rule; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.occurrence.ConstraintOccurrence; +import jetbrains.mps.logic.reactor.constraint.occurrence.AbstractConstraintOccurrence; + +public abstract class Rule { + + public abstract Rule.Kind kind(); + + public abstract String tag(); + + public abstract Iterable headKept(); + + public abstract Iterable headReplaced(); + + public abstract Iterable guard(); + + public abstract Iterable body(); + + public abstract Iterable all(); + + public static enum Kind { + SIMPLIFICATION(), + PROPAGATION(), + SIMPAGATION(); + + } + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/rule/RuleBuilder.java b/reactor/API/src/jetbrains/mps/logic/reactor/rule/RuleBuilder.java new file mode 100644 index 00000000..bc4fe5d0 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/rule/RuleBuilder.java @@ -0,0 +1,156 @@ +package jetbrains.mps.logic.reactor.rule; + +/*Generated by MPS */ + +import jetbrains.mps.logic.reactor.constraint.occurrence.AbstractConstraintOccurrence; +import jetbrains.mps.logic.reactor.constraint.occurrence.ConstraintOccurrence; +import java.util.Collections; +import com.google.common.collect.Iterables; +import java.util.List; +import java.util.ArrayList; + +public class RuleBuilder { + + public RuleBuilder(String tag) { + this.tag = tag; + } + + public RuleBuilder appendBody(AbstractConstraintOccurrence... c) { + for (int i = 0; i < c.length; i++) { + body.add(c[i]); + } + return this; + } + + public RuleBuilder appendGuard(AbstractConstraintOccurrence... c) { + for (int i = 0; i < c.length; i++) { + guard.add(c[i]); + } + return this; + } + + public RuleBuilder appendHeadReplaced(ConstraintOccurrence... uc) { + for (int i = 0; i < uc.length; i++) { + headReplaced.add(uc[i]); + } + return this; + } + + public RuleBuilder appendHeadKept(ConstraintOccurrence... uc) { + for (int i = 0; i < uc.length; i++) { + headKept.add(uc[i]); + } + return this; + } + + public boolean hasHead() { + return !((headKept.isEmpty() && headReplaced.isEmpty())); + } + + public boolean hasGuard() { + return !(guard.isEmpty()); + } + + public boolean hasBody() { + return !(body.isEmpty()); + } + + public RuleBuilder merge(RuleBuilder... other) { + doMerge(other); + return this; + } + + public jetbrains.mps.logic.reactor.rule.Rule toRule() throws InvalidRuleException { + jetbrains.mps.logic.reactor.rule.Rule.Kind kind; + if (!(headKept.isEmpty()) && !(headReplaced.isEmpty())) { + kind = jetbrains.mps.logic.reactor.rule.Rule.Kind.SIMPAGATION; + + } else if (!(headReplaced.isEmpty())) { + kind = jetbrains.mps.logic.reactor.rule.Rule.Kind.SIMPLIFICATION; + + } else if (!(headKept.isEmpty())) { + kind = jetbrains.mps.logic.reactor.rule.Rule.Kind.PROPAGATION; + + } else { + throw new InvalidRuleException("Invalid rule: empty head in " + toString()); + } + + if (body.isEmpty()) { + throw new InvalidRuleException("Invalid rule: empty body in " + toString()); + } + + headKept = Collections.unmodifiableList(headKept); + headReplaced = Collections.unmodifiableList(headReplaced); + guard = Collections.unmodifiableList(guard); + body = Collections.unmodifiableList(body); + + return new RuleBuilder.Rule(kind, tag); + } + + @Override + public String toString() { + return String.format("%s (%d,%d,%d,%d)", tag, headKept.size(), headReplaced.size(), guard.size(), body.size()); + } + + private void doMerge(RuleBuilder... other) { + for (int i = 0; i < other.length; i++) { + RuleBuilder toMerge = other[i]; + + headReplaced.addAll(toMerge.headReplaced); + headKept.addAll(toMerge.headKept); + guard.addAll(toMerge.guard); + body.addAll(toMerge.body); + } + } + + public class Rule extends jetbrains.mps.logic.reactor.rule.Rule { + + private Rule(jetbrains.mps.logic.reactor.rule.Rule.Kind kind, String tag) { + this.kind = kind; + this.tag = tag; + } + + public jetbrains.mps.logic.reactor.rule.Rule.Kind kind() { + return kind; + } + + @Override + public String tag() { + return tag; + } + + @Override + public Iterable headKept() { + return headKept; + } + + @Override + public Iterable headReplaced() { + return headReplaced; + } + + @Override + public Iterable guard() { + return guard; + } + + @Override + public Iterable body() { + return body; + } + + @Override + public Iterable all() { + return Iterables.concat(headKept, headReplaced, guard, body); + } + + private jetbrains.mps.logic.reactor.rule.Rule.Kind kind; + private String tag; + } + + private String tag; + private List headKept = new ArrayList(4); + private List headReplaced = new ArrayList(4); + private List guard = new ArrayList(4); + private List body = new ArrayList(4); +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/rule/trace.info b/reactor/API/src/jetbrains/mps/logic/reactor/rule/trace.info new file mode 100644 index 00000000..4f634ec4 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/rule/trace.info @@ -0,0 +1,343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/reactor/Bridge/Bridge.iml b/reactor/Bridge/Bridge.iml new file mode 100644 index 00000000..245d3429 --- /dev/null +++ b/reactor/Bridge/Bridge.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/reactor/Bridge/src/jetbrains/mps/logic/reactor/handler/RuleHandler.java b/reactor/Bridge/src/jetbrains/mps/logic/reactor/handler/RuleHandler.java new file mode 100644 index 00000000..c6f29500 --- /dev/null +++ b/reactor/Bridge/src/jetbrains/mps/logic/reactor/handler/RuleHandler.java @@ -0,0 +1,28 @@ +package jetbrains.mps.logic.reactor.handler; + +/** + * @author Fedor Isakov + */ +public class RuleHandler { + + public static Factory with() { + return ourCompanion.createFactory(); + } + + public interface Factory { + RuleHandler newHandler(); + } + + + + + /** + * SPI + */ + protected interface Companion { + Factory createFactory(); + } + + protected static Companion ourCompanion; +} + diff --git a/reactor/Core/Core.iml b/reactor/Core/Core.iml new file mode 100644 index 00000000..9901096f --- /dev/null +++ b/reactor/Core/Core.iml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/reactor/Core/src/jetbrains/mps/logicl/reactor/core/RuleHandler.kt b/reactor/Core/src/jetbrains/mps/logicl/reactor/core/RuleHandler.kt new file mode 100644 index 00000000..af84b865 --- /dev/null +++ b/reactor/Core/src/jetbrains/mps/logicl/reactor/core/RuleHandler.kt @@ -0,0 +1,23 @@ +package jetbrains.mps.logicl.reactor.core + +/** + * @author Fedor Isakov + */ + +import jetbrains.mps.logic.reactor.handler.RuleHandler + +class FactoryImpl : RuleHandler.Factory { + override fun newHandler(): RuleHandler = HandlerImpl() +} + +class HandlerImpl : RuleHandler() { + + fun init() { + ourCompanion = object : Companion { + override fun createFactory(): Factory = FactoryImpl() + } + } + + + +} \ No newline at end of file