Publish subscribe

src/Event.java

@@ -0,0 +1,22 @@
+import java.util.HashMap;
+
+public class Event {
+    static HashMap<String, Subscribers> channels = new HashMap<>();
+
+    public static void publish(String channel, String message) {
+        if (!channels.containsKey(channel)) {
+            return;
+        }
+        Subscribers subscribers = channels.get(channel);
+        for (Subscriber subscriber : subscribers) {
+            subscriber.receive(message);
+        }
+    }
+
+    public static void subscribe(String channel, Subscriber subscriber) {
+        if (!channels.containsKey(channel)) {
+            channels.put(channel, new Subscribers());
+        }
+        channels.get(channel).add(subscriber);
+    }
+}

src/Game.java

@@ -1,18 +1,22 @@
 public class Game {
-    final Players players = new Players();
+    Players players;
     private Pile deck;
 
     /**
      * @param numberOfCards   Total number of cards
-     * @param numberOfPlayers Total number of players
+     * @param playerNumber Total number of players
      */
-    public Game(int numberOfCards, int numberOfPlayers) {
+    public Game(int numberOfCards, int playerNumber, Subscriber subscriber) {
+        players = new Players();
         deck = Pile.createDeck(numberOfCards);
-        int cardsPerPlayer = deck.size() / numberOfPlayers;
-        for (int i = 0; i < numberOfPlayers; i++) {
+        int cardsPerPlayer = deck.size() / playerNumber;
+        for (int i = 0; i < playerNumber; i++) {
             Player player = new Player(String.valueOf(i), deck.take(cardsPerPlayer));
             players.add(player);
         }
+        Event.subscribe("win", subscriber);
+        Event.subscribe("round", subscriber);
+        Event.subscribe("roundWin", subscriber);
     }
 
 

src/GameTest.java

@@ -5,12 +5,13 @@ import static org.junit.jupiter.api.Assertions.*;
 
 class GameTest {
     Game game;
+    Out subscriber = new Out();
 
     @org.junit.jupiter.api.Test
 
     @BeforeEach
     void setUp() {
-        game = new Game(10, 2);
+        game = new Game(10, 2, subscriber);
     }
 
     @Test

src/Main.java

@@ -9,8 +9,9 @@ public class Main {
      * @param args the input arguments
      */
     public static void main(String[] args) {
-        Game game = new Game(10, 2);
+        Subscriber subscriber = new Out();
+        Game game = new Game(10, 2, subscriber);
         game.players.play();
-        System.out.print(Out.get());
+        System.out.println(subscriber.toString());
     }
 }

src/Out.java

@@ -3,48 +3,28 @@ import java.util.ArrayList;
 /**
  * The type Out.
  */
-public class Out {
+public class Out implements Subscriber {
     /**
      * The Output.
      */
-    static final ArrayList<String> output = new ArrayList<>();
-
-    /**
-     * Instantiates a new Out.
-     */
-    protected Out() { throw new IllegalStateException("Utility class"); }
+    final ArrayList<String> output = new ArrayList<>();
 
     /**
      * Gets output.
      *
      * @return the output
      */
-    public static ArrayList<String> getOutput() {
+    public ArrayList<String> getOutput() {
         return output;
     }
 
-    /**
-     * Println.
-     *
-     * @param string the string
-     */
-    public static void println(String string) {
-        output.add(string);
-    }
-
-    /**
-     * Println.
-     */
-    public static void println() {
-        println("");
-    }
-
     /**
      * Get string.
      *
      * @return the string
      */
-    public static String get() {
+    @Override
+    public String toString() {
         StringBuilder string = new StringBuilder();
         for (String s : output) {
             string.append(s);
@@ -52,4 +32,8 @@ public class Out {
         }
         return string.toString();
     }
+
+    public void receive(String message) {
+        output.add(message);
+    }
 }

src/OutTest.java

@@ -3,18 +3,14 @@ import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 
 class OutTest {
+    Out out = new Out();
 
     @Test
     void printlnStoresString() {
-        Out.getOutput().clear();
-        Out.println();
-        assertEquals("\n", Out.get());
-        Out.println("Hello");
-        assertEquals("\nHello\n", Out.get());
-    }
-
-    @Test
-    void throwsException() {
-        assertThrows(IllegalStateException.class, Out::new);
+        out.getOutput().clear();
+        out.receive("");
+        assertEquals("\n", out.toString());
+        out.receive("Hello");
+        assertEquals("\nHello\n", out.toString());
     }
 }

src/Pile.java

@@ -66,7 +66,13 @@ public class Pile extends ArrayList<Card> {
      * @return the long
      */
     public long occurrences(int max) {
-        return IntStream.range(0, size()).filter(i -> get(i).number == max).count();
+        long count = 0L;
+        for (int i = 0; i < size(); i++) {
+            if (get(i).number == max) {
+                count++;
+            }
+        }
+        return count;
     }
 
     /**

src/Players.java

@@ -18,15 +18,15 @@ public class Players extends ArrayList<Player> {
                     String output = String.format("Player %s (%d cards)", player.name, player.cardsCount());
                     Card card = player.draw();
                     draws.add(card);
-                    Out.println(String.format("%s: %d - %s", output, card.number, card.suit));
+                    Event.publish("round", String.format("%s: %d - %s", output, card.number, card.suit));
                 }
                 pot.addAll(draws);
                 givePotOnWin();
             }
             if (size() == 0) {
-                Out.println("No winner in the game!");
+                Event.publish("win", "No winner in the game!");
             } else {
-                Out.println(String.format("Player %s wins the game!", get(0).name));
+                Event.publish("win", String.format("Player %s wins the game!", get(0).name));
             }
         }
     }
@@ -44,12 +44,11 @@ public class Players extends ArrayList<Player> {
         Card max = draws.getMax();
         if (draws.occurrences(max.number) == 1) {
             int maxIndex = draws.indexOf(max);
-            Out.println(String.format("Player %d wins this round", maxIndex));
+            Event.publish("roundWin", String.format("Player %d wins this round", maxIndex));
             this.get(maxIndex).discardPile.addAll(pot);
             pot.clear();
         } else {
-            Out.println("No winner in this round");
+            Event.publish("roundWin","No winner in this round");
         }
-        Out.println();
     }
 }

src/PlayersTest.java

@@ -4,25 +4,33 @@ import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 
 class PlayersTest {
+    Out subscriber = new Out();
+
     Players players = new Players();
 
     @BeforeEach
     void setUp() {
-        Out.getOutput().clear();
+        subscriber.getOutput().clear();
     }
 
     @Test
     void playForZeroPlayers() {
+        Event.subscribe("win", subscriber);
+        Event.subscribe("round", subscriber);
+        Event.subscribe("roundWin", subscriber);
         players.play();
-        assertEquals("", Out.get());
+        assertEquals("", subscriber.toString());
     }
 
     @Test
     void playForOnePlayerMakesHimAWinner() {
         Player player = new Player("0", Pile.createDeck(1));
         players.add(player);
+        Event.subscribe("win", subscriber);
+        Event.subscribe("round", subscriber);
+        Event.subscribe("roundWin", subscriber);
         players.play();
-        assertEquals("Player 0 wins the game!\n", Out.get());
+        assertEquals("Player 0 wins the game!\n", subscriber.toString());
     }
 
     @Test
@@ -31,9 +39,12 @@ class PlayersTest {
         players.add(player);
         player = new Player("1", Pile.createDeck(1));
         players.add(player);
+        Event.subscribe("win", subscriber);
+        Event.subscribe("round", subscriber);
+        Event.subscribe("roundWin", subscriber);
         players.play();
-        assertTrue(Out.get().contains("No winner in this round"));
-        assertTrue(Out.get().contains("No winner in the game!"));
+        assertTrue(subscriber.toString().contains("No winner in this round"));
+        assertTrue(subscriber.toString().contains("No winner in the game!"));
     }
 
     @Test
@@ -47,9 +58,12 @@ class PlayersTest {
         players.add(player);
         player = new Player("1", deck.take(2));
         players.add(player);
+        Event.subscribe("win", subscriber);
+        Event.subscribe("round", subscriber);
+        Event.subscribe("roundWin", subscriber);
         players.play();
-        assertTrue(Out.get().contains("Player 1 wins this round"));
-        assertTrue(Out.get().contains("Player 1 wins the game!"));
+        assertTrue(subscriber.toString().contains("Player 1 wins this round"));
+        assertTrue(subscriber.toString().contains("Player 1 wins the game!"));
     }
 
     @Test
@@ -63,10 +77,13 @@ class PlayersTest {
         players.add(player);
         player = new Player("1", deck.take(2));
         players.add(player);
+        Event.subscribe("win", subscriber);
+        Event.subscribe("round", subscriber);
+        Event.subscribe("roundWin", subscriber);
         players.play();
-        assertTrue(Out.get().contains("No winner in this round"));
-        assertTrue(Out.get().contains("Player 1 wins this round"));
-        assertTrue(Out.get().contains("Player 1 wins the game!"));
+        assertTrue(subscriber.toString().contains("No winner in this round"));
+        assertTrue(subscriber.toString().contains("Player 1 wins this round"));
+        assertTrue(subscriber.toString().contains("Player 1 wins the game!"));
         assertEquals("1", players.get(0).name);
         assertEquals(4, players.get(0).cardsCount());
     }

src/Subscriber.java

@@ -0,0 +1,5 @@
+public interface Subscriber {
+    void receive(String message);
+
+    String toString();
+}

src/Subscribers.java

@@ -0,0 +1,4 @@
+import java.util.HashSet;
+
+public class Subscribers extends HashSet<Subscriber> {
+}