BAEL-8198: code examples

Author: etrandafir93

patterns-modules/data-oriented-programming/pom.xml

@@ -11,16 +11,39 @@
 
     <parent>
         <groupId>com.baeldung</groupId>
-        <artifactId>parent-boot-2</artifactId>
-        <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-boot-2</relativePath>
+        <artifactId>patterns-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
     </parent>
 
-    <dependencies>
-    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>21</source>
+                    <target>21</target>
+                    <!-- Needed due to a bug with JDK 21, described here: https://issues.apache.org/jira/browse/MCOMPILER-546?page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel&focusedCommentId=17767513 -->
+                    <debug>false</debug>
+                    <compilerArgs>
+                        <arg>--enable-preview</arg>
+                    </compilerArgs>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <argLine>--enable-preview</argLine>
+                </configuration>
+            </plugin>
+
+        </plugins>
+    </build>
 
     <properties>
-        <java.version>21</java.version>
+        <maven.compiler.source.version>21</maven.compiler.source.version>
+        <maven.compiler.target.version>21</maven.compiler.target.version>
     </properties>
 
 </project>

patterns-modules/data-oriented-programming/src/main/java/com/baeldung/patterns/dataoriented/ScoringRules.java renamed to patterns-modules/data-oriented-programming/src/main/java/com/baeldung/patterns/ScoringRules.java

@@ -1,4 +1,4 @@
-package com.baeldung.patterns.dataoriented;
+package com.baeldung.patterns;
 
 import java.util.List;
 import java.util.Map;
@@ -10,6 +10,10 @@
 import static java.util.stream.Collectors.groupingBy;
 
 public class ScoringRules {
+
+	private ScoringRules() {
+	}
+
 	static int pairs(List<Integer> dices, int nrOfPairs) {
 		Map<Integer, Long> frequency = dices.stream()
 				.collect(groupingBy(identity(), counting()));
@@ -31,7 +35,7 @@ static int pairs(List<Integer> dices, int nrOfPairs) {
 				.sum();
 	}
 
-	public static Integer moreOfSameKind(List<Integer> roll, int nrOfDicesOfSameKind) {
+	static Integer moreOfSameKind(List<Integer> roll, int nrOfDicesOfSameKind) {
 		Map<Integer, Long> frequency = roll.stream()
 				.collect(groupingBy(identity(), counting()));
 
@@ -44,7 +48,7 @@ public static Integer moreOfSameKind(List<Integer> roll, int nrOfDicesOfSameKind
 				.orElse(0);
 	}
 
-	public static Integer specificValue(List<Integer> dices, Integer value) {
+	static Integer specificValue(List<Integer> dices, Integer value) {
 		return dices.stream()
 				.filter(value::equals)
 				.mapToInt(it -> it)

patterns-modules/data-oriented-programming/src/main/java/com/baeldung/patterns/Yahtzee.java

@@ -0,0 +1,74 @@
+package com.baeldung.patterns;
+
+
+import com.baeldung.patterns.data.Roll;
+import com.baeldung.patterns.data.Strategies;
+import com.baeldung.patterns.data.Strategies.*;
+import com.baeldung.patterns.data.Strategy;
+import com.baeldung.patterns.data.Turn;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+import static com.baeldung.patterns.ScoringRules.*;
+
+public class Yahtzee {
+
+	private Yahtzee() {
+	}
+
+	static Supplier<Integer> diceValueGenerator = () -> ThreadLocalRandom.current().nextInt(1, 7);
+
+	static Roll roll() {
+		List<Integer> dice = IntStream.rangeClosed(1, 5)
+				.mapToObj(__ -> randomDieValue())
+				.toList();
+		return new Roll(dice, 1);
+	}
+
+	static Roll rerollValues(Roll roll, Integer... values) {
+		List<Integer> valuesToReroll = new ArrayList<>(List.of(values));
+		if (roll.rollCount() >= 3) {
+			throw new IllegalStateException("You can re-roll 3 times at most.");
+		}
+		if (!new HashSet<>(roll.dice()).containsAll(valuesToReroll)) {
+			throw new IllegalStateException("You can re-roll dice values which are not from the original roll.");
+		}
+		List<Integer> newDice = roll.dice()
+				.stream()
+				.map(it -> {
+					if (!valuesToReroll.contains(it)) {
+						return it;
+					}
+					valuesToReroll.remove(it);
+					return randomDieValue();
+				}).toList();
+
+		return new Roll(newDice, roll.rollCount() + 1);
+	}
+
+	static Turn chooseStrategy(Roll roll, String strategyStr) {
+		Strategy strategy = Strategies.fromString(strategyStr);
+		return new Turn(roll, strategy);
+	}
+
+	static int score(Turn turn) {
+		var dices = turn.roll().dice();
+		return switch (turn.strategy()) {
+			case Ones __ -> specificValue(dices, 1);
+			case Twos __ -> specificValue(dices, 2);
+			case OnePair __ -> pairs(dices, 1);
+			case TwoPairs __ -> pairs(dices, 2);
+			case ThreeOfaKind __ -> moreOfSameKind(dices, 3);
+		};
+	}
+
+	private static Integer randomDieValue() {
+		return diceValueGenerator.get();
+	}
+
+}

patterns-modules/data-oriented-programming/src/main/java/com/baeldung/patterns/chess/ChessGamePlayback.java

@@ -0,0 +1,15 @@
+package com.baeldung.patterns.data;
+
+import java.util.Collections;
+import java.util.List;
+
+public record Roll(List<Integer> dice, int rollCount) {
+	public Roll {
+		if (dice.size() != 5)
+			throw new IllegalArgumentException("A Roll needs to have exactly 5 dice.");
+		if (dice.stream().anyMatch(die -> die < 1 || die > 6))
+			throw new IllegalArgumentException("Dice values should be between 1 and 6.");
+
+		dice = Collections.unmodifiableList(dice);
+	}
+}

patterns-modules/data-oriented-programming/src/main/java/com/baeldung/patterns/chess/tokens/Token.java

@@ -0,0 +1,29 @@
+package com.baeldung.patterns.data;
+
+public class Strategies {
+	public record Ones() implements Strategy {
+	}
+
+	public record Twos() implements Strategy {
+	}
+
+	public record OnePair() implements Strategy {
+	}
+
+	public record TwoPairs() implements Strategy {
+	}
+
+	public record ThreeOfaKind() implements Strategy {
+	}
+
+	public static Strategy fromString(String strategyString) {
+		return switch (strategyString) {
+			case "ONES" -> new Ones();
+			case "TWOS" -> new Twos();
+			case "ONE_PAIR" -> new OnePair();
+			case "TWO_PAIRS" -> new TwoPairs();
+			case "THREE_OF_A_KIND" -> new ThreeOfaKind();
+			default -> throw new IllegalStateException("Unknown strategy: " + strategyString);
+		};
+	}
+}

patterns-modules/data-oriented-programming/src/main/java/com/baeldung/patterns/chess/tokens/TokenFactory.java

@@ -0,0 +1,6 @@
+package com.baeldung.patterns.data;
+
+import static com.baeldung.patterns.data.Strategies.*;
+
+public sealed interface Strategy permits Ones, Twos, OnePair, TwoPairs, ThreeOfaKind {
+}