cleanup SUL cache impls

Author: mtf90

CHANGELOG.md

@@ -11,11 +11,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 
 * The `{DFA,Mealy,}W{p,}MethodEQOracle(MembershipOracle, int, int)` constructor no longer interprets its second `int` parameter as the batch size, but as an estimate for the expected SUL size. In order to explicitly set the batch size of the oracle, use the `{DFA,Mealy,}W{p,}MethodEQOracle(MembershipOracle, int, int, int)` constructor. Now, the two parameters `lookahead` and `expectedSize` will determine the length of the *middle part* via `Math.max(lookahead, expectedSize - hypothesis.size())`. This allows to dynamically adjust the length of the *middle part* throughout the learning process. See [LearnLib/automatalib#32](https://github.com/LearnLib/automatalib/issues/32).
-* Several DFA/Mealy specific (oracle) subclasses are now automatically generated. As a result they are no longer an inner class, but an indepentend top-level class. This requires to update the import statements.
+* Several DFA/Mealy specific (oracle) subclasses are now automatically generated. As a result they are no longer an inner class, but an independent top-level class. This requires to update the import statements.
 * JSR305 annotations have been replaced with checker-framework annotations.
   * LearnLib (incl. AutomataLib) now follows checker-framework's convention that (non-annotated) types are usually considered non-null unless explicitly annotated with `@Nullable`.
   * LearnLib (incl. AutomataLib) no longer has a (runtime-) dependency on JSR305 (and other `javax.*`) annotations or includes them in the distribution artifact. This now makes LearnLib (incl. AutomataLib) compliant with [Oracle's binary code license](https://www.oracle.com/downloads/licenses/binary-code-license.html) and allows LearnLib (incl. AutomataLib) artifacts as-is to be bundled in binary distributions with Oracle's JDKs/JREs.
 * A lot of code for inferring partial Mealy machines (esp. `PartialLStarMealy` and `PartialObservationTable`) has been removed/refactored. The concept of state local inputs is now implemented as a SUL filter and introduces a special `StateLocalInputSULOracle` which early-answers queries that would traverse unavailable inputs with a previously specified symbol. This way, queries that would traverse undefined input symbols still won't be executed on the SUL but the SUL appears as a 'total' Mealy system to the learner, allowing one to use every currently existing Mealy learner as-is. See the in-tree examples for more information.
+* `SULCache` no longer implements `MembershipOracle`.
 
 ### Removed
 

oracles/filters/cache/src/main/java/de/learnlib/filter/cache/sul/AbstractSULCache.java

@@ -15,22 +15,30 @@
  */
 package de.learnlib.filter.cache.sul;
 
+import java.io.Serializable;
+import java.util.List;
 import java.util.concurrent.locks.ReadWriteLock;
 
+import de.learnlib.api.Resumable;
 import de.learnlib.api.SUL;
+import de.learnlib.api.oracle.EquivalenceOracle.MealyEquivalenceOracle;
 import de.learnlib.filter.cache.LearningCache.MealyLearningCache;
 import de.learnlib.filter.cache.mealy.MealyCacheConsistencyTest;
 import net.automatalib.SupportsGrowingAlphabet;
 import net.automatalib.incremental.mealy.IncrementalMealyBuilder;
 import net.automatalib.ts.output.MealyTransitionSystem;
 import net.automatalib.words.WordBuilder;
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 abstract class AbstractSULCache<I, O> implements SUL<I, O>, MealyLearningCache<I, O>, SupportsGrowingAlphabet<I> {
 
-    private final AbstractSULCacheImpl<?, I, ?, O> impl;
+    private static final Logger LOGGER = LoggerFactory.getLogger(AbstractSULCache.class);
 
-    protected <S, T> AbstractSULCache(AbstractSULCacheImpl<S, I, T, O> cacheImpl) {
+    private final AbstractSULCacheImpl<?, I, ?, O, ? extends AbstractSULCacheState<I, O>> impl;
+
+    protected <S, T> AbstractSULCache(AbstractSULCacheImpl<S, I, T, O, ? extends AbstractSULCacheState<I, O>> cacheImpl) {
         this.impl = cacheImpl;
     }
 
@@ -60,7 +68,7 @@ public SUL<I, O> fork() {
     }
 
     @Override
-    public MealyCacheConsistencyTest<I, O> createCacheConsistencyTest() {
+    public MealyEquivalenceOracle<I, O> createCacheConsistencyTest() {
         return impl.createCacheConsistencyTest();
     }
 
@@ -85,18 +93,20 @@ public int size() {
      *         transition system transition type
      * @param <O>
      *         output symbol type
+     * @param <C>
+     *         cache type
      *
      * @author Malte Isberner
      */
-    abstract static class AbstractSULCacheImpl<S, I, T, O>
-            implements SUL<I, O>, MealyLearningCache<I, O>, SupportsGrowingAlphabet<I> {
+    abstract static class AbstractSULCacheImpl<S, I, T, O, C extends AbstractSULCacheState<I, O>>
+            implements SUL<I, O>, MealyLearningCache<I, O>, SupportsGrowingAlphabet<I>, Resumable<C> {
 
         protected IncrementalMealyBuilder<I, O> incMealy;
         protected MealyTransitionSystem<S, I, T, O> mealyTs;
         protected final SUL<I, O> delegate;
         protected final ReadWriteLock incMealyLock;
 
-        protected final WordBuilder<I> inputWord = new WordBuilder<>();
+        private final WordBuilder<I> inputWord = new WordBuilder<>();
         private final WordBuilder<O> outputWord = new WordBuilder<>();
 
         private boolean delegatePreCalled;
@@ -143,6 +153,7 @@ public O step(I in) {
 
             if (current == null) {
                 out = delegate.step(in);
+                postNewStepHook();
                 outputWord.add(out);
             }
 
@@ -161,7 +172,8 @@ public void post() {
                 // otherwise acquire write-lock to update cache!
                 incMealyLock.writeLock().lock();
                 try {
-                    writeCache();
+                    incMealy.insert(inputWord.toWord(), outputWord.toWord());
+                    postCacheWriteHook(inputWord);
                 } finally {
                     incMealyLock.writeLock().unlock();
                 }
@@ -182,7 +194,7 @@ public boolean canFork() {
         }
 
         @Override
-        public MealyCacheConsistencyTest<I, O> createCacheConsistencyTest() {
+        public MealyEquivalenceOracle<I, O> createCacheConsistencyTest() {
             return new MealyCacheConsistencyTest<>(incMealy, incMealyLock);
         }
 
@@ -191,15 +203,41 @@ public void addAlphabetSymbol(I symbol) {
             incMealy.addAlphabetSymbol(symbol);
         }
 
+        @Override
+        @SuppressWarnings("unchecked")
+        public void resume(C state) {
+            final Class<?> thisClass = this.incMealy.getClass();
+            final Class<?> stateClass = state.builder.getClass();
+
+            if (!thisClass.equals(stateClass)) {
+                LOGGER.warn(
+                        "You currently plan to use a '{}', but the state contained a '{}'. This may yield unexpected behavior.",
+                        thisClass,
+                        stateClass);
+            }
+
+            this.incMealy = state.builder;
+            this.mealyTs = (MealyTransitionSystem<S, I, T, O>) this.incMealy.asTransitionSystem();
+        }
+
         protected void requiredInitializedDelegate() {
             if (!delegatePreCalled) {
                 delegate.pre();
             }
             delegatePreCalled = true;
         }
 
-        protected void writeCache() {
-            incMealy.insert(inputWord.toWord(), outputWord.toWord());
+        protected void postNewStepHook() {}
+
+        protected void postCacheWriteHook(List<I> input) {}
+    }
+
+    abstract static class AbstractSULCacheState<I, O> implements Serializable {
+
+        final IncrementalMealyBuilder<I, O> builder;
+
+        protected AbstractSULCacheState(IncrementalMealyBuilder<I, O> builder) {
+            this.builder = builder;
         }
     }
 }

oracles/filters/cache/src/main/java/de/learnlib/filter/cache/sul/SULCache.java

@@ -15,7 +15,6 @@
  */
 package de.learnlib.filter.cache.sul;
 
-import java.io.Serializable;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
@@ -27,8 +26,6 @@
 import net.automatalib.incremental.mealy.tree.IncrementalMealyTreeBuilder;
 import net.automatalib.ts.output.MealyTransitionSystem;
 import net.automatalib.words.Alphabet;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * A cache to be used with a {@link SUL}.
@@ -49,8 +46,6 @@
  */
 public class SULCache<I, O> extends AbstractSULCache<I, O> implements Resumable<SULCacheState<I, O>> {
 
-    private static final Logger LOGGER = LoggerFactory.getLogger(SULCache.class);
-
     private final SULCacheImpl<?, I, ?, O> impl;
 
     SULCache(IncrementalMealyBuilder<I, O> incMealy, SUL<I, O> sul) {
@@ -95,8 +90,7 @@ public void resume(SULCacheState<I, O> state) {
      *
      * @author Malte Isberner
      */
-    private static final class SULCacheImpl<S, I, T, O> extends AbstractSULCacheImpl<S, I, T, O>
-            implements Resumable<SULCacheState<I, O>> {
+    private static final class SULCacheImpl<S, I, T, O> extends AbstractSULCacheImpl<S, I, T, O, SULCacheState<I, O>> {
 
         SULCacheImpl(IncrementalMealyBuilder<I, O> incMealy,
                      ReadWriteLock lock,
@@ -114,31 +108,12 @@ public SUL<I, O> fork() {
         public SULCacheState<I, O> suspend() {
             return new SULCacheState<>(incMealy);
         }
-
-        @Override
-        @SuppressWarnings("unchecked")
-        public void resume(SULCacheState<I, O> state) {
-            final Class<?> thisClass = this.incMealy.getClass();
-            final Class<?> stateClass = state.builder.getClass();
-
-            if (!thisClass.equals(stateClass)) {
-                LOGGER.warn(
-                        "You currently plan to use a '{}', but the state contained a '{}'. This may yield unexpected behavior.",
-                        thisClass,
-                        stateClass);
-            }
-
-            super.incMealy = state.builder;
-            super.mealyTs = (MealyTransitionSystem<S, I, T, O>) this.incMealy.asTransitionSystem();
-        }
     }
 
-    public static class SULCacheState<I, O> implements Serializable {
-
-        final IncrementalMealyBuilder<I, O> builder;
+    public static final class SULCacheState<I, O> extends AbstractSULCacheState<I, O> {
 
         SULCacheState(IncrementalMealyBuilder<I, O> builder) {
-            this.builder = builder;
+            super(builder);
         }
     }