Fix matrix recurrent alterations using immutable block streams

2 files changed, 35 insertions, 29 deletions

diff --git a/src/ch/epfl/xblast/Lists.java b/src/ch/epfl/xblast/Lists.java
index bdcfb6a..1f2e1c7 100644
--- a/src/ch/epfl/xblast/Lists.java
+++ b/src/ch/epfl/xblast/Lists.java
@@ -58,6 +58,18 @@ public final class Lists {
     }
 
     /**
+     * Returns a copy of the given list surrounded with element e.
+     *
+     * @param l   the list
+     * @param e   the element to insert
+     * @param <T> the type of the list's elements
+     * @return a copy of the list with the element inserted at start and end
+     */
+    public static <T> List<T> surrounded(List<T> l, T e) {
+        return Lists.inserted(Lists.inserted(l, 0, e), l.size() + 1, e);
+    }
+
+    /**
      * Returns all the permutations of the elements of the given list
      *
      * @param l   given list
diff --git a/src/ch/epfl/xblast/server/Board.java b/src/ch/epfl/xblast/server/Board.java
index e449a00..bcb94a2 100644
--- a/src/ch/epfl/xblast/server/Board.java
+++ b/src/ch/epfl/xblast/server/Board.java
@@ -5,7 +5,10 @@ import ch.epfl.xblast.Cell;
 import ch.epfl.xblast.Lists;
 
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * A two-dimensional Board in which the game takes place.
@@ -40,8 +43,8 @@ public final class Board {
         if (matrix == null || matrix.size() != rows)
             throw new IllegalArgumentException();
 
-        for (int i = 0; i < rows; i++)
-            if (matrix.get(i).size() != columns)
+        for (List<Block> row : matrix)
+            if (row.size() != columns)
                 throw new IllegalArgumentException();
     }
 
@@ -71,14 +74,14 @@ public final class Board {
      * @throws IllegalArgumentException if rows is not BOARD_ROWS * BOARD_COLUMNS
      */
     public static Board ofRows(List<List<Block>> rows) {
-        checkBlockMatrix(rows, BOARD_ROWS, BOARD_COLUMNS);
-        List<Sq<Block>> blocksSequence = new ArrayList<>();
+        Board.checkBlockMatrix(rows, BOARD_ROWS, BOARD_COLUMNS);
 
-        for (List<Block> row : rows)
-            for (Block aRow : row)
-                blocksSequence.add(Sq.constant(aRow));
+        List<Sq<Block>> blockSequence = rows.stream()
+                .flatMap(Collection::stream)
+                .map(Sq::constant)
+                .collect(Collectors.toList());
 
-        return new Board(blocksSequence);
+        return new Board(blockSequence);
     }
 
     /**
@@ -89,24 +92,16 @@ public final class Board {
      * @throws IllegalArgumentException if innerBlocks is not INNER_BOARD_ROWS * INNER_BOARD_COLUMNS
      */
     public static Board ofInnerBlocksWalled(List<List<Block>> innerBlocks) {
-        checkBlockMatrix(innerBlocks, INNER_BOARD_ROWS, INNER_BOARD_COLUMNS);
-        List<List<Block>> rowsList = new ArrayList<>();
-        List<Block> wallLine = new ArrayList<>();
+        Board.checkBlockMatrix(innerBlocks, INNER_BOARD_ROWS, INNER_BOARD_COLUMNS);
 
-        for (int i = 0; i < BOARD_COLUMNS; i++)
-            wallLine.add(Block.INDESTRUCTIBLE_WALL);
+        List<List<Block>> innerRows = innerBlocks.stream()
+                .map(r -> Lists.surrounded(r, Block.INDESTRUCTIBLE_WALL))
+                .collect(Collectors.toList());
 
-        for (List<Block> row : innerBlocks) {
-            row.add(0, Block.INDESTRUCTIBLE_WALL);
-            row.add(Block.INDESTRUCTIBLE_WALL);
+        List<List<Block>> completeMatrix = Lists.surrounded(
+                innerRows, Collections.nCopies(BOARD_COLUMNS, Block.INDESTRUCTIBLE_WALL));
 
-            rowsList.add(row);
-        }
-
-        rowsList.add(0, wallLine);
-        rowsList.add(wallLine);
-
-        return ofRows(rowsList);
+        return Board.ofRows(completeMatrix);
     }
 
     /**
@@ -117,14 +112,13 @@ public final class Board {
      * @throws IllegalArgumentException if quadrantNWBlocks is not QUADRANT_ROWS * QUADRANT_COLUMNS
      */
     public static Board ofQuadrantNWBlocksWalled(List<List<Block>> quadrantNWBlocks) {
-        checkBlockMatrix(quadrantNWBlocks, QUADRANT_ROWS, QUADRANT_COLUMNS);
-        List<List<Block>> rowsList = new ArrayList<>();
-        List<List<Block>> halfInnerBoard = Lists.mirrored(quadrantNWBlocks);
+        Board.checkBlockMatrix(quadrantNWBlocks, QUADRANT_ROWS, QUADRANT_COLUMNS);
 
-        for (List<Block> aHalfInnerBoard : halfInnerBoard)
-            rowsList.add(Lists.mirrored(aHalfInnerBoard));
+        List<List<Block>> innerRows = Lists.mirrored(quadrantNWBlocks.stream()
+                .map(Lists::mirrored)
+                .collect(Collectors.toList()));
 
-        return Board.ofInnerBlocksWalled(rowsList);
+        return Board.ofInnerBlocksWalled(innerRows);
     }
 
     /**