arnekeller/kit-programmieren-ws1920-final1
1
0
Fork 0
mirror of https://gitlab.com/arnekeller/kit-programmieren-ws1920-final1.git synced 2024-11-24 01:15:05 +00:00
Code Issues Projects Releases Wiki Activity

Checkstyle and SonarQube

Browse Source
This commit is contained in:
Arne Keller 2020-02-19 23:54:33 +01:00
parent c40e635cb8
commit aa8f43b251
6 changed files with 79 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
loopyinput.txt
View File

@ -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

1
loopyoutput.txt
View File

@ -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

117
src/edu/kit/informatik/model/ModelRailwaySimulation.java
View File

@ -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 (Train train : trains.values()) {
int id = train.getIdentifier();
if (train.contains(engine)) {
Terminal.printLine(String.format("%s %s", id, engine));
continue engine;
}
}
for (Engine engine : engines) {
Train train = trains.values().stream().filter(x -> x.contains(engine)).findFirst().orElse(null);
if (train != null) {
Terminal.printLine(String.format("%s %s", train.getIdentifier(), engine));
} else {
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()) {
if (train.contains(coach)) {
Train train = trains.values().stream().filter(x -> x.contains(coach)).findFirst().orElse(null);
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 (Train train : trains.values()) {
if (train.contains(trainSet)) {
for (TrainSet trainSet : trainSets) {
Train train = trains.values().stream().filter(x -> x.contains(trainSet)).findFirst().orElse(null);
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()) {
if (coach.getNumericalIdentifier() == coachId) {
return coach;
}
}
return coaches.get(coachId);
} else {
for (Engine engine : engines) {
if (engine.getIdentifier().equals(id)) {
return engine;
return Stream.concat(engines.stream(), trainSets.stream())
.filter(rollingStock -> rollingStock.getIdentifier().equals(id))
.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) {
if (otherCollision.stream().anyMatch(collision::contains)) {
Set<Train> otherCollision = collisions.stream()
.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()) {
if (!train.isPlaced()) {
continue;
}
trains.values().stream().filter(Train::isPlaced).forEach(train -> {
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)
train: for (int id : trains.keySet().stream().sorted().collect(Collectors.toList())) {
// TODO (only one of the loops above actually runs)
for (int id : trains.keySet().stream().sorted().collect(Collectors.toList())) {
Train train = trains.get(id);
// print collision
for (Set<Train> collisionSet : collisions) {
if (!collisionSet.contains(train)) {
continue;
}
Set<Train> collisionSet = collisions.stream()
.filter(collision -> collision.contains(train))
.findFirst().orElse(null);
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(",",
collision.stream().map(
x -> Integer.toString(x.getIdentifier())).toArray(String[]::new)));
Terminal.printLine("Crash of train " + String.join(",", collision.stream()
.map(crashedTrain -> Integer.toString(crashedTrain.getIdentifier()))
.toArray(String[]::new)));
}
continue train;
}
// or position, if not in collision
if (train.isPlaced()) {
} else if (train.isPlaced()) { // or position, if not in collision
Terminal.printLine(String.format("Train %d at %s", train.getIdentifier(), train.getFrontPosition()));
}
}

18
src/edu/kit/informatik/model/RailwayNetwork.java
View File

@ -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 (rail.canConnectTo(start) || rail.canConnectTo(end1) || rail.canConnectTo(end2)) {
if (rails.values().stream()
.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();

3
src/edu/kit/informatik/ui/command/Command.java
View File

@ -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.

8
testcoverage_output.txt
View File

@ -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, identifier already used
Error, identifier already used
Error, engine identifier already used by train set
Error, train set identifier already used by train set
Error, train set identifier already used by engine
T2-Lambda
train-set T2-Lambda added to train 3
++