commit aff4e4c693092660bafc6c9fcfa9a699b47e2d9c Author: Alexander Staeding Date: Mon Jun 28 23:54:52 2021 +0200 Initial Commit diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..d18605c --- /dev/null +++ b/.editorconfig @@ -0,0 +1,9 @@ +# Editor configuration, see https://editorconfig.org +root = true + +[*] +charset = utf-8 +indent_style = space +indent_size = 2 +insert_final_newline = true +trim_trailing_whitespace = true diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..92001f8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,84 @@ +### VS-Code ### +.vscode/ +*.code-workspace +.history/ + +### Intellij ### +.idea/ +*.iws +/out/ +*.iml +.idea_modules/ +atlassian-ide-plugin.xml + +### Eclipse ### +.metadata +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.settings/ +.loadpath +.recommenders +.externalToolBuilders/ +*.launch +.factorypath +.recommenders/ +.apt_generated/ +.project +.classpath + +### Linux ### +*~ +.fuse_hidden* +.directory +.Trash-* +.nfs* + +### macOS ### +.DS_Store +.AppleDouble +.LSOverride +Icon +._* +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### NetBeans ### +nbproject/private/ +build/ +nbbuild/ +dist/ +nbdist/ +.nb-gradle/ + +### Windows ### +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db +*.stackdump +[Dd]esktop.ini +$RECYCLE.BIN/ +*.lnk + +### Gradle ### +.gradle +/build/ +out/ +gradle-app.setting +!gradle-wrapper.jar +.gradletasknamecache diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 0000000..f591740 --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,40 @@ +import org.jagrkt.submitter.submit + +plugins { + java + application + id("org.jagrkt.submitter").version("0.3.1") +} + +submit { + assignmentId = "h07" // do not change assignmentId + studentId = null + firstName = null + lastName = null + // Optionally require tests for prepareSubmission task. Default is true + requireTests = true +} + +repositories { + mavenCentral() +} + +dependencies { + // JUnit only available in "test" source set (./src/test) + testImplementation("org.junit.jupiter:junit-jupiter:5.7.1") +} + +java { + sourceCompatibility = JavaVersion.VERSION_11 + targetCompatibility = JavaVersion.VERSION_11 +} + +application { + mainClass.set("h07.Main") +} + +tasks { + test { + useJUnitPlatform() + } +} diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000..e708b1c Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..1acc777 --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.1-all.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100644 index 0000000..8f89047 --- /dev/null +++ b/gradlew @@ -0,0 +1,184 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# 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 +# +# https://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. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ]; do + ls=$(ls -ld "$PRG") + link=$(expr "$ls" : '.*-> \(.*\)$') + if expr "$link" : '/.*' >/dev/null; then + PRG="$link" + else + PRG=$(dirname "$PRG")"/$link" + fi +done +SAVED="$(pwd)" +cd "$(dirname \"$PRG\")/" >/dev/null +APP_HOME="$(pwd -P)" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=$(basename "$0") + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn() { + echo "$*" +} + +die() { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$(uname)" in +CYGWIN*) + cygwin=true + ;; +Darwin*) + darwin=true + ;; +MINGW*) + msys=true + ;; +NONSTOP*) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ]; then + if [ -x "$JAVA_HOME/jre/sh/java" ]; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ]; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ]; then + MAX_FD_LIMIT=$(ulimit -H -n) + if [ $? -eq 0 ]; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ]; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ]; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ]; then + APP_HOME=$(cygpath --path --mixed "$APP_HOME") + CLASSPATH=$(cygpath --path --mixed "$CLASSPATH") + + JAVACMD=$(cygpath --unix "$JAVACMD") + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=$(find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null) + SEP="" + for dir in $ROOTDIRSRAW; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ]; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@"; do + CHECK=$(echo "$arg" | egrep -c "$OURCYGPATTERN" -) + CHECK2=$(echo "$arg" | egrep -c "^-") ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ]; then ### Added a condition + eval $(echo args$i)=$(cygpath --path --ignore --mixed "$arg") + else + eval $(echo args$i)="\"$arg\"" + fi + i=$(expr $i + 1) + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save() { + for i; do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/"; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..107acd3 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 0000000..358e835 --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1 @@ +rootProject.name = "AuD-2021-H07-Student" diff --git a/src/main/java/h07/Main.java b/src/main/java/h07/Main.java new file mode 100644 index 0000000..2d65760 --- /dev/null +++ b/src/main/java/h07/Main.java @@ -0,0 +1,7 @@ +package h07; + +public class Main { + public static void main(String[] args) { + System.out.println("Hello World!"); + } +} diff --git a/src/main/java/h07/algebra/Monoid.java b/src/main/java/h07/algebra/Monoid.java new file mode 100644 index 0000000..3c29c3d --- /dev/null +++ b/src/main/java/h07/algebra/Monoid.java @@ -0,0 +1,24 @@ +package h07.algebra; + +/** + * Modelliert eine binäre Operation über einem Datentypen mit neutralem Element. + * + * @param die Trägermenge des Monoids + */ +public interface Monoid { + /** + * Liefert das neutrale Element dieses Monoids. + * + * @return das neutrale Element dieses Monoids + */ + M zero(); + + /** + * Die Verknüpfung zweier Operanden durch das Monoid. + * + * @param a der erste Operand + * @param b der zweite Operand + * @return das Ergebnis der Verknüpfung beider Operanden + */ + M add(M a, M b); +} diff --git a/src/main/java/h07/algorithm/ShortestPathsAlgorithm.java b/src/main/java/h07/algorithm/ShortestPathsAlgorithm.java new file mode 100644 index 0000000..a1266bb --- /dev/null +++ b/src/main/java/h07/algorithm/ShortestPathsAlgorithm.java @@ -0,0 +1,14 @@ +package h07.algorithm; + +import h07.algebra.Monoid; +import h07.graph.DirectedGraph; +import h07.graph.Path; + +import java.util.Comparator; +import java.util.Map; + +public interface ShortestPathsAlgorithm { + Map> shortestPaths( + DirectedGraph graph, V startNode, + Monoid monoid, Comparator comparator); +} diff --git a/src/main/java/h07/experiment/RoadTrip.java b/src/main/java/h07/experiment/RoadTrip.java new file mode 100644 index 0000000..4688254 --- /dev/null +++ b/src/main/java/h07/experiment/RoadTrip.java @@ -0,0 +1,51 @@ +package h07.experiment; + +/* +import h07.algebra.IntegerAddition; +import h07.algorithm.Dijkstra; +import h07.graph.AdjacencyMatrixFactory; +*/ + +public class RoadTrip { + public static void main(String[] args) { + String[] nodes = { + "München", + "Augsburg", + "Karlsruhe", + "Erfurt", + "Nürnberg", + "Kassel", + "Würzburg", + "Stuttgart", + "Mannheim", + "Frankfurt" + }; + + Integer[][] adjacencyMatrix = { + {null, 84, null, null, 167, 502, null, null, null, null}, + {84, null, 250, null, null, null, null, null, null, null}, + {null, 250, null, null, null, null, null, null, 80, null}, + {null, null, null, null, null, null, 186, null, null, null}, + {167, null, null, null, null, null, 103, 183, null, null}, + {502, null, null, null, null, null, null, null, null, 173}, + {null, null, null, 186, 103, null, null, null, null, 217}, + {null, null, null, null, 183, null, null, null, null, null}, + {null, null, 80, null, null, null, null, null, null, 85}, + {null, null, null, null, null, 173, 217, null, 85, null} + }; + /* + var factory = new AdjacencyMatrixFactory<>(nodes, adjacencyMatrix); + var graph = factory.createDirectedGraph(); + + var dijkstra = new Dijkstra(); + var paths = dijkstra.shortestPaths( + graph, "Frankfurt", + new IntegerAddition(), + Comparator.naturalOrder()); + + // Sollte "Frankfurt -217-> Würzburg -103-> Nürnberg -167-> München" + // ausgeben. + System.out.println(paths.get("München")); + */ + } +} diff --git a/src/main/java/h07/graph/AbstractPath.java b/src/main/java/h07/graph/AbstractPath.java new file mode 100644 index 0000000..9347a7a --- /dev/null +++ b/src/main/java/h07/graph/AbstractPath.java @@ -0,0 +1,17 @@ +package h07.graph; + +abstract class AbstractPath implements Path { + @Override + public String toString() { + var traverser = traverser(); + var builder = new StringBuilder(traverser.getCurrentNode().toString()); + while (traverser.hasNextNode()) { + builder.append(" -"); + builder.append(traverser.getDistanceToNextNode()); + traverser.walkToNextNode(); + builder.append("-> "); + builder.append(traverser.getCurrentNode()); + } + return builder.toString(); + } +} diff --git a/src/main/java/h07/graph/DirectedGraph.java b/src/main/java/h07/graph/DirectedGraph.java new file mode 100644 index 0000000..a2e2cc3 --- /dev/null +++ b/src/main/java/h07/graph/DirectedGraph.java @@ -0,0 +1,108 @@ +package h07.graph; + +import java.util.Collection; + +/** + * Repräsentiert einen endlichen gerichteten Graphen mit gewichteten Kanten. + * + * @param der Typ der Knoten dieses Graphen + * @param der Typ der Kantengewichte dieses Graphen + */ +public interface DirectedGraph { + /** + * Liefert alle Knoten dieses Graphen als unveränderliche + * {@link java.util.Collection} von Knoten. + * + * @return eine unveränderliche {@link java.util.Collection} mit allen + * Knoten dieses Graphen als Elemente + */ + Collection getAllNodes(); + + /** + * Liefert die Kinder eines Knoten als unveränderliche + * {@link java.util.Collection} von Knoten. + * + * @param node der Knoten, dessen Kinder abgefragt werden sollen + * @return eine unveränderliche {@link java.util.Collection} mit den Kindern + * des übergebenen Knoten als Elemente + * @throws NullPointerException falls der übergebene Knoten {@code null} ist + * @throws java.util.NoSuchElementException falls der übergebene Knoten + * nicht in diesem Graphen existiert + */ + Collection getChildrenForNode(V node); + + /** + * Liefert das Gewicht der Kante zwischen zwei Knoten. + * + * @param from der Knoten, von dem die Kante ausgeht + * @param to der Knoten, auf den die Kante zeigt + * @return das Gewicht der Kante zwischen den beiden Knoten + * @throws NullPointerException falls für einen der beiden Knoten + * {@code null} als Parameter übergeben wird + * @throws java.util.NoSuchElementException falls einer der beiden Knoten + * nicht in diesem Graphen existiert oder falls keine Kante vom + * ersten zum zweiten Knoten existiert + */ + A getArcWeightBetween(V from, V to); + + /** + * Fügt diesem Graphen einen Knoten hinzu, der bisher noch nicht im Graphen + * enthalten ist. + * + * @param node der Knoten, der hinzugefügt werden soll + * @throws NullPointerException falls der hinzuzufügende Knoten {@code null} + * ist + * @throws IllegalArgumentException falls der übergebene Knoten bereits in + * diesem Graphen enthalten ist + * @throws UnsupportedOperationException falls das Hinzufügen von Knoten von + * diesem Graphen nicht unterstützt wird + */ + void addNode(V node); + + /** + * Entfernt einen Knoten aus diesem Graphen. + * Gleichzeitig werden alle vom zu entfernenden Knoten ausgehenden Kanten + * aus diesem Graphen gelöscht. + * + * @param node der Knoten, der entfernt werden soll + * @throws NullPointerException falls der zu entfernende Knoten {@code null} + * ist + * @throws java.util.NoSuchElementException falls der übergebene Knoten + * nicht in diesem Graphen enthalten ist + * @throws UnsupportedOperationException falls das Entfernen von Knoten von + * diesem Graphen nicht unterstützt wird + */ + void removeNode(V node); + + /** + * Verbindet zwei Knoten mit einer Kante. + * + * @param from der Knoten von dem aus die neue Kante ausgehen soll + * @param weight das Gewicht der neuen Kante + * @param to der Knoten, auf den die neue Kante zeigen soll + * @throws NullPointerException falls für einen der Parameter {@code null} + * übergeben wird + * @throws java.util.NoSuchElementException falls einer der beiden Knoten + * nicht in diesem Graphen existiert + * @throws IllegalArgumentException falls bereits eine Kante vom ersten zum + * zweiten Knoten existiert + * @throws UnsupportedOperationException falls das Hinzufügen von Kanten von + * diesem Graphen nicht unterstützt wird + */ + void connectNodes(V from, A weight, V to); + + /** + * Entfernt die bestehende Kante zwischen zwei Knoten. + * + * @param from der Knoten, von dem die zu löschende Kante ausgeht + * @param to der Knoten, auf den die zu löschende Kante zeigt + * @throws NullPointerException falls für einen der beiden Knoten + * {@code null} als Parameter übergeben wird + * @throws java.util.NoSuchElementException falls einer der beiden Knoten + * nicht in diesem Graphen existiert oder falls keine Kante vom + * ersten zum zweiten Knoten existiert + * @throws UnsupportedOperationException falls das Entfernen von Kanten von + * diesem Graphen nicht unterstützt wird + */ + void disconnectNodes(V from, V to); +} diff --git a/src/main/java/h07/graph/DirectedGraphFactory.java b/src/main/java/h07/graph/DirectedGraphFactory.java new file mode 100644 index 0000000..c8dc26b --- /dev/null +++ b/src/main/java/h07/graph/DirectedGraphFactory.java @@ -0,0 +1,16 @@ +package h07.graph; + +/** + * Eine abstrakte Fabrik zum Erzeugen von {@link DirectedGraph}-Objekten. + * + * @param der Typ der Knoten dieses Graphen + * @param der Typ der Kantengewichte dieses Graphen + */ +public interface DirectedGraphFactory { + /** + * Erzeugt einen {@link DirectedGraph}. + * + * @return der {@code DirectedGraph}, der von dieses Fabrik erzeugt wird. + */ + DirectedGraph createDirectedGraph(); +} diff --git a/src/main/java/h07/graph/Path.java b/src/main/java/h07/graph/Path.java new file mode 100644 index 0000000..ad7198e --- /dev/null +++ b/src/main/java/h07/graph/Path.java @@ -0,0 +1,138 @@ +package h07.graph; + +import java.util.Objects; + +/** + * Repräsentiert einen gewichteten Pfad als Teilmenge eines endlichen + * gerichteten Graphs. + * + * @param der Typ der Knoten dieses Pfades + * @param der Typ der Kantengewichte dieses Pfades + */ +public interface Path extends Iterable { + /** + * Dieses Interface ermöglicht das Traversieren eines gerichteten Pfades. + * Dabei läuft der {@code Traverser} von Knoten zu Knoten unter + * Berücksichtigung der Gewichte der Kanten zwischen den Knoten. + * Den Knoten, auf dem sich ein {@code Traverser} zu einem gegebenen + * Zeitpunkt befindet, nennen wir den aktuell betrachteten Knoten. + * + * @param der Typ der Knoten, über die dieser {@code Traverser} läuft + * @param der Typ der Gewichte der Kanten, die zwischen den einzelnen + * Knoten liegen + */ + interface Traverser { + /** + * Liefert den von diesem {@code Traverser} aktuell betrachteten Knoten. + * + * @return der aktuell betrachtete Knoten + */ + V getCurrentNode(); + + /** + * Liefert das Gewicht der Kante vom aktuell betrachteten Knoten zu + * seinem Nachfolgeknoten. + * + * @return die Distanz zum nächsten Knoten. + * @throws IllegalStateException falls es sich beim aktuell betrachteten + * Knoten um den letzten Knoten im Pfad dieses + * {@code Traverser}s handelt + */ + A getDistanceToNextNode(); + + /** + * @throws java.util.NoSuchElementException falls es sich beim aktuell + * betrachteten Knoten um den letzten Knoten im Pfad dieses + * {@code Traverser}s handelt. + */ + void walkToNextNode(); + + /** + * Zeigt an, ob der aktuell betrachtete Knoten einen Nachfolgeknoten + * besitzt. + * + * @return {@code true} genau dann, wenn es sich beim aktuell + * betrachteten Knoten nicht um den letzten Knoten im Pfad + * dieses {@code Traverser}s handelt + */ + boolean hasNextNode(); + } + + /** + * Liefert einen {@link Traverser}, mit dem sich dieser Pfad traversieren + * lässt. + * Beim aktuell betrachteten Knoten des {@code Traverser}s handelt es sich + * zunächst um den ersten Knoten in diesem Pfad. + * + * @return ein {@code Traverser} für diesen Pfad + */ + Traverser traverser(); + + /** + * Erzeugt einen neuen Pfad aus den Knoten und Kanten dieses Pfades und + * einem weiteren Knoten. + * Dieser wird durch eine neue Kante an den letzten Knoten dieses Pfades + * angehängt. + * Dieser Pfad wird durch diese Methode jedoch nicht verändert. + * + * @param node der Knoten, der im neuen Pfad an den letzten Knoten + * dieses Pfades angehängt werden soll + * @param distance das Gewicht der neuen Kante, mit der der neue Knoten mit + * dem letzten Knoten dieses Pfades verbunden werden soll + * @return eine Kopie dieses Pfades mit einem zusätzlichen Knoten + * @throws NullPointerException falls der neue Knoten oder das Gewicht der + * neuen Kante {@code null} ist + */ + Path concat(V node, A distance); + + /** + * Erzeugt einen gewichteten Pfad mit einem Knoten. + * + * @param v1 der erste Knoten im Pfad + * @param der Typ der Knoten des erzeugten Pfades + * @param der Typ der Kantengewichte erzeugten Pfades + * @return ein Pfad mit dem übergebenen Knoten + * @throws NullPointerException falls der Knoten {@code null} ist + */ + static Path of(V v1) { + throw new UnsupportedOperationException("Noch nicht implementiert."); + /* + Objects.requireNonNull(v1, "Der Knoten eines Pfades darf nicht null sein"); + return new PathImpl<>(v1); + */ + } + + /** + * Erzeugt einen gewichteten Pfad mit zwei Knoten. + * + * @param v1 der erste Knoten im Pfad + * @param w1 das Gewicht der Kante vom ersten zum zweiten Knoten + * @param v2 der zweite Knoten im Pfad + * @param der Typ der Knoten des erzeugten Pfades + * @param der Typ der Kantengewichte erzeugten Pfades + * @return ein Pfad mit den übergebenen Knoten und Kantengewichten + * @throws NullPointerException falls einer der Knoten oder eines der + * Kantengewichte {@code null} ist + */ + static Path of(V v1, A w1, V v2) { + return Path.of(v1).concat(v2, w1); + } + + /** + * Erzeugt einen gewichteten Pfad mit drei Knoten. + * + * @param v1 der erste Knoten im Pfad + * @param w1 das Gewicht der Kante vom ersten zum zweiten Knoten + * @param v2 der zweite Knoten im Pfad + * @param w2 das Gewicht der Kante vom zweiten zum dritten Knoten + * @param v3 der dritte Knoten im Pfad + * @param der Typ der Knoten des erzeugten Pfades + * @param der Typ der Kantengewichte erzeugten Pfades + * @return ein Pfad mit den übergebenen Knoten und Kantengewichten + * @throws NullPointerException falls einer der Knoten oder eines der + * Kantengewichte {@code null} ist + */ + static Path of(V v1, A w1, V v2, A w2, V v3) { + return Path.of(v1, w1, v2).concat(v3, w2); + } +} diff --git a/src/test/java/h07/ExampleJUnitTest.java b/src/test/java/h07/ExampleJUnitTest.java new file mode 100644 index 0000000..8f8f754 --- /dev/null +++ b/src/test/java/h07/ExampleJUnitTest.java @@ -0,0 +1,13 @@ +package h07; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class ExampleJUnitTest { + + @Test + public void testAddition() { + assertEquals(2, 1 + 1); + } +}