From 506b24543813044c42232280d8429b8ea070cb04 Mon Sep 17 00:00:00 2001 From: Fedor Isakov Date: Thu, 13 Jun 2024 11:11:22 +0200 Subject: [PATCH] Drop obsolete deprecated code --- .../mps/logic/reactor/core/RuleIndex.kt | 9 --- .../reactor/evaluation/Instructible.java | 30 ------- .../logic/reactor/evaluation/Queryable.java | 30 ------- .../mps/logic/reactor/evaluation/Solver.java | 4 +- .../mps/logic/reactor/program/RulesList.java | 30 ------- reactor/Test/src/program/MockProgram.kt | 31 ++------ reactor/Test/test/RulesHelper.kt | 79 ++----------------- reactor/Test/test/TestController.kt | 4 +- 8 files changed, 17 insertions(+), 200 deletions(-) delete mode 100644 reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Instructible.java delete mode 100644 reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Queryable.java delete mode 100644 reactor/Core/src/jetbrains/mps/logic/reactor/program/RulesList.java diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt index 743991b5..a09a432f 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt @@ -120,10 +120,6 @@ class RuleIndex(): Iterable, RuleLookup } } - fun updateIndex(ruleLists: Iterable) { - updateIndexFromRules(ruleLists.flatMap { it.rules() }) - } - fun updateIndexFromRules(rules: Iterable) { val removedTags = allRules.map { it.rule.uniqueTag() }.toHashSet() rules.map { it.uniqueTag() }.forEach{ removedTags.remove(it) } @@ -163,11 +159,6 @@ class RuleIndex(): Iterable, RuleLookup } } - private fun buildIndex(ruleLists: Iterable) { - val rules = ruleLists.flatMap { it.rules() } - buildIndexFromRules(rules) - } - private fun removeRuleFromIndex(irule: IndexedRule) { val uniqueTag = irule.rule.uniqueTag() tag2rule.remove(uniqueTag) diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Instructible.java b/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Instructible.java deleted file mode 100644 index 8c724279..00000000 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Instructible.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright 2014-2019 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package jetbrains.mps.logic.reactor.evaluation; - - -/** - * Abstract interface to a predicate. - * - * @author Fedor Isakov - */ -@Deprecated -public interface Instructible { - - void tell(PredicateInvocation invocation); - -} diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Queryable.java b/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Queryable.java deleted file mode 100644 index d30c62b9..00000000 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Queryable.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright 2014-2019 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package jetbrains.mps.logic.reactor.evaluation; - - -/** - * Abstract interface to a predicate. - * - * @author Fedor Isakov - */ -@Deprecated -public interface Queryable extends Instructible { - - boolean ask(PredicateInvocation invocation); - -} diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Solver.java b/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Solver.java index 469c707f..7da515b7 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Solver.java +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Solver.java @@ -23,7 +23,7 @@ import org.jetbrains.annotations.NotNull; * * @author Fedor Isakov */ -public interface Solver extends Queryable, Instructible { +public interface Solver { class Result { @@ -88,10 +88,8 @@ public interface Solver extends Queryable, Instructible { } } - @Override void tell(PredicateInvocation invocation); - @Override boolean ask(PredicateInvocation invocation); default Result tryTell(PredicateInvocation invocation) { diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/program/RulesList.java b/reactor/Core/src/jetbrains/mps/logic/reactor/program/RulesList.java deleted file mode 100644 index b32db766..00000000 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/program/RulesList.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright 2014-2019 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package jetbrains.mps.logic.reactor.program; - -/** - * A container for rules. - * @author Fedor Isakov - */ -@Deprecated -public abstract class RulesList { - - public abstract String name(); - - public abstract Iterable rules(); - -} diff --git a/reactor/Test/src/program/MockProgram.kt b/reactor/Test/src/program/MockProgram.kt index f2b841e1..25646271 100644 --- a/reactor/Test/src/program/MockProgram.kt +++ b/reactor/Test/src/program/MockProgram.kt @@ -15,13 +15,11 @@ import kotlin.collections.LinkedHashMap class ProgramBuilder(val registry: MockConstraintRegistry) { - fun program(name: String, rulesLists: List): Program { - for (h in rulesLists) { - for (r in h.rules()) { - registry.update(r) - } + fun program(name: String, rules: List): Program { + for (r in rules) { + registry.update(r) } - return MockProgram(name, rulesLists, registry) + return MockProgram(name, rules, registry) } } @@ -30,17 +28,11 @@ class HandlerBuilder(val name: String) { val rules = LinkedHashMap() - constructor(name: String, rulesList: RulesList) : this(name) { - for (r in rulesList.rules()) { - appendRule(r) - } - } - fun appendRule(rule: Rule) { rules[rule.uniqueTag()] = rule } - fun toHandler(): RulesList = MockHandler(name, rules.values.toList()) + fun toHandler(): List = rules.values.toList() } class RuleBuilder(val tag: String) { @@ -65,15 +57,6 @@ class RuleBuilder(val tag: String) { fun toRule(): Rule = MockRule(Rule.Tag(tag), kept, replaced, guard, body) } -class MockHandler( - val name: String, - val rules: List) : RulesList() { - - override fun name(): String = name - - override fun rules(): Iterable = rules -} - class MockRule( val tag: Rule.Tag, val kept: Collection, @@ -98,10 +81,10 @@ class MockRule( else (kept + replaced).map { it as AndItem } + guard + body.flatten() } -class MockProgram(val name: String, val rulesLists: List, val registry: MockConstraintRegistry) : Program() { +class MockProgram(val name: String, val rules: List, val registry: MockConstraintRegistry) : Program() { override fun name(): String = name - override fun rules(): MutableIterable = unmodifiableCollection(rulesLists.flatMap { it.rules() }) + override fun rules(): MutableIterable = unmodifiableCollection(rules) } diff --git a/reactor/Test/test/RulesHelper.kt b/reactor/Test/test/RulesHelper.kt index 4de88bac..6dd6d7ad 100644 --- a/reactor/Test/test/RulesHelper.kt +++ b/reactor/Test/test/RulesHelper.kt @@ -10,21 +10,19 @@ import jetbrains.mps.logic.reactor.program.* import program.MockConstraint import solver.TestEqPredicate import java.util.* -import kotlin.collections.HashMap /** * @author Fedor Isakov */ -class Builder(var rulesLists: List) : RuleLookup { +class Builder(var rulesList: List) : RuleLookup { val tag2rule = LinkedHashMap() val programBuilder = ProgramBuilder(MockConstraintRegistry()) init { - rulesLists - .flatMap { it.rules() } + rulesList .forEach { r -> tag2rule[r.uniqueTag()] = r } } @@ -35,28 +33,19 @@ class Builder(var rulesLists: List) : RuleLookup { fun ruleMatcher(): RuleMatcher = createRuleMatcher(this, rules.first().uniqueTag()) - fun program(name: String): Program = programBuilder.program(name, rulesLists) + fun program(name: String): Program = programBuilder.program(name, rulesList) } -private fun createBuilder(rulesListBlocks: Array RulesList>): Builder { - val handlers = ArrayList() +private fun createBuilder(rulesListBlocks: Array List>): Builder { + val handlers = ArrayList() for (block in rulesListBlocks) { - handlers.add(block()) + handlers.addAll(block()) } return Builder(handlers) } -private fun updateBuilder(builder:Builder, rulesListBlocks: Array RulesList>): Builder { - val name2handler = HashMap(builder.rulesLists.map { it.name() to it }.toMap()) - for (block in rulesListBlocks) { - val h = block() - name2handler[h.name()] = h - } - return Builder(name2handler.values.toList()) -} - -private fun createHandler(name: String, vararg ruleBlocks: () -> Rule): () -> RulesList = { +private fun createHandler(name: String, vararg ruleBlocks: () -> Rule): () -> List = { val hb = HandlerBuilder(name) for (block in ruleBlocks) { hb.appendRule(block()) @@ -64,66 +53,12 @@ private fun createHandler(name: String, vararg ruleBlocks: () -> Rule): () -> Ru hb.toHandler() } -private fun updateHandler(name: String, rulesList: RulesList, vararg ruleBlocks: () -> Rule): () -> RulesList = { - val hb = HandlerBuilder(name, rulesList) - for (block in ruleBlocks) { - hb.appendRule(block()) - } - hb.toHandler() -} - -private fun insertRulesInHandler(at: Int, name: String, rulesList: RulesList, vararg ruleBlocks: () -> Rule): () -> RulesList = { - val hb = HandlerBuilder(name) - rulesList.rules().forEachIndexed { index, rule -> - if (index == at) { - for (block in ruleBlocks) { - hb.appendRule(block()) - } - } - hb.appendRule(rule) - } - hb.toHandler() -} - -private fun removeRulesByIndices(at: Iterable, name: String, rulesList: RulesList): () -> RulesList = { - val hb = HandlerBuilder(name) - rulesList.rules().forEachIndexed { index, rule -> - if (!at.contains(index)) hb.appendRule(rule) - } - hb.toHandler() -} - -private fun removeRulesByTags(tags: Iterable, name: String, rulesList: RulesList): () -> RulesList = { - val hb = HandlerBuilder(name) - rulesList.rules().forEach { rule -> - if (!tags.contains(rule.uniqueTag())) hb.appendRule(rule) - } - hb.toHandler() -} - -private fun insertRulesInHandlerWhen(at: (Rule) -> Boolean, name: String, rulesList: RulesList, vararg ruleBlocks: () -> Rule): () -> RulesList = - insertRulesInHandler(rulesList.rules().indexOfFirst(at), name, rulesList, * ruleBlocks) // builder DSL for constructing program fun programWithRules(vararg ruleBuilders: () -> Rule): Builder = createBuilder(arrayOf(createHandler("test", * ruleBuilders))) -fun Builder.programWithRules(vararg ruleBuilders: () -> Rule): Builder = - updateBuilder(this, arrayOf(updateHandler("test", rulesLists.first(), * ruleBuilders))) - -fun Builder.removeRulesAt(at: Iterable): Builder = - updateBuilder(this, arrayOf(removeRulesByIndices(at, "test", rulesLists.first()))) - -fun Builder.removeRules(tags: Iterable): Builder = - updateBuilder(this, arrayOf(removeRulesByTags(tags, "test", rulesLists.first()))) - -fun Builder.insertRulesAt(at: Int, vararg ruleBuilders: () -> Rule): Builder = - updateBuilder(this, arrayOf(insertRulesInHandler(at, "test", rulesLists.first(), * ruleBuilders))) - -fun Builder.insertRulesWhen(at: (Rule) -> Boolean, vararg ruleBuilders: () -> Rule): Builder = - updateBuilder(this, arrayOf(insertRulesInHandlerWhen(at, "test", rulesLists.first(), * ruleBuilders))) - fun rule(tag: String, vararg component: RuleBuilder.() -> Unit): () -> Rule = { val rb = RuleBuilder(tag) for (cmp in component) { diff --git a/reactor/Test/test/TestController.kt b/reactor/Test/test/TestController.kt index 93a3d08f..4a166e60 100644 --- a/reactor/Test/test/TestController.kt +++ b/reactor/Test/test/TestController.kt @@ -57,7 +57,7 @@ class TestController { } private fun Builder.controller(vararg occurrences: ConstraintOccurrence): Controller { - val program = MockProgram("test", rulesLists, registry = MockConstraintRegistry()) + val program = MockProgram("test", rulesList, registry = MockConstraintRegistry()) MockSession.init(program, MockSupervisor()) val controller = createController(MockSupervisor(), RuleIndex(program.rules())) MockSession.ourBackend.session.controller = controller @@ -66,7 +66,7 @@ class TestController { private fun Builder.controllerWithFeedback(feedbackHandler: (RuleMatch, EvaluationFeedback) -> Boolean, vararg occurrences: ConstraintOccurrence): Controller { - val program = MockProgram("test", rulesLists, registry = MockConstraintRegistry()) + val program = MockProgram("test", rulesList, registry = MockConstraintRegistry()) val supervisor = object : MockSupervisor() { override fun handleFeedback(ruleMatch: RuleMatch, feedbackKey: Any, feedbackBasis: MutableList, feedback: EvaluationFeedback): Boolean = feedbackHandler(ruleMatch, feedback)