natas_hw
/
mps-coderules
mirror of https://github.com/JetBrains/mps-coderules
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactoring the reactor API. Extract StoreView, get rid of obsolete calls to SessionSolver. Cleaning up the code.

This commit is contained in:
Fedor Isakov 2017-01-04 10:47:23 +01:00
parent 0771504044
commit ebfe680aae
8 changed files with 28 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
reactor/API/src/jetbrains/mps/logic/reactor/evaluation/EvaluationSession.java
View File

@ -39,23 +39,12 @@ public abstract class EvaluationSession {
public abstract SessionSolver sessionSolver();
public abstract Instructible sessionInstructible();
public abstract Queryable sessionQueryable();
public abstract StoreView storeView();
@Deprecated
public Iterable<ConstraintSymbol> constraintSymbols() {
throw new UnsupportedOperationException();
}
@Deprecated
public Iterable<ConstraintOccurrence> constraintOccurrences() {
throw new UnsupportedOperationException();
}
@Deprecated
public Iterable<ConstraintOccurrence> constraintOccurrences(ConstraintSymbol symbol) {
throw new UnsupportedOperationException();
}
protected static void setBackend(EvaluationSession.Backend backend) {
if (ourBackend != null) {
throw new IllegalStateException("backend already assigned");

16
reactor/API/src/jetbrains/mps/logic/reactor/evaluation/SessionSolver.java
View File

@ -59,20 +59,7 @@ public abstract class SessionSolver implements Instructible, Queryable {
solver.tell(invocation);
}
public abstract boolean queueIfBusy(Runnable runnable);
public abstract void fail(String message);
public Queryable lookupQueryable(Class<?> clazz) {
for (Map.Entry<PredicateSymbol, Solver> e : solvers.entrySet()) {
Queryable queryable = e.getValue();
if (clazz.isAssignableFrom(queryable.getClass())) {
return queryable;
}
}
return null;
}
@Deprecated
public abstract Class<? extends Queryable> solverClass(PredicateSymbol predicateSymbol);
protected abstract void registerSymbol(PredicateSymbol predicateSymbol, EvaluationTrace computingTracer);
@ -119,4 +106,5 @@ public abstract class SessionSolver implements Instructible, Queryable {
private Map<PredicateSymbol, Solver> solvers = new HashMap<PredicateSymbol, Solver>();
private EvaluationTrace tracer = EvaluationTrace.NULL;
}

4
reactor/Core/src/jetbrains/mps/logic/reactor/core/Controller.kt
View File

@ -286,7 +286,7 @@ class Controller {
profiler.profile<Boolean>("ask_${invocation.predicate().symbol()}", {
// TODO: provide SessionSolver as part of evaluation session
val result = EvaluationSession.current().sessionSolver().ask(invocation)
val result = EvaluationSession.current().sessionQueryable().ask(invocation)
// trace.ask(result, invocation)
return result
@ -297,7 +297,7 @@ class Controller {
// TODO: provide SessionSolver as part of evaluation session
// trace.tell(invocation)
EvaluationSession.current().sessionSolver().tell(invocation)
EvaluationSession.current().sessionInstructible().tell(invocation)
}
}

13
reactor/Core/src/jetbrains/mps/logic/reactor/core/MemEvaluationSession.kt
View File

@ -97,18 +97,13 @@ class MemEvaluationSession : EvaluationSession, SessionObjects {
override fun sessionSolver(): SessionSolver = sessionSolver
override fun sessionInstructible(): Instructible = sessionSolver
override fun sessionQueryable(): Queryable = sessionSolver
override fun storeView(): StoreView =
controller.storeView()
override fun constraintSymbols(): Iterable<ConstraintSymbol> =
storeView().constraintSymbols()
override fun constraintOccurrences(): Iterable<ConstraintOccurrence> =
storeView().allOccurrences()
override fun constraintOccurrences(symbol: ConstraintSymbol): Iterable<ConstraintOccurrence> =
storeView().occurrences(symbol)
private class Backend : EvaluationSession.Backend {
val ourSession = ThreadLocal<MemEvaluationSession>()

1
reactor/Test/src/solver/EqualsSolver.kt
View File

@ -100,7 +100,6 @@ class EqualsSolver : Solver {
if (!condition) throw EvaluationFailureException("condition is not satisfied")
}
private fun ERROR(msg: String) : Nothing = throw IllegalArgumentException(msg)
}
infix fun <T : Any> Logical<T>.eq(value: T) {

8
reactor/Test/src/solver/MockSessionSolver.kt
View File

@ -1,9 +1,6 @@
package solver
import jetbrains.mps.logic.reactor.evaluation.EvaluationTrace
import jetbrains.mps.logic.reactor.evaluation.Queryable
import jetbrains.mps.logic.reactor.evaluation.SessionSolver
import jetbrains.mps.logic.reactor.evaluation.Solver
import jetbrains.mps.logic.reactor.evaluation.*
import jetbrains.mps.logic.reactor.program.JavaPredicateSymbol
import jetbrains.mps.logic.reactor.program.PredicateSymbol
@ -29,7 +26,4 @@ open class MockSessionSolver(val expressionSolver: Solver, val equalsSolver: Sol
}
}
override fun queueIfBusy(runnable: Runnable): Boolean = false
override fun fail(message: String) = throw IllegalStateException (message)
}

5
reactor/Test/test/TestController.kt
View File

@ -27,10 +27,9 @@ class TestController {
lateinit var controller: Controller
override fun handler(): Controller = controller
override fun sessionSolver(): SessionSolver = solver
override fun sessionInstructible(): Instructible = solver
override fun sessionQueryable(): Queryable = solver
override fun storeView(): StoreView = TODO()
override fun constraintSymbols(): MutableIterable<ConstraintSymbol> = TODO()
override fun constraintOccurrences(): MutableIterable<ConstraintOccurrence> = TODO()
override fun constraintOccurrences(symbol: ConstraintSymbol?): MutableIterable<ConstraintOccurrence> = TODO()
class MockBackend(val session: MockSession) : Backend {
override fun current(): EvaluationSession = session

24
reactor/Test/test/TestProgram.kt
View File

@ -1,5 +1,6 @@
import jetbrains.mps.logic.reactor.core.MemEvaluationSession
import jetbrains.mps.logic.reactor.evaluation.EvaluationSession
import jetbrains.mps.logic.reactor.evaluation.StoreView
import jetbrains.mps.logic.reactor.logical.Logical
import solver.MockSessionSolver
import jetbrains.mps.logic.reactor.program.ConstraintSymbol
@ -25,15 +26,16 @@ class TestProgram {
}
}
private fun Builder.session(name: String): EvaluationSession {
private fun Builder.session(name: String): StoreView {
val sessionSolver = MockSessionSolver(env.expressionSolver, env.equalsSolver)
val programBuilder = ProgramBuilder(ConstraintRegistry(sessionSolver))
for (h in handlers) {
programBuilder.addHandler(h)
}
return EvaluationSession.newSession(programBuilder.program(name)).
val session = EvaluationSession.newSession(programBuilder.program(name)).
withPredicates(PredicateSymbol("equals", 2), JavaPredicateSymbol.EXPRESSION0, JavaPredicateSymbol.EXPRESSION1, JavaPredicateSymbol.EXPRESSION2, JavaPredicateSymbol.EXPRESSION3).
withParam("main", MockConstraint(ConstraintSymbol("main", 0))).start(sessionSolver)
return session.storeView()
}
@Test
@ -83,8 +85,8 @@ class TestProgram {
)
).session("logicalValue").run {
assertEquals(setOf(ConstraintSymbol("foo", 1), ConstraintSymbol("bar", 1)), constraintSymbols())
assertEquals(2, constraintOccurrences().count())
val yval = constraintOccurrences(ConstraintSymbol("bar", 1)).first().arguments().first()
assertEquals(2, allOccurrences().count())
val yval = occurrences(ConstraintSymbol("bar", 1)).first().arguments().first()
assertEquals(66, (yval as Logical<Int>).get())
}
}
@ -106,10 +108,10 @@ class TestProgram {
)
).session("dec").run {
assertEquals(setOf(ConstraintSymbol("val", 1), ConstraintSymbol("trail", 1)), constraintSymbols())
assertEquals(1, constraintOccurrences(ConstraintSymbol.symbol("val", 1)).count())
val a = constraintOccurrences(ConstraintSymbol.symbol("val", 1)).first().arguments().first()
assertEquals(1, occurrences(ConstraintSymbol.symbol("val", 1)).count())
val a = occurrences(ConstraintSymbol.symbol("val", 1)).first().arguments().first()
assertEquals(0, (a as Logical<Int>).get())
assertEquals(5, constraintOccurrences(ConstraintSymbol.symbol("trail", 1)).count())
assertEquals(5, occurrences(ConstraintSymbol.symbol("trail", 1)).count())
}
}
@ -135,8 +137,8 @@ class TestProgram {
)
)
).session("gcd").run {
assertEquals(1, constraintOccurrences().count())
val arg = constraintOccurrences().first().arguments().first()
assertEquals(1, allOccurrences().count())
val arg = allOccurrences().first().arguments().first()
assertEquals(7, (arg as Logical<Int>).get())
}
}
@ -162,8 +164,8 @@ class TestProgram {
body( statement { } /* nothing */ )
)
).session("primes").run {
assertEquals(4, constraintOccurrences().count())
assertEquals(setOf(2,3,5,7), constraintOccurrences(ConstraintSymbol.symbol("prime", 1)).
assertEquals(4, allOccurrences().count())
assertEquals(setOf(2,3,5,7), occurrences(ConstraintSymbol.symbol("prime", 1)).
flatMap { co -> co.arguments() }.
map { a -> (a as Logical<Int>).findRoot().value() }.
toSet())