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

Drop obsolete deprecated code

This commit is contained in:
Fedor Isakov 2024-06-13 11:11:22 +02:00
parent b053cd7c3e
commit 506b245438
8 changed files with 17 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt
View File

@ -120,10 +120,6 @@ class RuleIndex(): Iterable<Rule>, RuleLookup
}
}
fun updateIndex(ruleLists: Iterable<RulesList>) {
updateIndexFromRules(ruleLists.flatMap { it.rules() })
}
fun updateIndexFromRules(rules: Iterable<Rule>) {
val removedTags = allRules.map { it.rule.uniqueTag() }.toHashSet()
rules.map { it.uniqueTag() }.forEach{ removedTags.remove(it) }
@ -163,11 +159,6 @@ class RuleIndex(): Iterable<Rule>, RuleLookup
}
}
private fun buildIndex(ruleLists: Iterable<RulesList>) {
val rules = ruleLists.flatMap { it.rules() }
buildIndexFromRules(rules)
}
private fun removeRuleFromIndex(irule: IndexedRule) {
val uniqueTag = irule.rule.uniqueTag()
tag2rule.remove(uniqueTag)

30
reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Instructible.java
View File

@ -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);
}

30
reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Queryable.java
View File

@ -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);
}

4
reactor/Core/src/jetbrains/mps/logic/reactor/evaluation/Solver.java
View File

@ -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) {

30
reactor/Core/src/jetbrains/mps/logic/reactor/program/RulesList.java
View File

@ -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<Rule> rules();
}

31
reactor/Test/src/program/MockProgram.kt
View File

@ -15,13 +15,11 @@ import kotlin.collections.LinkedHashMap
class ProgramBuilder(val registry: MockConstraintRegistry) {
fun program(name: String, rulesLists: List<RulesList>): Program {
for (h in rulesLists) {
for (r in h.rules()) {
registry.update(r)
}
fun program(name: String, rules: List<Rule>): 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<Any, Rule>()
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<Rule> = 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<Rule>) : RulesList() {
override fun name(): String = name
override fun rules(): Iterable<Rule> = rules
}
class MockRule(
val tag: Rule.Tag,
val kept: Collection<Constraint>,
@ -98,10 +81,10 @@ class MockRule(
else (kept + replaced).map { it as AndItem } + guard + body.flatten()
}
class MockProgram(val name: String, val rulesLists: List<RulesList>, val registry: MockConstraintRegistry) : Program() {
class MockProgram(val name: String, val rules: List<Rule>, val registry: MockConstraintRegistry) : Program() {
override fun name(): String = name
override fun rules(): MutableIterable<Rule> = unmodifiableCollection(rulesLists.flatMap { it.rules() })
override fun rules(): MutableIterable<Rule> = unmodifiableCollection(rules)
}

79
reactor/Test/test/RulesHelper.kt
View File

@ -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<RulesList>) : RuleLookup {
class Builder(var rulesList: List<Rule>) : RuleLookup {
val tag2rule = LinkedHashMap<Any, Rule>()
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<RulesList>) : 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<out () -> RulesList>): Builder {
val handlers = ArrayList<RulesList>()
private fun createBuilder(rulesListBlocks: Array<out () -> List<Rule>>): Builder {
val handlers = ArrayList<Rule>()
for (block in rulesListBlocks) {
handlers.add(block())
handlers.addAll(block())
}
return Builder(handlers)
}
private fun updateBuilder(builder:Builder, rulesListBlocks: Array<out () -> 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<Rule> = {
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<Int>, 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<Any>, 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<Int>): Builder =
updateBuilder(this, arrayOf(removeRulesByIndices(at, "test", rulesLists.first())))
fun Builder.removeRules(tags: Iterable<Any>): 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) {

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

@ -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<Any>, feedback: EvaluationFeedback): Boolean =
feedbackHandler(ruleMatch, feedback)