Checkstyle and SonarQube

loopyinput.txt

@@ -14,6 +14,7 @@ add train 1 W3
 show train 1
 put train 1 at (0,0) in direction 1,0
 step 64
+step -64
 delete track 1
 delete track 2
 delete track 3

loopyoutput.txt

@@ -18,6 +18,7 @@ passenger coach W3 added to train 1
   (O)(O)      (O)(O)      (O)        (O)       (O)        (O)       (O)        (O)   
 OK
 Train 1 at (0,0)
+Train 1 at (0,0)
 Error, could not delete rail segment
 Error, could not delete rail segment
 Error, could not delete rail segment

src/edu/kit/informatik/model/ModelRailwaySimulation.java

@@ -13,6 +13,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Model railway simulation. Can simulate trains on a railway network.
@@ -109,12 +110,12 @@ public class ModelRailwaySimulation {
         String id = newEngine.getIdentifier();
         for (Engine engine : engines) {
             if (engine.getIdentifier().equals(id)) {
-                throw new InvalidInputException("identifier already used");
+                throw new InvalidInputException("engine identifier already used by engine");
             }
         }
         for (TrainSet trainSet : trainSets) {
             if (trainSet.getIdentifier().equals(id)) {
-                throw new InvalidInputException("identifier already used");
+                throw new InvalidInputException("engine identifier already used by train set");
             }
         }
         engines.add(newEngine);
@@ -128,18 +129,16 @@ public class ModelRailwaySimulation {
             Terminal.printLine("No engine exists");
         } else {
             engines.sort(Comparator.comparing(Engine::getIdentifier));
-            engine: for (Engine engine : engines) {
+            for (Engine engine : engines) {
-                for (Train train : trains.values()) {
+                Train train = trains.values().stream().filter(x -> x.contains(engine)).findFirst().orElse(null);
-                    int id = train.getIdentifier();
+                if (train != null) {
-                    if (train.contains(engine)) {
+                    Terminal.printLine(String.format("%s %s", train.getIdentifier(), engine));
-                        Terminal.printLine(String.format("%s %s", id, engine));
+                } else {
-                        continue engine;
-                    }
-                }
                     Terminal.printLine(String.format("none %s", engine));
                 }
             }
         }
+    }
 
     /**
      * Add a new coach to the simulation.
@@ -192,19 +191,18 @@ public class ModelRailwaySimulation {
         if (coaches.isEmpty()) {
             Terminal.printLine("No coach exists");
         } else {
-            coach: for (Integer identifier : coaches.keySet().stream().sorted().collect(Collectors.toList())) {
+            for (Integer identifier : coaches.keySet().stream().sorted().collect(Collectors.toList())) {
                 Coach coach = coaches.get(identifier);
-                for (Train train : trains.values()) {
+                Train train = trains.values().stream().filter(x -> x.contains(coach)).findFirst().orElse(null);
-                    if (train.contains(coach)) {
+                if (train != null) {
                     Terminal.printLine(String.format("%d %s %s %d %b %b",
                             coach.getNumericalIdentifier(), train.getIdentifier(), coach.getType(),
                             coach.getLength(), coach.hasCouplingFront(), coach.hasCouplingBack()));
-                        continue coach;
+                } else {
+                    Terminal.printLine(String.format("%d none %s %d %b %b", coach.getNumericalIdentifier(),
+                            coach.getType(), coach.getLength(), coach.hasCouplingFront(), coach.hasCouplingBack()));
                 }
             }
-                Terminal.printLine(String.format("%d none %s %d %b %b", coach.getNumericalIdentifier(), coach.getType(),
-                        coach.getLength(), coach.hasCouplingFront(), coach.hasCouplingBack()));
-            }
         }
     }
 
@@ -217,12 +215,12 @@ public class ModelRailwaySimulation {
         String id = newTrainSet.getIdentifier();
         for (Engine engine : engines) {
             if (engine.getIdentifier().equals(id)) {
-                throw new InvalidInputException("identifier already used");
+                throw new InvalidInputException("train set identifier already used by engine");
             }
         }
         for (TrainSet trainSet : trainSets) {
             if (trainSet.getIdentifier().equals(id)) {
-                throw new InvalidInputException("identifier already used");
+                throw new InvalidInputException("train set identifier already used by train set");
             }
         }
         trainSets.add(newTrainSet);
@@ -236,17 +234,16 @@ public class ModelRailwaySimulation {
             Terminal.printLine("No train-set exists");
         } else {
             trainSets.sort(Comparator.comparing(TrainSet::getIdentifier));
-            trainset: for (TrainSet trainSet : trainSets) {
+            for (TrainSet trainSet : trainSets) {
-                for (Train train : trains.values()) {
+                Train train = trains.values().stream().filter(x -> x.contains(trainSet)).findFirst().orElse(null);
-                    if (train.contains(trainSet)) {
+                if (train != null) {
                     Terminal.printLine(String.format("%s %s", train.getIdentifier(), trainSet));
-                        continue trainset;
+                } else {
-                    }
-                }
                     Terminal.printLine(String.format("none %s", trainSet));
                 }
             }
         }
+    }
 
     /**
      * Delete a rolling stock.
@@ -273,25 +270,13 @@ public class ModelRailwaySimulation {
     public RollingStock getRollingStock(final String id) {
         if (id.matches("W\\+?\\d+")) {
             int coachId = Integer.parseInt(id.substring(1));
-            for (Coach coach : coaches.values()) {
+            return coaches.get(coachId);
-                if (coach.getNumericalIdentifier() == coachId) {
-                    return coach;
-                }
-            }
         } else {
-            for (Engine engine : engines) {
+            return Stream.concat(engines.stream(), trainSets.stream())
-                if (engine.getIdentifier().equals(id)) {
+                    .filter(rollingStock -> rollingStock.getIdentifier().equals(id))
-                    return engine;
+                    .findFirst().orElse(null);
         }
     }
-            for (TrainSet trainSet : trainSets) {
-                if (trainSet.getIdentifier().equals(id)) {
-                    return trainSet;
-                }
-            }
-        }
-        return null;
-    }
 
     /**
      * Create a new train or add rolling stock to an existing train.
@@ -416,7 +401,7 @@ public class ModelRailwaySimulation {
     private List<HashSet<Train>> getStaticCollisions() {
         List<HashSet<Train>> collisions = new ArrayList<>();
         int maxId = trains.keySet().stream().max(Integer::compareTo).orElse(0);
-        train: for (int id1 = 1; id1 <= maxId; id1++) {
+        for (int id1 = 1; id1 <= maxId; id1++) {
             Train train1 = trains.get(id1);
             if (train1 == null || !train1.isPlaced()) {
                 continue;
@@ -434,17 +419,18 @@ public class ModelRailwaySimulation {
             }
             if (!collision.isEmpty()) {
                 // check for existing collision
-                for (HashSet<Train> otherCollision : collisions) {
+                Set<Train> otherCollision = collisions.stream()
-                    if (otherCollision.stream().anyMatch(collision::contains)) {
+                        .filter(x -> x.stream().anyMatch(collision::contains))
+                        .findFirst().orElse(null);
+                if (otherCollision != null) { // add to that collision
+                    otherCollision.add(train1);
                     otherCollision.addAll(collision);
-                        continue train;
+                } else { // create a new collision
-                    }
-                }
-                // else, create a new collision
                     collision.add(train1);
                     collisions.add(collision);
                 }
             }
+        }
         return collisions;
     }
 
@@ -532,25 +518,22 @@ public class ModelRailwaySimulation {
         }
         // perform step
         Map<Train, Set<Rail>> nextOccupiedRails = new HashMap<>();
-        for (Train train : trains.values()) {
+        trains.values().stream().filter(Train::isPlaced).forEach(train -> {
-            if (!train.isPlaced()) {
-                continue;
-            }
             Vector2D front = train.getFrontPosition();
             Vector2D position = train.getRearPosition();
             Vector2D direction = train.getRearDirection();
             Vector2D nextPosition = railNetwork.move(position, direction);
             if (nextPosition == null
-                    || train.isOnPosition(nextPosition) && !train.getFrontPosition().equals(nextPosition)) {
+                    || train.isOnPosition(nextPosition) && !train.getRearPosition().equals(train.getFrontPosition())) {
                 collisions.add(new HashSet<>(Arrays.asList(train)));
                 train.removeFromRails();
                 nextOccupiedRails.put(train, occupiedRails.get(train));
-                continue;
+            } else {
-            }
                 train.moveBackTo(railNetwork, nextPosition);
                 train.setDirection(front.subtract(train.getFrontPosition()));
                 nextOccupiedRails.put(train, train.getOccupiedRails());
             }
+        });
         // check for block collisions
         for (Train train : trains.values()) {
             if (!train.isPlaced() || collisions.stream().anyMatch(x -> x.contains(train))) {
@@ -610,26 +593,22 @@ public class ModelRailwaySimulation {
             List<Set<Train>> newCollisions = getCollisionsOfOneReverseStep();
             collisions.addAll(newCollisions);
         }
-        // (only one of the loops above actually runs)
+        // TODO (only one of the loops above actually runs)
-        train: for (int id : trains.keySet().stream().sorted().collect(Collectors.toList())) {
+        for (int id : trains.keySet().stream().sorted().collect(Collectors.toList())) {
             Train train = trains.get(id);
-            // print collision
+            Set<Train> collisionSet = collisions.stream()
-            for (Set<Train> collisionSet : collisions) {
+                    .filter(collision -> collision.contains(train))
-                if (!collisionSet.contains(train)) {
+                    .findFirst().orElse(null);
-                    continue;
+            if (collisionSet != null) { // print collision
-                }
                 int first = collisionSet.stream().min(Comparator.comparing(Train::getIdentifier)).get().getIdentifier();
                 if (train.getIdentifier() == first) { // only print each collision once
                     List<Train> collision = collisionSet.stream().sorted(Comparator.comparing(Train::getIdentifier))
                             .collect(Collectors.toList());
-                    Terminal.printLine("Crash of train " + String.join(",",
+                    Terminal.printLine("Crash of train " + String.join(",", collision.stream()
-                            collision.stream().map(
+                            .map(crashedTrain -> Integer.toString(crashedTrain.getIdentifier()))
-                                x -> Integer.toString(x.getIdentifier())).toArray(String[]::new)));
+                            .toArray(String[]::new)));
                 }
-                continue train;
+            } else if (train.isPlaced()) { // or position, if not in collision
-            }
-            // or position, if not in collision
-            if (train.isPlaced()) {
                 Terminal.printLine(String.format("Train %d at %s", train.getIdentifier(), train.getFrontPosition()));
             }
         }

src/edu/kit/informatik/model/RailwayNetwork.java

@@ -82,8 +82,8 @@ public class RailwayNetwork {
             if (startPossibleConnections == 2 || end1PossibleConnections == 2 || end2PossibleConnections == 2) {
                 throw new InvalidInputException("switch endpoint would connect to two other rails");
             }
-            for (Rail rail : rails.values()) {
+            if (rails.values().stream()
-                if (rail.canConnectTo(start) || rail.canConnectTo(end1) || rail.canConnectTo(end2)) {
+                    .anyMatch(rail -> rail.canConnectTo(start) || rail.canConnectTo(end1) || rail.canConnectTo(end2))) {
                 int id = getNextRailIdentifier();
                 if (id < 0) {
                     return -1;
@@ -91,11 +91,11 @@ public class RailwayNetwork {
                 Switch newSwitch = new Switch(start, end1, end2, id);
                 rails.put(id, newSwitch);
                 return newSwitch.getIdentifier();
-                }
+            } else {
-            }
                 throw new InvalidInputException("switch not connected to other rails");
             }
         }
+    }
 
     /**
      * Remove the specified rail from the rail network.
@@ -103,16 +103,12 @@ public class RailwayNetwork {
      * @return whether the rail could be successfully removed
      */
     public boolean removeRail(final int id) {
-        if (rails.isEmpty()) {
-            return false;
-        }
         Rail toRemove = rails.get(id);
         if (toRemove == null) {
             return false;
         }
-        Set<Rail> connectedRails = new HashSet<>();
 
-        // locate one other rail: TODO use rail.connectedrails
+        // locate one other rail: TODO use rail.connectedrails?
         Rail otherRail = null;
         for (Rail anotherRail : rails.values()) {
             if (anotherRail.getIdentifier() != id && anotherRail.canConnectToRail(toRemove)) {
@@ -121,15 +117,19 @@ public class RailwayNetwork {
             }
         }
 
+        // last rail left, can always remove
         if (otherRail == null) {
             rails.clear();
             return true;
         }
 
+        // check that rails would still be connected after removing this rail
+        Set<Rail> connectedRails = new HashSet<>();
         connectedRails.add(otherRail);
         Queue<Rail> toProcess = new LinkedList<>();
         toProcess.add(otherRail);
 
+        // basically breadth-first search, using a queue
         while (!toProcess.isEmpty()) {
             Rail connected = toProcess.poll();
 

src/edu/kit/informatik/ui/command/Command.java

@@ -15,9 +15,8 @@ public abstract class Command {
      * Apply this command to a model railway simulation.
      * @param simulation simulation to use
      * @throws InvalidInputException on invalid user input
-     * @throws IllegalStateException if the command is not yet initialized
      */
-    public abstract void apply(ModelRailwaySimulation simulation) throws InvalidInputException, IllegalStateException;
+    public abstract void apply(ModelRailwaySimulation simulation) throws InvalidInputException;
 
     /**
      * Parse user input into this command object.

testcoverage_output.txt

@@ -38,11 +38,11 @@ OK
 2
 OK
 Crash of train 2
-Error, identifier already used
+Error, engine identifier already used by engine
 T2-Epsilon
-Error, identifier already used
+Error, engine identifier already used by train set
-Error, identifier already used
+Error, train set identifier already used by train set
-Error, identifier already used
+Error, train set identifier already used by engine
 T2-Lambda
 train-set T2-Lambda added to train 3
          ++