adjust to AutomataLib refactorings

Author: mtf90

algorithms/active/lstar/src/main/java/de/learnlib/algorithm/lstar/AbstractAutomatonLStar.java

@@ -24,7 +24,7 @@
 import net.automatalib.alphabet.Alphabet;
 import net.automatalib.alphabet.SupportsGrowingAlphabet;
 import net.automatalib.automaton.MutableDeterministic;
-import net.automatalib.common.util.array.ResizingArrayStorage;
+import net.automatalib.common.util.array.ArrayStorage;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -51,7 +51,7 @@ public abstract class AbstractAutomatonLStar<A, I, D, S, T, SP, TP, AI extends M
     private static final Logger LOGGER = LoggerFactory.getLogger(AbstractAutomatonLStar.class);
 
     protected AI internalHyp;
-    protected ResizingArrayStorage<StateInfo<S, I>> stateInfos = new ResizingArrayStorage<>(StateInfo.class);
+    protected ArrayStorage<StateInfo<S, I>> stateInfos = new ArrayStorage<>();
 
     /**
      * Constructor.
@@ -92,11 +92,11 @@ protected void updateInternalHypothesis() {
         // FIRST PASS: Create new hypothesis states
         for (Row<I> sp : table.getShortPrefixRows()) {
             int id = sp.getRowContentId();
-            StateInfo<S, I> info = stateInfos.array[id];
+            StateInfo<S, I> info = stateInfos.get(id);
 
             if (info == null) {
                 S state = createState(id == 0, sp);
-                stateInfos.array[id] = new StateInfo<>(sp, state);
+                stateInfos.set(id, new StateInfo<>(sp, state));
             } else if (info.getRow() == sp) { // State from previous hypothesis, property might have changed
                 internalHyp.setStateProperty(info.getState(), stateProperty(table, sp));
             }
@@ -105,7 +105,7 @@ protected void updateInternalHypothesis() {
 
         // SECOND PASS: Create hypothesis transitions
         for (int r = 0; r < numDistinct; r++) {
-            StateInfo<S, I> info = stateInfos.array[r];
+            StateInfo<S, I> info = stateInfos.get(r);
             Row<I> sp = info.getRow();
             S state = info.getState();
 
@@ -115,7 +115,7 @@ protected void updateInternalHypothesis() {
                 Row<I> succ = sp.getSuccessor(i);
                 int succId = succ.getRowContentId();
 
-                S succState = stateInfos.array[succId].getState();
+                S succState = stateInfos.get(succId).getState();
 
                 setTransition(state, input, succState, sp, i);
             }

algorithms/active/lstar/src/main/java/de/learnlib/algorithm/lstar/AutomatonLStarState.java

@@ -17,7 +17,7 @@
 
 import de.learnlib.algorithm.lstar.AbstractAutomatonLStar.StateInfo;
 import de.learnlib.datastructure.observationtable.GenericObservationTable;
-import net.automatalib.common.util.array.ResizingArrayStorage;
+import net.automatalib.common.util.array.ArrayStorage;
 
 /**
  * Class that contains all data that represent the internal state of the {@link AbstractAutomatonLStar} learner and its
@@ -36,11 +36,11 @@ public class AutomatonLStarState<I, D, AI, S> {
 
     private final GenericObservationTable<I, D> observationTable;
     private final AI hypothesis;
-    private final ResizingArrayStorage<StateInfo<S, I>> stateInfos;
+    private final ArrayStorage<StateInfo<S, I>> stateInfos;
 
     AutomatonLStarState(GenericObservationTable<I, D> observationTable,
                         AI hypothesis,
-                        ResizingArrayStorage<StateInfo<S, I>> stateInfos) {
+                        ArrayStorage<StateInfo<S, I>> stateInfos) {
         this.observationTable = observationTable;
         this.hypothesis = hypothesis;
         this.stateInfos = stateInfos;
@@ -54,7 +54,7 @@ AI getHypothesis() {
         return hypothesis;
     }
 
-    ResizingArrayStorage<AbstractAutomatonLStar.StateInfo<S, I>> getStateInfos() {
+    ArrayStorage<StateInfo<S, I>> getStateInfos() {
         return stateInfos;
     }
 }

algorithms/active/observation-pack-vpa/src/main/java/de/learnlib/algorithm/observationpack/vpa/hypothesis/HypLoc.java

@@ -18,7 +18,6 @@
 import de.learnlib.AccessSequenceProvider;
 import net.automatalib.alphabet.VPAlphabet;
 import net.automatalib.common.util.array.ArrayStorage;
-import net.automatalib.common.util.array.ResizingArrayStorage;
 import net.automatalib.word.Word;
 
 /**
@@ -32,7 +31,7 @@ public class HypLoc<I> implements AccessSequenceProvider<I> {
     private final AbstractHypTrans<I> treeIncoming;
     private final Word<I> aseq;
     private final ArrayStorage<HypIntTrans<I>> intSuccessors;
-    private final ArrayStorage<ResizingArrayStorage<HypRetTrans<I>>> returnSuccessors;
+    private final ArrayStorage<ArrayStorage<HypRetTrans<I>>> returnSuccessors;
     private final int index;
     private boolean accepting;
     private DTNode<I> leaf;
@@ -48,11 +47,11 @@ public HypLoc(VPAlphabet<I> alphabet, int index, boolean accepting, AbstractHypT
 
     public void updateStackAlphabetSize(int newStackAlphaSize) {
         for (int i = 0; i < returnSuccessors.size(); i++) {
-            ResizingArrayStorage<HypRetTrans<I>> transList = returnSuccessors.get(i);
+            ArrayStorage<HypRetTrans<I>> transList = returnSuccessors.get(i);
             if (transList == null) {
-                transList = new ResizingArrayStorage<>(HypRetTrans.class, newStackAlphaSize);
+                transList = new ArrayStorage<>(newStackAlphaSize);
                 returnSuccessors.set(i, transList);
-            } else if (transList.array.length < newStackAlphaSize) {
+            } else if (transList.size() < newStackAlphaSize) {
                 transList.ensureCapacity(newStackAlphaSize);
             }
         }
@@ -88,18 +87,18 @@ public void setAccepting(boolean accepting) {
     }
 
     public HypRetTrans<I> getReturnTransition(int retSymId, int stackSym) {
-        final ResizingArrayStorage<HypRetTrans<I>> succList = returnSuccessors.get(retSymId);
-        return succList.array[stackSym];
+        final ArrayStorage<HypRetTrans<I>> succList = returnSuccessors.get(retSymId);
+        return succList.get(stackSym);
     }
 
     public void setReturnTransition(int retSymId, int stackSym, HypRetTrans<I> trans) {
-        ResizingArrayStorage<HypRetTrans<I>> succList = returnSuccessors.get(retSymId);
+        ArrayStorage<HypRetTrans<I>> succList = returnSuccessors.get(retSymId);
         if (succList == null) {
-            succList = new ResizingArrayStorage<>(HypRetTrans.class, stackSym + 1);
+            succList = new ArrayStorage<>(stackSym + 1);
             returnSuccessors.set(retSymId, succList);
         }
         succList.ensureCapacity(stackSym);
-        succList.array[stackSym] = trans;
+        succList.set(stackSym, trans);
     }
 
     public HypIntTrans<I> getInternalTransition(int intSymId) {

algorithms/active/observation-pack/src/main/java/de/learnlib/algorithm/observationpack/hypothesis/HState.java

@@ -16,13 +16,12 @@
 package de.learnlib.algorithm.observationpack.hypothesis;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
 import de.learnlib.datastructure.discriminationtree.model.AbstractWordBasedDTNode;
-import net.automatalib.common.util.array.ResizingArrayStorage;
+import net.automatalib.common.util.array.ArrayStorage;
 import net.automatalib.word.Word;
 import net.automatalib.word.WordBuilder;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -32,7 +31,7 @@ public class HState<I, O, SP, TP> {
     private final @Nullable HTransition<I, O, SP, TP> treeIncoming;
     private final int id;
     private final int depth;
-    private final ResizingArrayStorage<HTransition<I, O, SP, TP>> transitions;
+    private final ArrayStorage<HTransition<I, O, SP, TP>> transitions;
     private final List<HTransition<I, O, SP, TP>> nonTreeIncoming = new ArrayList<>();
     private AbstractWordBasedDTNode<I, O, HState<I, O, SP, TP>> dtLeaf;
     private SP property;
@@ -45,7 +44,7 @@ public HState(int initialAlphabetSize, int id, @Nullable HTransition<I, O, SP, T
         this.id = id;
         this.treeIncoming = treeIncoming;
         this.depth = (treeIncoming == null) ? 0 : treeIncoming.getSource().depth + 1;
-        this.transitions = new ResizingArrayStorage<>(HTransition.class, initialAlphabetSize);
+        this.transitions = new ArrayStorage<>(initialAlphabetSize);
     }
 
     public AbstractWordBasedDTNode<I, O, HState<I, O, SP, TP>> getDTLeaf() {
@@ -90,15 +89,15 @@ public int getId() {
     }
 
     public HTransition<I, O, SP, TP> getTransition(int transIdx) {
-        return transitions.array[transIdx];
+        return transitions.get(transIdx);
     }
 
     public void setTransition(int transIdx, HTransition<I, O, SP, TP> transition) {
-        transitions.array[transIdx] = transition;
+        transitions.set(transIdx, transition);
     }
 
     public Collection<HTransition<I, O, SP, TP>> getOutgoingTransitions() {
-        return Collections.unmodifiableList(Arrays.asList(transitions.array));
+        return Collections.unmodifiableList(transitions);
     }
 
     public int getDepth() {

algorithms/active/ttt/src/main/java/de/learnlib/algorithm/ttt/base/TTTState.java

@@ -16,7 +16,7 @@
 package de.learnlib.algorithm.ttt.base;
 
 import de.learnlib.AccessSequenceProvider;
-import net.automatalib.common.util.array.ResizingArrayStorage;
+import net.automatalib.common.util.array.ArrayStorage;
 import net.automatalib.word.Word;
 
 /**
@@ -29,15 +29,15 @@ public class TTTState<I, D> implements AccessSequenceProvider<I> {
 
     final int id;
 
-    private final ResizingArrayStorage<TTTTransition<I, D>> transitions;
+    private final ArrayStorage<TTTTransition<I, D>> transitions;
     private final TTTTransition<I, D> parentTransition;
 
     AbstractBaseDTNode<I, D> dtLeaf;
 
     public TTTState(int initialAlphabetSize, TTTTransition<I, D> parentTransition, int id) {
         this.id = id;
         this.parentTransition = parentTransition;
-        this.transitions = new ResizingArrayStorage<>(TTTTransition.class, initialAlphabetSize);
+        this.transitions = new ArrayStorage<>(initialAlphabetSize);
     }
 
     /**
@@ -76,15 +76,15 @@ public String toString() {
     }
 
     public void setTransition(int idx, TTTTransition<I, D> transition) {
-        transitions.array[idx] = transition;
+        transitions.set(idx, transition);
     }
 
     public TTTTransition<I, D> getTransition(int idx) {
-        return transitions.array[idx];
+        return transitions.get(idx);
     }
 
-    public TTTTransition<I, D>[] getTransitions() {
-        return transitions.array;
+    public Iterable<TTTTransition<I, D>> getTransitions() {
+        return transitions;
     }
 
     public boolean ensureInputCapacity(int capacity) {

commons/datastructures/src/main/java/de/learnlib/datastructure/observationtable/RowImpl.java

@@ -15,7 +15,7 @@
  */
 package de.learnlib.datastructure.observationtable;
 
-import net.automatalib.common.util.array.ResizingArrayStorage;
+import net.automatalib.common.util.array.ArrayStorage;
 import net.automatalib.word.Word;
 
 final class RowImpl<I> implements Row<I> {
@@ -25,7 +25,7 @@ final class RowImpl<I> implements Row<I> {
 
     private int rowContentId = -1;
     private int lpIndex;
-    private ResizingArrayStorage<RowImpl<I>> successors;
+    private ArrayStorage<RowImpl<I>> successors;
 
     /**
      * Constructor for short label rows.
@@ -68,12 +68,12 @@ void makeShort(int initialAlphabetSize) {
             return;
         }
         lpIndex = -1;
-        this.successors = new ResizingArrayStorage<>(RowImpl.class, initialAlphabetSize);
+        this.successors = new ArrayStorage<>(initialAlphabetSize);
     }
 
     @Override
     public RowImpl<I> getSuccessor(int inputIdx) {
-        return successors.array[inputIdx];
+        return successors.get(inputIdx);
     }
 
     /**
@@ -86,7 +86,7 @@ public RowImpl<I> getSuccessor(int inputIdx) {
      *         the successor row
      */
     void setSuccessor(int inputIdx, RowImpl<I> succ) {
-        successors.array[inputIdx] = succ;
+        successors.set(inputIdx, succ);
     }
 
     @Override
@@ -131,9 +131,6 @@ void setLpIndex(int lpIndex) {
         this.lpIndex = lpIndex;
     }
 
-    /**
-     * See {@link ResizingArrayStorage#ensureCapacity(int)}.
-     */
     void ensureInputCapacity(int capacity) {
         this.successors.ensureCapacity(capacity);
     }