diff --git a/coderules/solutions/jetbrains.mps.coderules.ui/models/plugin.mps b/coderules/solutions/jetbrains.mps.coderules.ui/models/plugin.mps index d938ed65..e8120e86 100644 --- a/coderules/solutions/jetbrains.mps.coderules.ui/models/plugin.mps +++ b/coderules/solutions/jetbrains.mps.coderules.ui/models/plugin.mps @@ -9245,7 +9245,7 @@ - + @@ -9414,7 +9414,7 @@ - + diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleMatchEx.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleMatchEx.kt index b95987ac..021992ee 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleMatchEx.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleMatchEx.kt @@ -17,7 +17,7 @@ package jetbrains.mps.logic.reactor.core import jetbrains.mps.logic.reactor.evaluation.RuleMatch -import jetbrains.mps.logic.reactor.util.IdWrapper +import jetbrains.mps.logic.reactor.util.Id /** @@ -27,8 +27,8 @@ import jetbrains.mps.logic.reactor.util.IdWrapper interface RuleMatchEx : RuleMatch { /** - * Returns an array of matched constraint occurrences wrapped in [IdWrapper]. + * Returns an array of matched constraint occurrences wrapped in [Id]. */ - fun signature(): ArrayList?> + fun signature(): ArrayList?> } \ No newline at end of file diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/ControllerImpl.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/ControllerImpl.kt index 46b34b3c..edefb90c 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/ControllerImpl.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/ControllerImpl.kt @@ -17,7 +17,7 @@ package jetbrains.mps.logic.reactor.core.internal import jetbrains.mps.logic.reactor.core.* -import jetbrains.mps.logic.reactor.core.internal.ProcessingState.* +import jetbrains.mps.logic.reactor.core.internal.FeedbackStatus.* import jetbrains.mps.logic.reactor.evaluation.* import jetbrains.mps.logic.reactor.logical.Logical import jetbrains.mps.logic.reactor.logical.LogicalContext @@ -52,33 +52,33 @@ internal class ControllerImpl ( override fun evaluate(occ: Occurrence): StoreView { // create the internal occurrence val active = occ.constraint().occurrence(occ.arguments(), { frameStack.current }) - val state = process(active, NORMAL()) - if (state is FAILED) { - throw state.failure.failureCause() + val status = process(active, NORMAL()) + if (status is FAILED) { + throw status.failure.failureCause() } return storeView() } - fun activate(constraint: Constraint) : ProcessingState { + fun activate(constraint: Constraint) : FeedbackStatus { // FIXME noLogicalContext val context = Context(NORMAL(), noLogicalContext) activateConstraint(constraint, context) - return context.currentState() + return context.currentStatus() } override fun reactivate(occ: Occurrence) { - // FIXME propagate the processing state further up the call stack - // TODO: introduce processing state to solver API? - val state = process(occ, NORMAL()) - if (state is FAILED) { - throw state.failure.failureCause() + // FIXME propagate the status further up the call stack + // TODO: introduce status to solver API? + val status = process(occ, NORMAL()) + if (status is FAILED) { + throw status.failure.failureCause() } } - private fun process(active: Occurrence, inState: ProcessingState) : ProcessingState { + private fun process(active: Occurrence, inStatus: FeedbackStatus) : FeedbackStatus { assert(active.alive) - return profiler.profile("process_${active.constraint().symbol()}") { + return profiler.profile("process_${active.constraint().symbol()}") { if (!active.stored) { frameStack.current.store.store(active) @@ -90,13 +90,13 @@ internal class ControllerImpl ( val activatedFront = dispatchFront.expand(active) this.dispatchFront = activatedFront - val outState = activatedFront.matches().toList().fold(inState) { state, match -> + val outStatus = activatedFront.matches().toList().fold(inStatus) { status, match -> // TODO: paranoid check. should be isAlive() instead // FIXME: move this check elsewhere - if (state.operational && active.stored && match.allStored()) - processMatch(state, match as RuleMatchImpl) + if (status.operational && active.stored && match.allStored()) + processMatch(status, match as RuleMatchImpl) else - state + status } // TODO: should be isAlive() @@ -104,12 +104,12 @@ internal class ControllerImpl ( trace.suspend(active) } - outState + outStatus } } - private fun processMatch(inState: ProcessingState, match: RuleMatchImpl) : ProcessingState { - val context = Context(inState, match.logicalContext()) + private fun processMatch(inStatus: FeedbackStatus, match: RuleMatchImpl) : FeedbackStatus { + val context = Context(inStatus, match.logicalContext()) // invoke matched pattern predicates for (prd in match.patternPredicates()) { @@ -123,19 +123,19 @@ internal class ControllerImpl ( if (!askPredicate(gprd, context)) break } - context.updateState { state -> - when (state) { + context.updateStatus { status -> + when (status) { is ABORTED -> { // guard is not satisfied trace.reject(match) - return state.recover() + return status.recover() } is FAILED -> { // guard failed - trace.feedback(state.failure) - return state.recover() + trace.feedback(status.failure) + return status.recover() } - else -> state + else -> status } } @@ -152,13 +152,13 @@ internal class ControllerImpl ( while (altIt.hasNext()) { val body = altIt.next() - context.updateState { state -> - if (state is FAILED) { + context.updateStatus { status -> + if (status is FAILED) { trace.retry(match) - state.recover() + status.recover() } else { - state + status } } @@ -173,37 +173,37 @@ internal class ControllerImpl ( } if (itemOk) { - context.withState { state -> - if (state.feedback?.alreadyHandled() == false) { - state.feedback.handle(match.rule(), supervisor) + context.withStatus { status -> + if (status.feedback?.alreadyHandled() == false) { + status.feedback.handle(match.rule(), supervisor) } } } else { - // state is not operational after constraint/predicate processing + // status is not operational after constraint/predicate processing break } } - val altOk = context.updateState { state -> - if (state is FAILED) { - trace.feedback(state.failure) + val altOk = context.updateStatus { status -> + if (status is FAILED) { + trace.feedback(status.failure) if (altIt.hasNext()) { // clear the failure handled status // the supervisor is NOT notified here - state.failure.handle(match.rule()) - state + status.failure.handle(match.rule()) + status - } else if (state.feedback?.alreadyHandled() == false && state.failure.handle(match.rule(), supervisor)) { - state.recover() + } else if (status.feedback?.alreadyHandled() == false && status.failure.handle(match.rule(), supervisor)) { + status.recover() } else { - state + status } } else { - state + status } } @@ -219,26 +219,26 @@ internal class ControllerImpl ( trace.finish(match) - return context.currentState() + return context.currentStatus() } private fun activateConstraint(constraint: Constraint, context: Context) : Boolean { val args = supervisor.instantiateArguments(constraint.arguments(), context.logicalContext, context) - return context.updateState { state -> + return context.updateStatus { status -> val active = constraint.occurrence(args, { frameStack.current }, context.logicalContext) - process(active, state) + process(active, status) } } private fun askPredicate(predicate: Predicate, context: Context) : Boolean = profiler.profile("ask_${predicate.symbol()}") { - context.evalSafe { state -> + context.evalSafe { status -> val args = supervisor.instantiateArguments(predicate.arguments(), context.logicalContext, context) if (session.ask(predicate.invocation(args, context.logicalContext, context))) - state + status else - state.abort(DetailedFeedback("predicate not satisfied")) + status.abort(DetailedFeedback("predicate not satisfied")) } } @@ -266,52 +266,52 @@ internal class ControllerImpl ( } -private class Context(inState: ProcessingState, +private class Context(inStatus: FeedbackStatus, val logicalContext: LogicalContext) : InvocationContext { - private var state = inState - fun currentState(): ProcessingState = state + private var status = inStatus + fun currentStatus(): FeedbackStatus = status override fun report(feedback: EvaluationFeedback) { when (feedback) { - is EvaluationFailure -> this.state = state.fail(feedback) - is DetailedFeedback -> this.state = state.report(feedback) + is EvaluationFailure -> this.status = status.fail(feedback) + is DetailedFeedback -> this.status = status.report(feedback) } } - inline fun withState(block: (ProcessingState) -> Unit) { - block.invoke(state) + inline fun withStatus(block: (FeedbackStatus) -> Unit) { + block.invoke(status) } - inline fun updateState(block: (ProcessingState) -> ProcessingState) : Boolean { - this.state = block.invoke(state) - return state.operational + inline fun updateStatus(block: (FeedbackStatus) -> FeedbackStatus) : Boolean { + this.status = block.invoke(status) + return status.operational } - inline fun evalSafe(block: (ProcessingState) -> ProcessingState) : Boolean { - if (state.operational) { + inline fun evalSafe(block: (FeedbackStatus) -> FeedbackStatus) : Boolean { + if (status.operational) { try { - this.state = block.invoke(state) + this.status = block.invoke(status) } catch (ex: EvaluationFailureException) { - this.state = state.fail(EvaluationFailure(ex)) + this.status = status.fail(EvaluationFailure(ex)) } } - return state.operational + return status.operational } inline fun runSafe(block: () -> Unit) : Boolean { - if (state.operational) { + if (status.operational) { try { block() } catch (ex: EvaluationFailureException) { - this.state = state.fail(EvaluationFailure(ex)) + this.status = status.fail(EvaluationFailure(ex)) } } - return state.operational + return status.operational } } diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/EvaluationSessionImpl.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/EvaluationSessionImpl.kt index 654e6d51..8774d032 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/EvaluationSessionImpl.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/EvaluationSessionImpl.kt @@ -16,13 +16,11 @@ package jetbrains.mps.logic.reactor.core.internal -import jetbrains.mps.logic.reactor.core.EvaluationFailure -import jetbrains.mps.logic.reactor.core.internal.ProcessingState.FAILED +import jetbrains.mps.logic.reactor.core.internal.FeedbackStatus.FAILED import jetbrains.mps.logic.reactor.core.EvaluationSessionEx import jetbrains.mps.logic.reactor.core.Feedback import jetbrains.mps.logic.reactor.core.RuleIndex import jetbrains.mps.logic.reactor.evaluation.* -import jetbrains.mps.logic.reactor.logical.LogicalContext import jetbrains.mps.logic.reactor.program.Constraint import jetbrains.mps.logic.reactor.program.Program import jetbrains.mps.logic.reactor.util.Profiler @@ -45,7 +43,7 @@ internal class EvaluationSessionImpl private constructor ( override fun controller() = controller - private fun launch(main: Constraint, profiler: Profiler?, storeView: StoreView?) : ProcessingState { + private fun launch(main: Constraint, profiler: Profiler?, storeView: StoreView?) : FeedbackStatus { this.controller = ControllerImpl(supervisor, RuleIndex(program().handlers()), trace, profiler, storeView) return controller.activate(main) } @@ -87,9 +85,9 @@ internal class EvaluationSessionImpl private constructor ( var failure: Feedback? = null try { val main = parameters[ParameterKey.of("main", Constraint::class.java)] as Constraint - val state = session.launch(main, profiler, storeView) - if (state is FAILED) { - failure = state.failure + val status = session.launch(main, profiler, storeView) + if (status is FAILED) { + failure = status.failure } } finally { diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/ProcessingState.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/FeedbackStatus.kt similarity index 53% rename from reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/ProcessingState.kt rename to reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/FeedbackStatus.kt index d393a2a4..7d989938 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/ProcessingState.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/FeedbackStatus.kt @@ -18,44 +18,51 @@ package jetbrains.mps.logic.reactor.core.internal import jetbrains.mps.logic.reactor.core.Feedback import jetbrains.mps.logic.reactor.core.CompositeFeedback -import jetbrains.mps.logic.reactor.core.EvaluationFailure -import jetbrains.mps.logic.reactor.evaluation.EvaluationFeedback -abstract class ProcessingState(val feedback : Feedback?) { +/** + * Corresponds to the status given by the most recent constraint activation or predicate evaluation. + * + * A disjoint union of types: + * NORMAL - the feedback is neutral or there is no feedback + * FAILED - the feedback is a failure + * ABORTED - the feedback is negative, but not a failure + * + */ +abstract class FeedbackStatus(val feedback : Feedback?) { abstract val operational : Boolean -// inline fun eval(block: (ProcessingState) -> ProcessingState): ProcessingState = +// inline fun eval(block: (FeedbackStatus) -> FeedbackStatus): FeedbackStatus = // if (operational) block(this) else this /** Stop what is being done because a required condition is not satisfied. */ - open fun abort(details: Feedback) : ProcessingState = throw IllegalStateException() + open fun abort(details: Feedback) : FeedbackStatus = throw IllegalStateException() /** Failure occurred during processing. */ - open fun fail(failure: Feedback) : ProcessingState = throw IllegalStateException() + open fun fail(failure: Feedback) : FeedbackStatus = throw IllegalStateException() /** Provide detailed feedback. */ - open fun report(details: Feedback) : ProcessingState = throw IllegalStateException() + open fun report(details: Feedback) : FeedbackStatus = throw IllegalStateException() /** Move back to normal. */ - open fun recover() : ProcessingState = throw IllegalStateException() + open fun recover() : FeedbackStatus = throw IllegalStateException() - class NORMAL(feedback: Feedback? = null) : ProcessingState(feedback) { + class NORMAL(feedback: Feedback? = null) : FeedbackStatus(feedback) { override val operational = true - override fun abort(details: Feedback): ProcessingState = ABORTED(this, details) - override fun fail(failure: Feedback): ProcessingState = FAILED(this, failure) - override fun report(details: Feedback): ProcessingState = NORMAL(compose(this.feedback, details)) + override fun abort(details: Feedback): FeedbackStatus = ABORTED(this, details) + override fun fail(failure: Feedback): FeedbackStatus = FAILED(this, failure) + override fun report(details: Feedback): FeedbackStatus = NORMAL(compose(this.feedback, details)) } - class FAILED(state: ProcessingState, val failure: Feedback) : ProcessingState(compose(state.feedback, failure)) { + class FAILED(status: FeedbackStatus, val failure: Feedback) : FeedbackStatus(compose(status.feedback, failure)) { override val operational = false - /** Recover after a failure or a cancellation, bring the state back to operational. */ - override fun recover(): ProcessingState = NORMAL(feedback) + /** Recover after a failure or a cancellation, bring the status back to operational. */ + override fun recover(): FeedbackStatus = NORMAL(feedback) } - class ABORTED(state: ProcessingState, val reason: Feedback) : ProcessingState(compose(state.feedback, reason)) { + class ABORTED(status: FeedbackStatus, val reason: Feedback) : FeedbackStatus(compose(status.feedback, reason)) { override val operational = false - override fun recover(): ProcessingState = NORMAL(feedback) + override fun recover(): FeedbackStatus = NORMAL(feedback) } } diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Frame.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Frame.kt index 8e9c2fee..5fcc67fe 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Frame.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Frame.kt @@ -24,7 +24,7 @@ import jetbrains.mps.logic.reactor.core.LogicalObserver import jetbrains.mps.logic.reactor.core.addObserver import jetbrains.mps.logic.reactor.evaluation.StoreView import jetbrains.mps.logic.reactor.logical.Logical -import jetbrains.mps.logic.reactor.util.IdWrapper +import jetbrains.mps.logic.reactor.util.Id import jetbrains.mps.logic.reactor.util.cons import jetbrains.mps.logic.reactor.util.remove import java.util.* @@ -35,7 +35,7 @@ internal class Frame: LogicalObserver, FrameObservable { val store: Store - private var observers: Map>, ConsList<(FrameObservable) -> LogicalObserver>> + private var observers: Map>, ConsList<(FrameObservable) -> LogicalObserver>> constructor(stack: FrameStack) { this.stack = stack @@ -58,7 +58,7 @@ internal class Frame: LogicalObserver, FrameObservable { override fun storeObserver() = store override fun addObserver(logical: Logical<*>, obs: (FrameObservable) -> LogicalObserver) { - val logicalId = IdWrapper(logical) + val logicalId = Id(logical) if (!observers.containsKey(logicalId)) { stack.addObserver(logical) } @@ -67,7 +67,7 @@ internal class Frame: LogicalObserver, FrameObservable { } override fun removeObserver(logical: Logical<*>, obs: (FrameObservable) -> LogicalObserver) { - val logicalId = IdWrapper(logical) + val logicalId = Id(logical) observers[logicalId].remove(obs)?.let { newList -> this.observers = observers.put(logicalId, newList) if (newList.isEmpty) { @@ -77,7 +77,7 @@ internal class Frame: LogicalObserver, FrameObservable { } override fun valueUpdated(logical: Logical<*>) { - observers[IdWrapper(logical)]?.let { list -> + observers[Id(logical)]?.let { list -> for (obs in list) { obs(this).valueUpdated(logical) } @@ -85,7 +85,7 @@ internal class Frame: LogicalObserver, FrameObservable { } override fun parentUpdated(logical: Logical<*>) { - observers[IdWrapper(logical)]?.let { list -> + observers[Id(logical)]?.let { list -> for (obs in list) { obs(this).parentUpdated(logical) } @@ -98,7 +98,7 @@ internal class FrameStack(storeView: StoreView?) : LogicalObserver { var current: Frame - val observing = HashSet>>() + val observing = HashSet>>() init { this.current = if (storeView != null) Frame(this, storeView) else Frame(this) @@ -115,7 +115,7 @@ internal class FrameStack(storeView: StoreView?) : LogicalObserver { } fun addObserver(logical: Logical<*>) { - val token = IdWrapper(logical) + val token = Id(logical) if (!observing.contains(token)) { logical.addObserver(this) observing.add(token) diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatchImpl.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatchImpl.kt index 168908ec..03f83280 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatchImpl.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatchImpl.kt @@ -25,7 +25,7 @@ import jetbrains.mps.logic.reactor.logical.LogicalContext import jetbrains.mps.logic.reactor.logical.LogicalOwner import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.program.Rule -import jetbrains.mps.logic.reactor.util.IdWrapper +import jetbrains.mps.logic.reactor.util.Id internal class RuleMatchImpl(private val rule: Rule, private val subst: Subst, @@ -51,8 +51,8 @@ internal class RuleMatchImpl(private val rule: Rule, inline fun forEachReplaced(action: (Occurrence) -> Unit) = headReplaced.forEach(action) - override fun signature(): ArrayList?> = - ArrayList((headKept + headReplaced).map { IdWrapper(it) }) + override fun signature(): ArrayList?> = + ArrayList((headKept + headReplaced).map { Id(it) }) override fun rule(): Rule = rule diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatcherImpl.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatcherImpl.kt index f64567b4..46b021f9 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatcherImpl.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/RuleMatcherImpl.kt @@ -49,9 +49,9 @@ internal class RuleMatcherImpl(private val ruleLookup: RuleLookup, 0) inner class RuleMatchFront(private val nodes: List, - private val seenOccurrences: PersSet>, - private val consumedSignatures: PersSet?>>, - private val genId: Int) : RuleMatchingProbe + private val seenOccurrences: PersSet>, + private val consumedSignatures: PersSet?>>, + private val genId: Int) : RuleMatchingProbe { override fun rule(): Rule = lookupRule() @@ -74,8 +74,8 @@ internal class RuleMatcherImpl(private val ruleLookup: RuleLookup, * Mask specifies possible slots for the occurrence. */ override fun expand(occ: Occurrence, mask: BitSet): RuleMatchFront { - val reactivated = seenOccurrences.contains(IdWrapper(occ)) - val newSeen = if (reactivated) seenOccurrences else seenOccurrences.add(IdWrapper(occ)) + val reactivated = seenOccurrences.contains(Id(occ)) + val newSeen = if (reactivated) seenOccurrences else seenOccurrences.add(Id(occ)) val newNodes = ArrayList(nodes) val allSignatures = newNodes.map { it.signature }.toHashSet() @@ -99,7 +99,7 @@ internal class RuleMatcherImpl(private val ruleLookup: RuleLookup, open inner class MatchNode(val subst: Subst, val vacant: BitSet = bitSetOfOnes(head.size)) { // a signature is a (partial) set of constraint occurrences that belong to this node - open val signature: ArrayList?> = arrayListOf(* arrayOfNulls(head.size)) + open val signature: ArrayList?> = arrayListOf(* arrayOfNulls(head.size)) /** * Returns the additional nodes built from this node on adding the occurrence. @@ -162,8 +162,8 @@ internal class RuleMatcherImpl(private val ruleLookup: RuleLookup, MatchNode(subst, parent.vacant.clearBit(headIndex)) { val complete = vacant.cardinality() == 0 - override val signature: ArrayList?> = - ArrayList(parent.signature).also { it[headIndex] = IdWrapper(occurrence) } + override val signature: ArrayList?> = + ArrayList(parent.signature).also { it[headIndex] = Id(occurrence) } fun constraint(): Constraint = head[headIndex] diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Store.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Store.kt index 40304246..756e5fa6 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Store.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/internal/Store.kt @@ -46,7 +46,7 @@ internal class Store : LogicalObserver { var symbol2occurrences: PersMap> - var logical2occurrences: PersMap>, IdHashSet> + var logical2occurrences: PersMap>, IdHashSet> constructor(copyFrom: Store, currentFrame: () -> FrameObservable) { this.currentFrame = currentFrame @@ -62,7 +62,7 @@ internal class Store : LogicalObserver { constructor(copyFrom: StoreView, currentFrame: () -> FrameObservable) { this.currentFrame = currentFrame - var log2occs = Maps.of>, IdHashSet>() + var log2occs = Maps.of>, IdHashSet>() val orig2occ = IdentityHashMap() // process the original data and make copies as needed @@ -72,7 +72,7 @@ internal class Store : LogicalObserver { for (arg in orig.arguments()) { when (arg) { is Logical<*> -> { - val key = IdWrapper(arg.findRoot()) + val key = Id(arg.findRoot()) log2occs = log2occs.put(key, log2occs[key]?.add(occ) ?: singletonIdSet(occ)) currentFrame().addObserver(arg) { frame -> frame.storeObserver() } @@ -101,9 +101,9 @@ internal class Store : LogicalObserver { override fun parentUpdated(logical: Logical<*>) { // TODO: should we care about the order in which occurrences are stored? - val logicalId = IdWrapper(logical) + val logicalId = Id(logical) logical2occurrences[logicalId]?.let { toMerge -> - val rootId = IdWrapper(logical.findRoot()) + val rootId = Id(logical.findRoot()) var newSet = logical2occurrences[rootId] ?: emptyIdSet() for (log in toMerge) { newSet = newSet.add(log) @@ -126,7 +126,7 @@ internal class Store : LogicalObserver { when (value) { is Logical<*> -> { // free logical - val argId = IdWrapper(value.findRoot()) + val argId = Id(value.findRoot()) this.logical2occurrences = logical2occurrences.put(argId, logical2occurrences[argId]?.add(occ) ?: singletonIdSet(occ)) currentFrame().addObserver(value) { frame -> frame.storeObserver() } @@ -147,7 +147,7 @@ internal class Store : LogicalObserver { for (arg in occ.arguments()) { when (arg) { is Logical<*> -> { - val argId = IdWrapper(arg.findRoot()) + val argId = Id(arg.findRoot()) logical2occurrences[argId]?.remove(occ)?.let { newList -> this.logical2occurrences = if (newList.isEmpty) { logical2occurrences.remove(argId) diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/util/IdWrapper.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/util/Id.kt similarity index 92% rename from reactor/Core/src/jetbrains/mps/logic/reactor/util/IdWrapper.kt rename to reactor/Core/src/jetbrains/mps/logic/reactor/util/Id.kt index d4fe3c19..f2e52b7e 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/util/IdWrapper.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/util/Id.kt @@ -16,14 +16,14 @@ package jetbrains.mps.logic.reactor.util -class IdWrapper(val wrapped: T) { +class Id(val wrapped: T) { val idHash = System.identityHashCode(wrapped) override fun hashCode(): Int = idHash override fun equals(other: Any?): Boolean { - if (other is IdWrapper<*>) + if (other is Id<*>) return this.wrapped === other.wrapped // referential equality! return false }