Initial commit

Author: Zabuzard

.coursecreator/course/course.json

@@ -0,0 +1,162 @@
+# Created by https://www.toptal.com/developers/gitignore/api/netbeans,intellij,java,gradle,eclipse
+# Edit at https://www.toptal.com/developers/gitignore?templates=netbeans,intellij,java,gradle,eclipse
+
+### Eclipse ###
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# Java annotation processor (APT)
+.factorypath
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Annotation Processing
+.apt_generated/
+.apt_generated_test/
+
+# Uncomment this line if you wish to ignore the project description file.
+# Typically, this file would be tracked if it contains build/dependency configurations:
+#.project
+
+### Eclipse Patch ###
+# Spring Boot Tooling
+.sts4-cache/
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff (and .idea/, as we do not want to rely on that)
+.idea/
+*.iml
+*.ipr
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+### Intellij Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+
+### Java ###
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+### NetBeans ###
+**/nbproject/private/
+**/nbproject/Makefile-*.mk
+**/nbproject/Package-*.bash
+build/
+nbbuild/
+dist/
+nbdist/
+.nb-gradle/
+
+### Gradle ###
+.gradle
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Cache of project
+.gradletasknamecache
+
+# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
+# gradle/wrapper/gradle-wrapper.properties
+
+### Gradle Patch ###
+**/build/
+
+# Eclipse Gradle plugin generated files
+# Eclipse Core
+.project
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# End of https://www.toptal.com/developers/gitignore/api/netbeans,intellij,java,gradle,eclipse
+application/db/
+config.json
+application/config.json
+*.db
+*.db-shm
+*.db-wal
+logviewer/frontend/generated
+logviewer/node_modules
+logviewer/.npmrc
+logviewer/package.json
+logviewer/pnpmfile.js
+logviewer/tsconfig.json
+logviewer/types.d.ts
+logviewer/pnpm-lock.yaml
+logviewer/webpack.config.js
+logviewer/webpack.generated.js
+.DS_Store

.gitignore

@@ -0,0 +1,47 @@
+package org.togetherjava.event.elevator;
+
+import org.togetherjava.event.elevator.elevators.Elevator;
+import org.togetherjava.event.elevator.humans.Human;
+import org.togetherjava.event.elevator.simulation.Simulation;
+
+public final class Main {
+    /**
+     * Starts the application.
+     * <p>
+     * Will create an elevator-system simulation, execute it until it is done
+     * and pretty print the state to console.
+     *
+     * @param args Not supported
+     */
+    public static void main(final String[] args) {
+        // Select a desired simulation for trying out your code.
+        // Start with the simple simulations first, try out the bigger systems once you got it working.
+        // Eventually try out the randomly generated systems. If you want to debug a problem you encountered
+        // with one of them, note down the seed that it prints at the beginning and then use the variant that takes this seed.
+        // That way, it will generate the same system again, and you can repeat the test.
+        Simulation simulation = Simulation.createSingleElevatorSingleHumanSimulation();
+        // Simulation simulation = Simulation.createSimpleSimulation();
+        // Simulation simulation = Simulation.createRandomSimulation(5, 50, 10);
+        // Simulation simulation = Simulation.createRandomSimulation(putDesiredSeedHere, 5, 50, 10);
+
+        simulation.printSummary();
+
+        System.out.println("Starting simulation...");
+        simulation.start();
+        simulation.prettyPrint();
+
+        while (!simulation.isDone()) {
+            System.out.println("\tSimulation step " + simulation.getStepCount());
+            simulation.step();
+            simulation.prettyPrint();
+
+            if (simulation.getStepCount() >= 100_000) {
+                throw new IllegalStateException("Simulation aborted. All humans should have arrived"
+                        + " by now, but they did not. There is likely a bug in your code.");
+            }
+        }
+        System.out.println("Simulation is done.");
+
+        simulation.printResult();
+    }
+}

Contest/Assignment/src/org/togetherjava/event/elevator/Main.java

@@ -0,0 +1,90 @@
+package org.togetherjava.event.elevator.elevators;
+
+import java.util.StringJoiner;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A single elevator that can serve a given amount of floors.
+ * <p>
+ * An elevator can take floor requests from either humans or the elevator system itself.
+ * The elevator will eventually move towards the requested floor and transport humans to their destinations.
+ */
+public final class Elevator implements ElevatorPanel {
+    private static final AtomicInteger NEXT_ID = new AtomicInteger(0);
+
+    private final int id;
+    private final int minFloor;
+    private final int floorsServed;
+    private int currentFloor;
+
+    /**
+     * Creates a new elevator.
+     *
+     * @param minFloor     the minimum floor that the elevator can serve, must be greater equals 1
+     * @param floorsServed the amount of floors served in total by this elevator, must be greater equals 2.
+     *                     Together with the minFloor this forms a consecutive range of floors with no gaps in between.
+     * @param currentFloor the floor the elevator starts at, must be within the defined range of floors served by the elevator
+     */
+    public Elevator(int minFloor, int floorsServed, int currentFloor) {
+        if (minFloor <= 0 || floorsServed < 2) {
+            throw new IllegalArgumentException("Min floor must at least 1, floors served at least 2.");
+        }
+        if (currentFloor < minFloor || currentFloor >= minFloor + floorsServed) {
+            throw new IllegalArgumentException("The current floor must be between the floors served by the elevator.");
+        }
+
+        this.id = NEXT_ID.getAndIncrement();
+        this.minFloor = minFloor;
+        this.currentFloor = currentFloor;
+        this.floorsServed = floorsServed;
+    }
+
+    @Override
+    public int getId() {
+        return id;
+    }
+
+    public int getMinFloor() {
+        return minFloor;
+    }
+
+    public int getFloorsServed() {
+        return floorsServed;
+    }
+
+    @Override
+    public int getCurrentFloor() {
+        return currentFloor;
+    }
+
+    @Override
+    public void requestDestinationFloor(int destinationFloor) {
+        // TODO Implement. This represents a human or the elevator system
+        //  itself requesting this elevator to eventually move to the given floor.
+        //  The elevator is supposed to memorize the destination in a way that
+        //  it can ensure to eventually reach it.
+        System.out.println("Request for destination floor received");
+    }
+
+    public void moveOneFloor() {
+        // TODO Implement. Essentially there are three possibilities:
+        //  - move up one floor
+        //  - move down one floor
+        //  - stand still
+        //  The elevator is supposed to move in a way that it will eventually reach
+        //  the floors requested by Humans via requestDestinationFloor(), ideally "fast" but also "fair",
+        //  meaning that the average time waiting (either in corridor or inside the elevator)
+        //  is minimized across all humans.
+        //  It is essential that this method updates the currentFloor field accordingly.
+        System.out.println("Request to move a floor received");
+    }
+
+    @Override
+    public synchronized String toString() {
+        return new StringJoiner(", ", Elevator.class.getSimpleName() + "[", "]").add("id=" + id)
+                .add("minFloor=" + minFloor)
+                .add("floorsServed=" + floorsServed)
+                .add("currentFloor=" + currentFloor)
+                .toString();
+    }
+}

Contest/Assignment/src/org/togetherjava/event/elevator/elevators/Elevator.java

@@ -0,0 +1,28 @@
+package org.togetherjava.event.elevator.elevators;
+
+/**
+ * The system inside an elevator which provides information about the elevator and can be
+ * used to request a destination floor.
+ */
+public interface ElevatorPanel {
+    /**
+     * The unique ID of the elevator.
+     *
+     * @return the unique ID of the elevator
+     */
+    int getId();
+
+    /**
+     * The floor the elevator is currently at.
+     *
+     * @return the current floor
+     */
+    int getCurrentFloor();
+
+    /**
+     * Requesting the elevator to eventually move to the given destination floor, for humans to exit.
+     *
+     * @param destinationFloor the desired destination, must be within the range served by this elevator
+     */
+    void requestDestinationFloor(int destinationFloor);
+}

Contest/Assignment/src/org/togetherjava/event/elevator/elevators/ElevatorPanel.java

@@ -0,0 +1,49 @@
+package org.togetherjava.event.elevator.elevators;
+
+import org.togetherjava.event.elevator.humans.ElevatorListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * System controlling all elevators of a building.
+ * <p>
+ * Once all elevators and humans have been registered via {@link #registerElevator(Elevator)}
+ * and {@link #registerElevatorListener(ElevatorListener)} respectively,
+ * the system can be made ready using {@link #ready()}.
+ */
+public final class ElevatorSystem implements FloorPanelSystem {
+    private final List<Elevator> elevators = new ArrayList<>();
+    private final List<ElevatorListener> elevatorListeners = new ArrayList<>();
+
+    public void registerElevator(Elevator elevator) {
+        elevators.add(elevator);
+    }
+
+    public void registerElevatorListener(ElevatorListener listener) {
+        elevatorListeners.add(listener);
+    }
+
+    /**
+     * Upon calling this, the system is ready to receive elevator requests. Elevators may now start moving.
+     */
+    public void ready() {
+        elevatorListeners.forEach(listener -> listener.onElevatorSystemReady(this));
+    }
+
+    @Override
+    public void requestElevator(int atFloor, TravelDirection desiredTravelDirection) {
+        // TODO Implement. This represents a human standing in the corridor,
+        //  requesting that an elevator comes to pick them up for travel into the given direction.
+        //  The system is supposed to make sure that an elevator will eventually reach this floor to pick up the human.
+        //  The human can then enter the elevator and request their actual destination within the elevator.
+        //  Ideally this has to select the best elevator among all which can reduce the time
+        //  for the human spending waiting (either in corridor or in the elevator itself).
+        System.out.println("Request for elevator received");
+    }
+
+    public void moveOneFloor() {
+        elevators.forEach(Elevator::moveOneFloor);
+        elevators.forEach(elevator -> elevatorListeners.forEach(listener -> listener.onElevatorArrivedAtFloor(elevator)));
+    }
+}

Contest/Assignment/src/org/togetherjava/event/elevator/elevators/ElevatorSystem.java

@@ -0,0 +1,14 @@
+package org.togetherjava.event.elevator.elevators;
+
+/**
+ * The system in corridors that allows requesting elevators to the current floor.
+ */
+public interface FloorPanelSystem {
+    /**
+     * Requests an elevator to move to the given floor to pick up a human.
+     * @param atFloor the floor to pick up the human at, must be within the range served by the system
+     * @param desiredTravelDirection the direction the human wants to travel into,
+     *                               can be used for determination of the best elevator
+     */
+    void requestElevator(int atFloor, TravelDirection desiredTravelDirection);
+}