1 files changed, 306 insertions, 0 deletions

diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHints.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHints.java
new file mode 100644
index 00000000..5f3895be
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHints.java
@@ -0,0 +1,306 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.localsearch.matcher.integration;
+
+import tools.refinery.viatra.runtime.localsearch.planner.cost.ICostFunction;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.impl.IndexerBasedConstraintCostFunction;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.impl.StatisticsBasedConstraintCostFunction;
+import tools.refinery.viatra.runtime.matchers.backend.*;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IFlattenCallPredicate;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IRewriterTraceCollector;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.NopTraceCollector;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static tools.refinery.viatra.runtime.localsearch.matcher.integration.LocalSearchHintOptions.*;
+import static tools.refinery.viatra.runtime.matchers.backend.CommonQueryHintOptions.normalizationTraceCollector;
+
+/**
+ * Type safe builder and extractor for Local search specific hints
+ *
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public final class LocalSearchHints implements IMatcherCapability {
+
+    private Boolean useBase = null;
+
+    private Integer rowCount = null;
+
+    private ICostFunction costFunction = null;
+
+    private IFlattenCallPredicate flattenCallPredicate = null;
+
+    private ICallDelegationStrategy callDelegationStrategy = null;
+
+    private IAdornmentProvider adornmentProvider = null;
+
+    private IRewriterTraceCollector traceCollector = NopTraceCollector.INSTANCE;
+
+    private IQueryBackendFactory backendFactory = null;
+
+    private LocalSearchHints() {}
+
+    /**
+     * Return the default settings overridden by the given hints
+     */
+    public static LocalSearchHints getDefaultOverriddenBy(QueryEvaluationHint overridingHint){
+        return parse(getDefault().build(overridingHint));
+    }
+
+    /**
+     * Default settings which are considered the most safe, providing a reasonable performance for most of the cases. Assumes the availability of the base indexer.
+     */
+    public static LocalSearchHints getDefault(){
+        return getDefaultGeneric();
+    }
+
+    /**
+     * Initializes the generic (not EMF specific) search backend with the default settings
+     * @since 1.7
+     */
+    public static LocalSearchHints getDefaultGeneric(){
+        LocalSearchHints result = new LocalSearchHints();
+        result.useBase = true; // Should be unused; but a false value might cause surprises as an engine-default hint
+        result.rowCount = 4;
+        result.costFunction = new IndexerBasedConstraintCostFunction(StatisticsBasedConstraintCostFunction.INVERSE_NAVIGATION_PENALTY_GENERIC);
+        result.flattenCallPredicate = FLATTEN_CALL_PREDICATE.getDefaultValue();
+        result.callDelegationStrategy = ICallDelegationStrategy.FULL_BACKEND_ADHESION;
+        result.adornmentProvider = new LazyPlanningAdornments();
+        result.backendFactory = LocalSearchGenericBackendFactory.INSTANCE;
+        return result;
+    }
+
+    /**
+     * Initializes the default search backend with hybrid-enabled settings
+     * @since 2.1
+     */
+    public static LocalSearchHints getDefaultHybrid(){
+        LocalSearchHints result = getDefault();
+        result.callDelegationStrategy = ICallDelegationStrategy.PARTIAL_BACKEND_ADHESION;
+        result.flattenCallPredicate = new IFlattenCallPredicate.And(
+                new DontFlattenIncrementalPredicate(), new DontFlattenDisjunctive());
+        return result;
+    }
+
+    /**
+     * Initializes the generic (not EMF specific) search backend with hybrid-enabled settings
+     * @since 2.1
+     */
+    public static LocalSearchHints getDefaultGenericHybrid(){
+        LocalSearchHints result = getDefaultGeneric();
+        result.callDelegationStrategy = ICallDelegationStrategy.PARTIAL_BACKEND_ADHESION;
+        result.flattenCallPredicate = new IFlattenCallPredicate.And(
+                new DontFlattenIncrementalPredicate(), new DontFlattenDisjunctive());
+        return result;
+    }
+
+    public static LocalSearchHints parse(QueryEvaluationHint hint){
+        LocalSearchHints result = new LocalSearchHints();
+
+        result.useBase = USE_BASE_INDEX.getValueOrNull(hint);
+        result.rowCount = PLANNER_TABLE_ROW_COUNT.getValueOrNull(hint);
+        result.flattenCallPredicate = FLATTEN_CALL_PREDICATE.getValueOrNull(hint);
+        result.callDelegationStrategy = CALL_DELEGATION_STRATEGY.getValueOrNull(hint);
+        result.costFunction = PLANNER_COST_FUNCTION.getValueOrNull(hint);
+        result.adornmentProvider = ADORNMENT_PROVIDER.getValueOrNull(hint);
+        result.traceCollector = normalizationTraceCollector.getValueOrDefault(hint);
+
+        return result;
+    }
+
+
+    private Map<QueryHintOption<?>, Object> calculateHintMap() {
+        Map<QueryHintOption<?>, Object> map = new HashMap<>();
+        if (useBase != null){
+            USE_BASE_INDEX.insertOverridingValue(map, useBase);
+        }
+        if (rowCount != null){
+            PLANNER_TABLE_ROW_COUNT.insertOverridingValue(map, rowCount);
+        }
+        if (costFunction != null){
+            PLANNER_COST_FUNCTION.insertOverridingValue(map, costFunction);
+        }
+        if (flattenCallPredicate != null){
+            FLATTEN_CALL_PREDICATE.insertOverridingValue(map, flattenCallPredicate);
+        }
+        if (callDelegationStrategy != null){
+            CALL_DELEGATION_STRATEGY.insertOverridingValue(map, callDelegationStrategy);
+        }
+        if (adornmentProvider != null){
+            ADORNMENT_PROVIDER.insertOverridingValue(map, adornmentProvider);
+        }
+        if (traceCollector != null){
+            normalizationTraceCollector.insertOverridingValue(map, traceCollector);
+        }
+        return map;
+    }
+
+    public QueryEvaluationHint build(){
+        Map<QueryHintOption<?>, Object> map = calculateHintMap();
+        return new QueryEvaluationHint(map, backendFactory);
+    }
+
+    /**
+     * @since 1.7
+     */
+    public QueryEvaluationHint build(QueryEvaluationHint overridingHint) {
+        if (overridingHint == null)
+            return build();
+
+        IQueryBackendFactory factory = (overridingHint.getQueryBackendFactory() == null)
+                ? this.backendFactory
+                : overridingHint.getQueryBackendFactory();
+
+        Map<QueryHintOption<?>, Object> hints = calculateHintMap();
+        if (overridingHint.getBackendHintSettings() != null) {
+            hints.putAll(overridingHint.getBackendHintSettings());
+        }
+
+        return new QueryEvaluationHint(hints, factory);
+    }
+
+    public boolean isUseBase() {
+        return useBase;
+    }
+
+    public ICostFunction getCostFunction() {
+        return costFunction;
+    }
+
+    public IFlattenCallPredicate getFlattenCallPredicate() {
+        return flattenCallPredicate;
+    }
+
+    /**
+     * @since 2.1
+     */
+    public ICallDelegationStrategy getCallDelegationStrategy() {
+        return callDelegationStrategy;
+    }
+
+    public Integer getRowCount() {
+        return rowCount;
+    }
+
+    /**
+     * @since 1.5
+     */
+    public IAdornmentProvider getAdornmentProvider() {
+        return adornmentProvider;
+    }
+
+    /**
+     * @since 1.6
+     */
+    public IRewriterTraceCollector getTraceCollector() {
+        return traceCollector == null ? normalizationTraceCollector.getDefaultValue() : traceCollector;
+    }
+
+    public LocalSearchHints setUseBase(boolean useBase) {
+        this.useBase = useBase;
+        return this;
+    }
+
+    public LocalSearchHints setRowCount(int rowCount) {
+        this.rowCount = rowCount;
+        return this;
+    }
+
+    public LocalSearchHints setCostFunction(ICostFunction costFunction) {
+        this.costFunction = costFunction;
+        return this;
+    }
+
+    public LocalSearchHints setFlattenCallPredicate(IFlattenCallPredicate flattenCallPredicate) {
+        this.flattenCallPredicate = flattenCallPredicate;
+        return this;
+    }
+
+
+    /**
+     * @since 2.1
+     */
+    public LocalSearchHints setCallDelegationStrategy(ICallDelegationStrategy callDelegationStrategy) {
+        this.callDelegationStrategy = callDelegationStrategy;
+        return this;
+    }
+
+    /**
+     * @since 1.6
+     */
+    public LocalSearchHints setTraceCollector(IRewriterTraceCollector traceCollector) {
+        this.traceCollector = traceCollector;
+        return this;
+    }
+
+    /**
+     * @since 1.5
+     */
+    public LocalSearchHints setAdornmentProvider(IAdornmentProvider adornmentProvider) {
+        this.adornmentProvider = adornmentProvider;
+        return this;
+    }
+
+    public static LocalSearchHints customizeUseBase(boolean useBase){
+        return new LocalSearchHints().setUseBase(useBase);
+    }
+
+    public static LocalSearchHints customizeRowCount(int rowCount){
+        return new LocalSearchHints().setRowCount(rowCount);
+    }
+
+    public static LocalSearchHints customizeCostFunction(ICostFunction costFunction){
+        return new LocalSearchHints().setCostFunction(costFunction);
+    }
+
+    public static LocalSearchHints customizeFlattenCallPredicate(IFlattenCallPredicate predicate){
+        return new LocalSearchHints().setFlattenCallPredicate(predicate);
+    }
+
+    /**
+     * @since 2.1
+     */
+    public static LocalSearchHints customizeCallDelegationStrategy(ICallDelegationStrategy strategy){
+        return new LocalSearchHints().setCallDelegationStrategy(strategy);
+    }
+
+    /**
+     * @since 1.5
+     */
+    public static LocalSearchHints customizeAdornmentProvider(IAdornmentProvider adornmentProvider){
+        return new LocalSearchHints().setAdornmentProvider(adornmentProvider);
+    }
+
+    /**
+     * @since 1.6
+     */
+    public static LocalSearchHints customizeTraceCollector(IRewriterTraceCollector traceCollector){
+        return new LocalSearchHints().setTraceCollector(traceCollector);
+    }
+
+    @Override
+    public boolean canBeSubstitute(IMatcherCapability capability) {
+        if (capability instanceof LocalSearchHints){
+            LocalSearchHints other = (LocalSearchHints)capability;
+            /*
+             * We allow substitution of matchers if their functionally relevant settings are equal.
+             */
+            return Objects.equals(other.useBase, useBase);
+        }
+        /*
+         * For any other cases (e.g. for Rete), we cannot assume
+         * that matchers created by LS are functionally equivalent.
+         */
+        return false;
+    }
+}