fixes, cleanups, convenience

Author: mtf90

commons/util/src/main/java/net/automatalib/commons/util/collections/PositiveIntSet.java

@@ -17,7 +17,6 @@
 
 import java.util.AbstractSet;
 import java.util.BitSet;
-import java.util.Iterator;
 import java.util.Set;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -79,16 +78,24 @@ public boolean contains(@Nullable Object o) {
             return false;
         }
 
-        return delegate.get((Integer) o);
+        return containsInt((Integer) o);
+    }
+
+    public boolean containsInt(int integer) {
+        return delegate.get(integer);
     }
 
     @Override
-    public Iterator<Integer> iterator() {
+    public BitSetIterator iterator() {
         return new BitSetIterator(delegate, immutable);
     }
 
     @Override
     public boolean add(Integer integer) {
+        return addInt(integer);
+    }
+
+    public boolean addInt(int integer) {
         if (immutable) {
             throw new UnsupportedOperationException("This is a read-only set-view");
         }
@@ -101,17 +108,20 @@ public boolean add(Integer integer) {
 
     @Override
     public boolean remove(@Nullable Object o) {
-        if (immutable) {
-            throw new UnsupportedOperationException("This is a read-only set-view");
-        }
-
         if (!(o instanceof Integer)) {
             return false;
         }
 
-        int asInt = (Integer) o;
-        boolean containedBefore = delegate.get(asInt);
-        delegate.clear(asInt);
+        return removeInt((Integer) o);
+    }
+
+    public boolean removeInt(int integer) {
+        if (immutable) {
+            throw new UnsupportedOperationException("This is a read-only set-view");
+        }
+
+        boolean containedBefore = delegate.get(integer);
+        delegate.clear(integer);
         return containedBefore;
     }
 

util/src/main/java/net/automatalib/util/automata/spa/SPAUtil.java

@@ -369,7 +369,7 @@ public static <I> boolean isRedundancyFree(SPAAlphabet<I> alphabet, ATRSequences
         final Alphabet<I> callAlphabet = alphabet.getCallAlphabet();
         return atrSequences.accessSequences.keySet().containsAll(callAlphabet) &&
                atrSequences.terminatingSequences.keySet().containsAll(callAlphabet) &&
-               atrSequences.terminatingSequences.keySet().containsAll(callAlphabet);
+               atrSequences.returnSequences.keySet().containsAll(callAlphabet);
     }
 
     /**

util/src/main/java/net/automatalib/util/graphs/traversal/GraphTraversal.java

@@ -59,7 +59,7 @@ public static <N, E, D> boolean traverse(TraversalOrder order,
                                              IndefiniteGraph<N, E> graph,
                                              N initialNode,
                                              GraphTraversalVisitor<N, E, D> vis) {
-        return traverse(order, graph, -1, Collections.singleton(initialNode), vis);
+        return traverse(order, graph, Collections.singleton(initialNode), vis);
     }
 
     public static <N, E, D> boolean traverse(TraversalOrder order,
@@ -166,14 +166,14 @@ public static <N, E, D> boolean depthFirst(IndefiniteGraph<N, E> graph,
     public static <N, E, D> boolean depthFirst(IndefiniteGraph<N, E> graph,
                                                N initNode,
                                                GraphTraversalVisitor<N, E, D> vis) {
-        return depthFirst(graph, -1, initNode, vis);
+        return depthFirst(graph, Collections.singleton(initNode), vis);
     }
 
     public static <N, E, D> boolean depthFirst(IndefiniteGraph<N, E> graph,
                                                int limit,
                                                N initNode,
                                                GraphTraversalVisitor<N, E, D> vis) {
-        return depthFirst(graph, Collections.singleton(initNode), vis);
+        return depthFirst(graph, limit, Collections.singleton(initNode), vis);
     }
 
     public static <N, E, D> boolean depthFirst(IndefiniteGraph<N, E> graph,
@@ -282,13 +282,13 @@ public static <N, E, D> boolean breadthFirst(IndefiniteGraph<N, E> graph,
     public static <N, E, D> boolean breadthFirst(IndefiniteGraph<N, E> graph,
                                                  N initialNode,
                                                  GraphTraversalVisitor<N, E, D> visitor) {
-        return breadthFirst(graph, -1, Collections.singleton(initialNode), visitor);
+        return breadthFirst(graph, Collections.singleton(initialNode), visitor);
     }
 
     public static <N, E, D> boolean dfs(IndefiniteGraph<N, E> graph,
                                         N initialNode,
                                         DFSVisitor<? super N, ? super E, D> visitor) {
-        return dfs(graph, -1, Collections.singleton(initialNode), visitor);
+        return dfs(graph, Collections.singleton(initialNode), visitor);
     }
 
     public static <N, E, D> boolean dfs(IndefiniteGraph<N, E> graph,

util/src/main/java/net/automatalib/util/graphs/traversal/GraphTraversalVisitor.java

@@ -47,7 +47,7 @@ public interface GraphTraversalVisitor<N, E, D> {
      * Called when the exploration of a node is started.
      *
      * @param node
-     *         the node which's exploration is about to be started
+     *         the node whose exploration is about to be started
      * @param data
      *         the user data associated with this node
      *
@@ -59,7 +59,7 @@ public interface GraphTraversalVisitor<N, E, D> {
      * Called when the exploration of a node is finished.
      *
      * @param node
-     *         the node which's exploration is being finished
+     *         the node whose exploration is being finished
      * @param inData
      *         the user data associated with this node
      */