Refactor PartialJigsawInformation to JigsawInfo with builder pattern and type improvements

Author: zamora-carlos

exercises/practice/piecing-it-together/.meta/config.json

@@ -13,7 +13,7 @@
       ".meta/src/reference/java/PiecingItTogether.java"
     ],
     "editor": [
-      ".meta/src/reference/java/PartialJigsawInformation.java"
+      ".meta/src/reference/java/JigsawInfo.java"
     ]
   },
   "blurb": "Fill in missing jigsaw puzzle details from partial data",

exercises/practice/piecing-it-together/.meta/src/reference/java/JigsawInfo.java

@@ -0,0 +1,131 @@
+import java.util.Objects;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+
+/**
+ * Represents partial or complete information about a jigsaw puzzle,
+ *
+ * NOTE: There is no need to change this file and is treated as read only by the Exercism test runners.
+ */
+public class JigsawInfo {
+    private final OptionalInt pieces;
+    private final OptionalInt border;
+    private final OptionalInt inside;
+    private final OptionalInt rows;
+    private final OptionalInt columns;
+    private final OptionalDouble aspectRatio;
+    private final Optional<String> format;
+
+    private JigsawInfo(Builder builder) {
+        this.pieces = builder.pieces != null ? OptionalInt.of(builder.pieces) : OptionalInt.empty();
+        this.border = builder.border != null ? OptionalInt.of(builder.border) : OptionalInt.empty();
+        this.inside = builder.inside != null ? OptionalInt.of(builder.inside) : OptionalInt.empty();
+        this.rows = builder.rows != null ? OptionalInt.of(builder.rows) : OptionalInt.empty();
+        this.columns = builder.columns != null ? OptionalInt.of(builder.columns) : OptionalInt.empty();
+        this.aspectRatio = builder.aspectRatio != null ? OptionalDouble.of(builder.aspectRatio) : OptionalDouble.empty();
+        this.format = Optional.ofNullable(builder.format);
+    }
+
+    public static class Builder {
+        private Integer pieces;
+        private Integer border;
+        private Integer inside;
+        private Integer rows;
+        private Integer columns;
+        private Double aspectRatio;
+        private String format;
+
+        public Builder pieces(Integer pieces) {
+            this.pieces = pieces;
+            return this;
+        }
+
+        public Builder border(Integer border) {
+            this.border = border;
+            return this;
+        }
+
+        public Builder inside(Integer inside) {
+            this.inside = inside;
+            return this;
+        }
+
+        public Builder rows(Integer rows) {
+            this.rows = rows;
+            return this;
+        }
+
+        public Builder columns(Integer columns) {
+            this.columns = columns;
+            return this;
+        }
+
+        public Builder aspectRatio(Double aspectRatio) {
+            this.aspectRatio = aspectRatio;
+            return this;
+        }
+
+        public Builder format(String format) {
+            this.format = format;
+            return this;
+        }
+
+        public JigsawInfo build() {
+            return new JigsawInfo(this);
+        }
+    }
+
+    public OptionalInt getPieces() {
+        return pieces;
+    }
+
+    public OptionalInt getBorder() {
+        return border;
+    }
+
+    public OptionalInt getInside() {
+        return inside;
+    }
+
+    public OptionalInt getRows() {
+        return rows;
+    }
+
+    public OptionalInt getColumns() {
+        return columns;
+    }
+
+    public OptionalDouble getAspectRatio() {
+        return aspectRatio;
+    }
+
+    public Optional<String> getFormat() {
+        return format;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        JigsawInfo that = (JigsawInfo) o;
+        return Objects.equals(pieces, that.pieces) && Objects.equals(border, that.border) && Objects.equals(inside, that.inside) && Objects.equals(rows, that.rows) && Objects.equals(columns, that.columns) && Objects.equals(aspectRatio, that.aspectRatio) && Objects.equals(format, that.format);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(pieces, border, inside, rows, columns, aspectRatio, format);
+    }
+
+    @Override
+    public String toString() {
+        return "JigsawInfo{" +
+                "pieces=" + pieces +
+                ", border=" + border +
+                ", inside=" + inside +
+                ", rows=" + rows +
+                ", columns=" + columns +
+                ", aspectRatio=" + aspectRatio +
+                ", format=" + format +
+                '}';
+    }
+}

exercises/practice/piecing-it-together/.meta/src/reference/java/PartialJigsawInformation.java

@@ -1,22 +1,19 @@
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 
 public class PiecingItTogether {
     private final double epsilon = 1e-6;
 
-    public PartialJigsawInformation getCompleteInformation(PartialJigsawInformation input) {
-        Integer rows = input.getRows().orElse(null);
-        Integer cols = input.getColumns().orElse(null);
-        Integer pieces = input.getPieces().orElse(null);
-        Integer border = input.getBorder().orElse(null);
-        Integer inside = input.getInside().orElse(null);
-        Double aspect = input.getAspectRatio().orElse(null);
+    public JigsawInfo getCompleteInformation(JigsawInfo input) {
+        Integer rows = input.getRows().isPresent() ? input.getRows().getAsInt() : null;
+        Integer cols = input.getColumns().isPresent() ? input.getColumns().getAsInt() : null;
+        Integer pieces = input.getPieces().isPresent() ? input.getPieces().getAsInt() : null;
+        Integer border = input.getBorder().isPresent() ? input.getBorder().getAsInt() : null;
+        Integer inside = input.getInside().isPresent() ? input.getInside().getAsInt() : null;
+        Double aspect = input.getAspectRatio().isPresent() ? input.getAspectRatio().getAsDouble() : null;
         String format = input.getFormat().orElse(null);
 
         // Final information to be compared with the original input to detect inconsistencies
-        PartialJigsawInformation result = null;
+        JigsawInfo result = null;
 
         // Check format and aspect ratio don't contradict each other or set aspect if format is square
         if (format != null && aspect != null) {
@@ -77,7 +74,7 @@ public PartialJigsawInformation getCompleteInformation(PartialJigsawInformation
                 checkConsistencyOrThrow(result, input);
                 return result;
             } else if (inside != null && inside == 0) {
-                List<PartialJigsawInformation> validGuesses = new ArrayList<>();
+                List<JigsawInfo> validGuesses = new ArrayList<>();
 
                 for (int fixed : List.of(1, 2)) {
                     tryGuessWithFixedSide(fixed, true, aspect, input).ifPresent(validGuesses::add);  // rows = fixed
@@ -99,7 +96,7 @@ public PartialJigsawInformation getCompleteInformation(PartialJigsawInformation
         }
 
         // Brute force as a last resort
-        List<PartialJigsawInformation> validGuesses = new ArrayList<>();
+        List<JigsawInfo> validGuesses = new ArrayList<>();
 
         // Brute-force using pieces
         if (pieces != null) {
@@ -220,14 +217,22 @@ private Optional<Integer> calculateOtherSide(int knownSide, boolean isRowKnown,
         return Optional.empty();
     }
 
-    private PartialJigsawInformation fromRowsAndCols(int rows, int cols) {
+    private JigsawInfo fromRowsAndCols(int rows, int cols) {
         int pieces = rows * cols;
         int border = (rows == 1 || cols == 1) ? pieces : 2 * (rows + cols - 2);
         int inside = pieces - border;
         double aspect = (double) cols / rows;
         String format = getFormatFromAspect(aspect);
 
-        return new PartialJigsawInformation(pieces, border, inside, rows, cols, aspect, format);
+        return new JigsawInfo.Builder()
+                .pieces(pieces)
+                .border(border)
+                .inside(inside)
+                .rows(rows)
+                .columns(cols)
+                .aspectRatio(aspect)
+                .format(format)
+                .build();
     }
 
     /**
@@ -239,7 +244,7 @@ private PartialJigsawInformation fromRowsAndCols(int rows, int cols) {
      * @param input    the original partial input with possibly known values
      * @throws IllegalArgumentException if any known value in the input conflicts with the computed result
      */
-    public void checkConsistencyOrThrow(PartialJigsawInformation computed, PartialJigsawInformation input) {
+    public void checkConsistencyOrThrow(JigsawInfo computed, JigsawInfo input) {
         if (!valuesMatch(computed.getPieces(), input.getPieces()) || !valuesMatch(computed.getBorder(), input.getBorder()) || !valuesMatch(computed.getInside(), input.getInside()) || !valuesMatch(computed.getRows(), input.getRows()) || !valuesMatch(computed.getColumns(), input.getColumns()) || !valuesMatch(computed.getAspectRatio(), input.getAspectRatio()) || !valuesMatch(computed.getFormat(), input.getFormat())) {
             throw new IllegalArgumentException("Contradictory data");
         }
@@ -255,14 +260,14 @@ public void checkConsistencyOrThrow(PartialJigsawInformation computed, PartialJi
      * @param input      the original input to check for consistency
      * @return an Optional containing a valid inferred configuration, or empty if the guess is invalid
      */
-    private Optional<PartialJigsawInformation> tryGuessWithFixedSide(int fixed, boolean isRowFixed, double aspect, PartialJigsawInformation input) {
+    private Optional<JigsawInfo> tryGuessWithFixedSide(int fixed, boolean isRowFixed, double aspect, JigsawInfo input) {
         try {
             int other = isRowFixed ? roundIfClose(fixed * aspect) : roundIfClose(fixed / aspect);
 
             int rows = isRowFixed ? fixed : other;
             int cols = isRowFixed ? other : fixed;
 
-            PartialJigsawInformation guess = fromRowsAndCols(rows, cols);
+            JigsawInfo guess = fromRowsAndCols(rows, cols);
             checkConsistencyOrThrow(guess, input);
             return Optional.of(guess);
         } catch (IllegalArgumentException ignored) {
@@ -279,9 +284,9 @@ private Optional<PartialJigsawInformation> tryGuessWithFixedSide(int fixed, bool
      * @param input the original input to check for consistency
      * @return an Optional containing a valid configuration, or empty if inconsistent
      */
-    private Optional<PartialJigsawInformation> tryGuess(int rows, int cols, PartialJigsawInformation input) {
+    private Optional<JigsawInfo> tryGuess(int rows, int cols, JigsawInfo input) {
         try {
-            PartialJigsawInformation guess = fromRowsAndCols(rows, cols);
+            JigsawInfo guess = fromRowsAndCols(rows, cols);
             checkConsistencyOrThrow(guess, input);
             return Optional.of(guess);
         } catch (IllegalArgumentException ignored) {
@@ -306,4 +311,20 @@ private <T> boolean valuesMatch(Optional<T> a, Optional<T> b) {
 
         return true;
     }
+
+    private boolean valuesMatch(OptionalInt a, OptionalInt b) {
+        if (a.isPresent() && b.isPresent()) {
+            return a.getAsInt() == b.getAsInt();
+        }
+
+        return true;
+    }
+
+    private boolean valuesMatch(OptionalDouble a, OptionalDouble b) {
+        if (a.isPresent() && b.isPresent()) {
+            return Double.compare(a.getAsDouble(), b.getAsDouble()) == 0;
+        }
+
+        return true;
+    }
 }