replace explicit StatsContainer with ServiceLoader-based approach

Author: mtf90

algorithms/active/lstar/src/main/java/de/learnlib/algorithm/lstar/mmlt/ExtensibleLStarMMLT.java

@@ -23,9 +23,8 @@
 import de.learnlib.datastructure.observationtable.Row;
 import de.learnlib.oracle.TimedQueryOracle;
 import de.learnlib.query.DefaultQuery;
-import de.learnlib.statistic.container.DummyStatsContainer;
-import de.learnlib.statistic.container.LearnerStatsProvider;
-import de.learnlib.statistic.container.StatsContainer;
+import de.learnlib.statistic.Statistics;
+import de.learnlib.statistic.StatsContainer;
 import de.learnlib.symbol_filter.SymbolFilter;
 import de.learnlib.symbol_filter.SymbolFilterResponse;
 import de.learnlib.util.mealy.MealyUtil;
@@ -50,10 +49,10 @@
  * @param <I> Input type for non-delaying inputs
  * @param <O> Output symbol type
  */
-public class ExtensibleLStarMMLT<I, O> implements OTLearner<MMLT<Integer, I, ?, O>, TimedInput<I>, Word<TimedOutput<O>>>, LearnerStatsProvider {
+public class ExtensibleLStarMMLT<I, O> implements OTLearner<MMLT<Integer, I, ?, O>, TimedInput<I>, Word<TimedOutput<O>>> {
 
     private static final Logger logger = LoggerFactory.getLogger(ExtensibleLStarMMLT.class);
-    private StatsContainer stats = new DummyStatsContainer();
+    private final StatsContainer stats;
 
     private final ClosingStrategy<? super TimedInput<I>, ? super Word<TimedOutput<O>>> closingStrategy;
 
@@ -109,6 +108,7 @@ public ExtensibleLStarMMLT(Alphabet<I> alphabet,
         this.closingStrategy = closingStrategy;
         this.timeOracle = timeOracle;
         this.initialSuffixes = initialSuffixes;
+        this.stats = Statistics.getContainer();
 
         // Prepare hyp data:
 
@@ -424,12 +424,6 @@ protected void completeConsistentTable(List<List<Row<TimedInput<I>>>> unclosed)
 
     }
 
-    @Override
-    public void setStatsContainer(StatsContainer container) {
-        this.stats = container;
-        this.cexAnalyzer.setStatsContainer(container);
-    }
-
     /**
      * Constructs a hypothesis MMLT from an observation table, inferred local resets, and inferred local timers.
      */

algorithms/active/lstar/src/main/java/de/learnlib/algorithm/lstar/mmlt/cex/MMLTCounterexampleHandler.java

@@ -4,16 +4,13 @@
 
 import de.learnlib.acex.AcexAnalyzer;
 import de.learnlib.algorithm.lstar.mmlt.ExtensibleLStarMMLT;
+import de.learnlib.algorithm.lstar.mmlt.MMLTHypothesis;
 import de.learnlib.algorithm.lstar.mmlt.cex.results.CexAnalysisResult;
 import de.learnlib.algorithm.lstar.mmlt.cex.results.FalseIgnoreResult;
 import de.learnlib.algorithm.lstar.mmlt.cex.results.MissingDiscriminatorResult;
 import de.learnlib.algorithm.lstar.mmlt.cex.results.MissingOneShotResult;
 import de.learnlib.algorithm.lstar.mmlt.cex.results.MissingResetResult;
-import de.learnlib.algorithm.lstar.mmlt.MMLTHypothesis;
 import de.learnlib.oracle.TimedQueryOracle;
-import de.learnlib.statistic.container.DummyStatsContainer;
-import de.learnlib.statistic.container.LearnerStatsProvider;
-import de.learnlib.statistic.container.StatsContainer;
 import de.learnlib.symbol_filter.SymbolFilter;
 import de.learnlib.symbol_filter.SymbolFilterResponse;
 import net.automatalib.automaton.mmlt.MealyTimerInfo;
@@ -34,10 +31,9 @@
  * @param <I> Input type for non-delaying inputs
  * @param <O> Output symbol type
  */
-public class MMLTCounterexampleHandler<S, I, O> implements LearnerStatsProvider {
+public class MMLTCounterexampleHandler<S, I, O> {
     private static final Logger logger = LoggerFactory.getLogger(MMLTCounterexampleHandler.class);
     private final SymbolFilter<TimedInput<I>, InputSymbol<I>> symbolFilter;
-    private StatsContainer stats = new DummyStatsContainer();
 
     protected final TimedQueryOracle<I, O> timeOracle;
     private final MMLTCounterexampleDecompositor<S, I, O> decompositor;
@@ -48,13 +44,8 @@ public MMLTCounterexampleHandler(TimedQueryOracle<I, O> timeOracle, AcexAnalyzer
         this.symbolFilter = symbolFilter;
     }
 
-    @Override
-    public void setStatsContainer(StatsContainer container) {
-        this.stats = container;
-    }
-
-    public <T> CexAnalysisResult<I, O> analyzeInconsistency(MMLTOutputInconsistency<I, O> outIncons,
-                                                            MMLTHypothesis<I, O> hypothesis) {
+    public CexAnalysisResult<I, O> analyzeInconsistency(MMLTOutputInconsistency<I, O> outIncons,
+                                                        MMLTHypothesis<I, O> hypothesis) {
 
         // Search for an extended decomposition:
         var decomposition = decompositor.findExtendedDecomposition(outIncons, hypothesis);

…istic/container/DummyStatsContainer.java …rnlib/statistic/DummyStatsContainer.javaapi/src/main/java/de/learnlib/statistic/container/DummyStatsContainer.java renamed to api/src/main/java/de/learnlib/statistic/DummyStatsContainer.java api/src/main/java/de/learnlib/statistic/container/DummyStatsContainer.java renamed to api/src/main/java/de/learnlib/statistic/DummyStatsContainer.java

@@ -1,4 +1,4 @@
-package de.learnlib.statistic.container;
+package de.learnlib.statistic;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -8,7 +8,7 @@
 /**
  * A dummy implementation of {@link StatsContainer} that does nothing.
  */
-public class DummyStatsContainer implements StatsContainer {
+class DummyStatsContainer implements StatsContainer {
     @Override
     public void addTextInfo(String id, @Nullable String description, String text) {
 

api/src/main/java/de/learnlib/statistic/Statistics.java

@@ -0,0 +1,41 @@
+package de.learnlib.statistic;
+
+import java.util.ServiceLoader;
+
+public class Statistics {
+
+    private static final StatisticsProvider PROVIDER;
+
+    static {
+        final ServiceLoader<StatisticsProvider> loader = ServiceLoader.load(StatisticsProvider.class);
+
+        StatisticsProvider bestProvider = new DummyProvider();
+        for (StatisticsProvider sp : loader) {
+            if (sp.getPriority() > bestProvider.getPriority()) {
+                bestProvider = sp;
+            }
+        }
+
+        PROVIDER = bestProvider;
+    }
+
+    public static StatsContainer getContainer() {
+        return PROVIDER.getContainer();
+    }
+
+    private static class DummyProvider implements StatisticsProvider {
+
+        private static final StatsContainer CONTAINER = new DummyStatsContainer();
+
+        @Override
+        public int getPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public StatsContainer getContainer() {
+            return CONTAINER;
+        }
+    }
+
+}

api/src/main/java/de/learnlib/statistic/StatisticsProvider.java

@@ -0,0 +1,8 @@
+package de.learnlib.statistic;
+
+public interface StatisticsProvider {
+
+    int getPriority();
+
+    StatsContainer getContainer();
+}

…/statistic/container/StatsContainer.java …e/learnlib/statistic/StatsContainer.javaapi/src/main/java/de/learnlib/statistic/container/StatsContainer.java renamed to api/src/main/java/de/learnlib/statistic/StatsContainer.java api/src/main/java/de/learnlib/statistic/container/StatsContainer.java renamed to api/src/main/java/de/learnlib/statistic/StatsContainer.java

@@ -1,4 +1,4 @@
-package de.learnlib.statistic.container;
+package de.learnlib.statistic;
 
 
 import org.checkerframework.checker.nullness.qual.Nullable;

api/src/main/java/de/learnlib/statistic/container/LearnerStatsProvider.java

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import de.learnlib.statistic.StatisticsProvider;
+
 /**
  * This module provides the core interfaces of LearnLib.
  * <p>
@@ -43,6 +45,7 @@
     exports de.learnlib.query;
     exports de.learnlib.statistic;
     exports de.learnlib.sul;
-    exports de.learnlib.statistic.container;
     exports de.learnlib.symbol_filter;
+
+    uses StatisticsProvider;
 }

api/src/main/java/module-info.java

@@ -43,5 +43,4 @@
     exports de.learnlib.util.moore;
     exports de.learnlib.util.nfa;
     exports de.learnlib.util.statistic;
-    exports de.learnlib.util.statistic.container;
 }

commons/util/src/main/java/module-info.java

@@ -9,21 +9,22 @@
 import de.learnlib.driver.simulator.MMLTSimulatorSUL;
 import de.learnlib.filter.cache.mmlt.TimedSULTreeCache;
 import de.learnlib.filter.cache.mmlt.TimeoutReducerSUL;
+import de.learnlib.filter.statistic.oracle.CounterEQOracle;
 import de.learnlib.filter.statistic.sul.CounterTimedSUL;
 import de.learnlib.oracle.EquivalenceOracle.MMLTEquivalenceOracle;
-import de.learnlib.oracle.equivalence.mmlt.EQOracleChain;
-import de.learnlib.oracle.equivalence.mmlt.RandomWpOracle;
-import de.learnlib.oracle.equivalence.mmlt.ResetSearchOracle;
+import de.learnlib.oracle.equivalence.MMLTEQOracleChain;
+import de.learnlib.oracle.equivalence.mmlt.RandomWpEQOracle;
+import de.learnlib.oracle.equivalence.mmlt.ResetSearchEQOracle;
 import de.learnlib.oracle.equivalence.mmlt.SimulatorEQOracle;
 import de.learnlib.oracle.membership.TimedSULOracle;
 import de.learnlib.oracle.symbol_filters.CachedSymbolFilter;
 import de.learnlib.oracle.symbol_filters.mmlt.MMLTRandomSymbolFilter;
 import de.learnlib.oracle.symbol_filters.mmlt.MMLTStatisticsSymbolFilter;
 import de.learnlib.query.DefaultQuery;
-import de.learnlib.statistic.container.StatsContainer;
+import de.learnlib.statistic.Statistics;
+import de.learnlib.statistic.StatsContainer;
 import de.learnlib.symbol_filter.SymbolFilter;
 import de.learnlib.testsupport.example.mmlt.MMLTExamples;
-import de.learnlib.util.statistic.container.MapStatsContainer;
 import net.automatalib.automaton.visualization.MMLTVisualizationHelper;
 import net.automatalib.symbol.time.InputSymbol;
 import net.automatalib.symbol.time.TimedInput;
@@ -43,7 +44,7 @@ public static void main(String[] args) {
 
         // We first create a statistics container.
         // This container will store various statistical data during learning:
-        var stats = new MapStatsContainer();
+        var stats = Statistics.getContainer();
         stats.addTextInfo("LocalTimerMealyModel", null, model.toString());
         stats.setCounter("original_locs", "Locations in original", model.getReferenceAutomaton().getStates().size());
         stats.setCounter("original_inputs", "Untimed alphabet size in original", model.getReferenceAutomaton().getInputAlphabet().size());
@@ -54,23 +55,21 @@ public static void main(String[] args) {
         var sul = new MMLTSimulatorSUL<>(model.getReferenceAutomaton().getSemantics());
 
         // We count all operations that are performed on the SUL with a stats-SUL:
-        var statsAfterCache = new CounterTimedSUL<>(sul, stats);
+        var statsAfterCache = new CounterTimedSUL<>(sul);
 
         // We use a cache to avoid redundant operations:
         var cacheSUL = new TimedSULTreeCache<>(statsAfterCache, model.getParams());
-        cacheSUL.setStatsContainer(stats);
-        var toReducerSul = new TimeoutReducerSUL<>(cacheSUL, model.getParams().maxTimeoutWaitingTime(), stats);
+        var toReducerSul = new TimeoutReducerSUL<>(cacheSUL, model.getParams().maxTimeoutWaitingTime());
 
         // We use a query oracle to answer queries from the learner:
         var timeOracle = new TimedSULOracle<>(toReducerSul, model.getParams());
 
         // We use a chain of different equivalence oracles:
-        EQOracleChain<String, String> chainOracle = new EQOracleChain<>();
-        chainOracle.addOracle(cacheSUL.createCacheConsistencyTest());
-        chainOracle.addOracle(new ResetSearchOracle<>(timeOracle, 100, 1.0, 1.0));
-        chainOracle.addOracle(new RandomWpOracle<>(timeOracle, 100, 16, 0, 100));
-        chainOracle.addOracle(new SimulatorEQOracle<>(model.getReferenceAutomaton())); // ensure that we eventually find an accurate model
-        chainOracle.setStatsContainer(stats);
+        MMLTEQOracleChain<String, String> chainOracle = new MMLTEQOracleChain<>();
+        chainOracle.addOracle(new CounterEQOracle<>(cacheSUL.createCacheConsistencyTest(), "cache"));
+        chainOracle.addOracle(new CounterEQOracle<>(new ResetSearchEQOracle<>(timeOracle, 100, 1.0, 1.0), "reset"));
+        chainOracle.addOracle(new CounterEQOracle<>(new RandomWpEQOracle<>(timeOracle, 100, 16, 0, 100), "wp"));
+        chainOracle.addOracle(new CounterEQOracle<>(new SimulatorEQOracle<>(model.getReferenceAutomaton()), "sim")); // ensure that we eventually find an accurate model
 
         // Set up our L* learner:
         List<Word<TimedInput<String>>> suffixes = new ArrayList<>();
@@ -87,7 +86,6 @@ public static void main(String[] args) {
         filter = new CachedSymbolFilter<>(filter); // need to wrap to enable updates to responses
 
         var learner = new ExtensibleLStarMMLT<>(model.getReferenceAutomaton().getInputAlphabet(), model.getParams(), suffixes, timeOracle, filter);
-        learner.setStatsContainer(stats);
 
         // Start learning:
         runExperiment(learner, chainOracle, stats, 100);