fix issues flagged by code-analysis

Author: mtf90

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

@@ -1,25 +1,45 @@
+/* Copyright (C) 2013-2025 TU Dortmund University
+ * This file is part of LearnLib <https://learnlib.de>.
+ *
+ * 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 de.learnlib.algorithm.lstar.mmlt;
 
-import net.automatalib.symbol.time.TimedInput;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import net.automatalib.automaton.mmlt.TimerInfo;
+import net.automatalib.symbol.time.TimedInput;
 import net.automatalib.word.Word;
-import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.Serializable;
-import java.util.*;
-
 /**
  * Stores information about local timers of a location.
  *
- * @param <I> Input type for non-delaying inputs
- * @param <O> Output symbol type
+ * @param <I>
+ *         input symbol type (of non-delaying inputs)
+ * @param <O>
+ *         output symbol type
  */
-public class LocationTimerInfo<I, O> implements Serializable {
+public class LocationTimerInfo<I, O> {
 
-    private static final Logger logger = LoggerFactory.getLogger(LocationTimerInfo.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(LocationTimerInfo.class);
 
     private final Map<String, TimerInfo<?, O>> timers; // name -> info
 
@@ -43,6 +63,9 @@ public Word<TimedInput<I>> getPrefix() {
     /**
      * Adds a local timer to this location.
      *
+     * @param timer
+     *         the timer to add
+     *
      */
     public void addTimer(TimerInfo<?, O> timer) {
         this.timers.put(timer.name(), timer);
@@ -51,42 +74,52 @@ public void addTimer(TimerInfo<?, O> timer) {
     }
 
     public void removeTimer(String timerName) {
-        if (!this.timers.containsKey(timerName)) {
-            logger.warn("Attempted to remove an unknown timer.");
-            return;
+        final TimerInfo<?, O> removedTimer = this.timers.remove(timerName);
+        if (removedTimer == null) {
+            LOGGER.warn("Attempted to remove an unknown timer.");
+        } else {
+            this.sortedTimers.remove(removedTimer);
         }
-        TimerInfo<?, O> removedTimer = this.timers.remove(timerName);
-        this.sortedTimers.remove(removedTimer);
     }
 
-    @Nullable
-    public TimerInfo<?, O> getTimerInfo(long initial) {
-        Optional<TimerInfo<?, O>> timer = this.sortedTimers.stream().filter(t -> t.initial() == initial).findAny();
-        return timer.orElse(null);
+    /**
+     * Returns the timer with the given initial value.
+     *
+     * @param initial
+     *         the queried initial value
+     *
+     * @return the timer with given timeout, {@code null} if no such timer exists
+     */
+    public @Nullable TimerInfo<?, O> getTimerInfo(long initial) {
+        for (TimerInfo<?, O> t : this.sortedTimers) {
+            if (t.initial() == initial) {
+                return t;
+            }
+        }
+        return null;
     }
 
-
     /**
-     * Returns the timer with the highest initial value
+     * Returns the timer with the highest initial value.
      *
-     * @return Timer with maximum timeout. Null, if no timers defined.
+     * @return the timer with maximum timeout, {@code null} if no timers defined
      */
-    @Nullable
-    public TimerInfo<?, O> getLastTimer() {
+    public @Nullable TimerInfo<?, O> getLastTimer() {
         if (this.timers.isEmpty()) {
             return null;
         }
         return sortedTimers.get(sortedTimers.size() - 1);
     }
 
     /**
-     * Sets the given timer to one-shot, ensuring that there is only one one-shot timer at a time.
-     * This is preferred over setting the timer property.
+     * Sets the given timer to one-shot, ensuring that there is only one one-shot timer at a time. This is preferred
+     * over setting the timer property.
      *
-     * @param name Name of the new one-shot timer
+     * @param name
+     *         name of the new one-shot timer
      */
     public void setOneShotTimer(String name) {
-        var oneShotTimer = this.timers.get(name);
+        TimerInfo<?, O> oneShotTimer = this.timers.get(name);
         if (oneShotTimer == null) {
             throw new IllegalArgumentException("Unknown one-shot timer name.");
         }
@@ -95,27 +128,25 @@ public void setOneShotTimer(String name) {
         }
 
         // update references
-        var newTimer = oneShotTimer.asOneShot();
+        TimerInfo<?, O> newTimer = oneShotTimer.asOneShot();
         this.timers.put(name, newTimer);
         this.sortedTimers.set(sortedTimers.size() - 1, newTimer);
     }
 
     /**
      * Returns a list of all timers defined in this location, sorted by their initial value.
      *
-     * @return List of local timers. Empty, if none.
+     * @return list of local timers, may be empty
      */
     public List<TimerInfo<?, O>> getSortedTimers() {
         return Collections.unmodifiableList(sortedTimers);
     }
 
     /**
-     * Returns an unmodifiable view of the timers defined for this location.
-     * Format: name -> info
+     * Returns an unmodifiable view of the timers defined for this location. Format: name -> info
      *
-     * @return Map of local timers. Empty, if none defined.
+     * @return map of local timers, may be empty
      */
-    @NonNull
     public Map<String, TimerInfo<?, O>> getLocalTimers() {
         return Collections.unmodifiableMap(this.timers);
     }

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

@@ -1,26 +1,44 @@
+/* Copyright (C) 2013-2025 TU Dortmund University
+ * This file is part of LearnLib <https://learnlib.de>.
+ *
+ * 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 de.learnlib.algorithm.lstar.mmlt;
 
-import de.learnlib.time.MMLTModelParams;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
 import de.learnlib.datastructure.observationtable.Row;
+import de.learnlib.time.MMLTModelParams;
 import net.automatalib.alphabet.Alphabet;
 import net.automatalib.symbol.time.TimedInput;
 import net.automatalib.symbol.time.TimedOutput;
 import net.automatalib.word.Word;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
 /**
- * Stores various data used for describing the MMLT hypothesis.
- * This includes the OT, a list of local resets, and a list of outputs.
+ * Stores various data used for describing the MMLT hypothesis. This includes the observation table, a list of local
+ * resets, and a list of outputs.
  *
- * @param <I> Input type for non-delaying inputs
- * @param <O> Output symbol type
+ * @param <I>
+ *         input symbol type (of non-delaying inputs)
+ * @param <O>
+ *         output symbol type
  */
 class MMLTHypDataContainer<I, O> {
+
     private final Alphabet<TimedInput<I>> alphabet;
 
     private final MMLTObservationTable<I, O> table;
@@ -29,7 +47,9 @@ class MMLTHypDataContainer<I, O> {
 
     private final MMLTModelParams<O> modelParams;
 
-    public MMLTHypDataContainer(Alphabet<TimedInput<I>> alphabet, MMLTModelParams<O> modelParams, MMLTObservationTable<I, O> table) {
+    MMLTHypDataContainer(Alphabet<TimedInput<I>> alphabet,
+                         MMLTModelParams<O> modelParams,
+                         MMLTObservationTable<I, O> table) {
         this.alphabet = alphabet;
         this.modelParams = modelParams;
         this.table = table;
@@ -38,35 +58,32 @@ public MMLTHypDataContainer(Alphabet<TimedInput<I>> alphabet, MMLTModelParams<O>
         this.transitionResetSet = new HashSet<>();
     }
 
-    @Nullable
-    protected TimedOutput<O> getTransitionOutput(Row<TimedInput<I>> stateRow, int inputIdx) {
+    @Nullable TimedOutput<O> getTransitionOutput(Row<TimedInput<I>> stateRow, int inputIdx) {
         Row<TimedInput<I>> transRow = stateRow.getSuccessor(inputIdx);
         if (transRow == null) {
             return null;
         }
 
-        return this.transitionOutputMap.getOrDefault(transRow.getLabel(), null);
+        return this.transitionOutputMap.get(transRow.getLabel());
     }
 
-
-    public MMLTModelParams<O> getModelParams() {
+    MMLTModelParams<O> getModelParams() {
         return modelParams;
     }
 
-    public Alphabet<TimedInput<I>> getAlphabet() {
+    Alphabet<TimedInput<I>> getAlphabet() {
         return alphabet;
     }
 
-
-    public MMLTObservationTable<I, O> getTable() {
+    MMLTObservationTable<I, O> getTable() {
         return table;
     }
 
-    public Map<Word<TimedInput<I>>, TimedOutput<O>> getTransitionOutputMap() {
+    Map<Word<TimedInput<I>>, TimedOutput<O>> getTransitionOutputMap() {
         return transitionOutputMap;
     }
 
-    public Set<Word<TimedInput<I>>> getTransitionResetSet() {
+    Set<Word<TimedInput<I>>> getTransitionResetSet() {
         return transitionResetSet;
     }
 }

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

@@ -1,3 +1,18 @@
+/* Copyright (C) 2013-2025 TU Dortmund University
+ * This file is part of LearnLib <https://learnlib.de>.
+ *
+ * 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 de.learnlib.algorithm.lstar.mmlt;
 
 import java.util.Map;
@@ -6,17 +21,16 @@
 import net.automatalib.automaton.mmlt.State;
 import net.automatalib.automaton.mmlt.SymbolCombiner;
 import net.automatalib.automaton.mmlt.impl.CompactMMLT;
-import net.automatalib.symbol.time.TimeStepSequence;
 import net.automatalib.symbol.time.TimedInput;
 import net.automatalib.word.Word;
 
 /**
  * An MMLT hypothesis that includes a prefix mapping. This mapping assigns a short prefix to each location.
  *
  * @param <I>
- *         Input type for non-delaying inputs
+ *         input symbol type (of non-delaying inputs)
  * @param <O>
- *         Output symbol type
+ *         output symbol type
  */
 public class MMLTHypothesis<I, O> extends CompactMMLT<I, O> {
 
@@ -42,16 +56,29 @@ public class MMLTHypothesis<I, O> extends CompactMMLT<I, O> {
      * @return Assigned prefix
      */
     public Word<TimedInput<I>> getPrefix(State<Integer, O> configuration) {
-        var locPrefix = getLocationPrefix(configuration);
+        Word<TimedInput<I>> locPrefix = getLocationPrefix(configuration);
         if (configuration.isEntryConfig()) {
             return locPrefix; // entry distance = 0
         } else {
-            return locPrefix.append(new TimeStepSequence<>(configuration.getEntryDistance()));
+            return locPrefix.append(TimedInput.step(configuration.getEntryDistance()));
         }
     }
 
+    /**
+     * Returns a prefix for the given location. This prefix is deterministic in the learner.
+     *
+     * @param location
+     *         Location
+     *
+     * @return Location prefix
+     */
+    public Word<TimedInput<I>> getPrefix(Integer location) {
+        return prefixMap.get(location);
+    }
+
     public Word<TimedInput<I>> getPrefix(Word<TimedInput<I>> prefix) {
-        var resultingConfig = getSemantics().getState(prefix);
+        State<Integer, O> resultingConfig = getSemantics().getState(prefix);
+        assert resultingConfig != null;
         return getPrefix(resultingConfig);
     }
 
@@ -64,20 +91,8 @@ public Word<TimedInput<I>> getPrefix(Word<TimedInput<I>> prefix) {
      * @return Assigned prefix
      */
     public Word<TimedInput<I>> getLocationPrefix(State<Integer, O> configuration) {
-        var locPrefix = this.prefixMap.get(configuration.getLocation());
-        if (locPrefix == null) {throw new AssertionError();}
+        Word<TimedInput<I>> locPrefix = this.prefixMap.get(configuration.getLocation());
+        assert locPrefix != null;
         return locPrefix;
     }
-
-    /**
-     * Returns a prefix for the given location. This prefix is deterministic in the RS learner.
-     *
-     * @param location
-     *         Location
-     *
-     * @return Location prefix
-     */
-    public Word<TimedInput<I>> getPrefix(Integer location) {
-        return prefixMap.get(location);
-    }
 }