Add sorted set and map methods to BuilderRef

This adds static methods to BuilderRef for creating sorted maps
and sets, including an optional custom comparator.

Author: JordonPhillips

smithy-utils/src/main/java/software/amazon/smithy/utils/BuilderRef.java

@@ -6,13 +6,16 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
 
 /**
  * Manages the creation, copying, and reuse of values created by builders.
@@ -105,6 +108,40 @@ static <K, V> BuilderRef<Map<K, V>> forOrderedMap() {
                 Collections::emptyMap);
     }
 
+    /**
+     * Creates a builder reference to a sorted map.
+     *
+     * @param <K> Type of key of the map.
+     * @param <V> Type of value of the map.
+     * @return Returns the created map.
+     */
+    static <K, V> BuilderRef<Map<K, V>> forSortedMap() {
+        return new DefaultBuilderRef<>(TreeMap::new,
+                TreeMap::new,
+                Collections::unmodifiableMap,
+                Collections::emptyMap);
+    }
+
+    /**
+     * Creates a builder reference to a sorted map with a custom comparator.
+     *
+     * @param <K> Type of key of the map.
+     * @param <V> Type of value of the map.
+     * @param comparator A comparator used to sort entries in the map.
+     * @return Returns the created map.
+     */
+    static <K, V> BuilderRef<Map<K, V>> forSortedMap(Comparator<K> comparator) {
+        return new DefaultBuilderRef<>(
+                () -> new TreeMap<>(comparator),
+                source -> {
+                    Map<K, V> copy = new TreeMap<>(comparator);
+                    copy.putAll(source);
+                    return copy;
+                },
+                Collections::unmodifiableMap,
+                Collections::emptyMap);
+    }
+
     /**
      * Creates a builder reference to a list.
      *
@@ -143,4 +180,36 @@ static <T> BuilderRef<Set<T>> forOrderedSet() {
                 Collections::unmodifiableSet,
                 Collections::emptySet);
     }
+
+    /**
+     * Creates a builder reference to a sorted set.
+     *
+     * @param <T> Type of value in the set.
+     * @return Returns the created set.
+     */
+    static <T> BuilderRef<Set<T>> forSortedSet() {
+        return new DefaultBuilderRef<>(TreeSet::new,
+                TreeSet::new,
+                Collections::unmodifiableSet,
+                Collections::emptySet);
+    }
+
+    /**
+     * Creates a builder reference to a sorted set.
+     *
+     * @param <T> Type of value in the set.
+     * @param comparator A comparator used to sort items in the set.
+     * @return Returns the created set.
+     */
+    static <T> BuilderRef<Set<T>> forSortedSet(Comparator<T> comparator) {
+        return new DefaultBuilderRef<>(
+                () -> new TreeSet<>(comparator),
+                source -> {
+                    Set<T> copy = new TreeSet<>(comparator);
+                    copy.addAll(source);
+                    return copy;
+                },
+                Collections::unmodifiableSet,
+                Collections::emptySet);
+    }
 }

smithy-utils/src/test/java/software/amazon/smithy/utils/BuilderRefTest.java

@@ -6,10 +6,13 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.containsInRelativeOrder;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.not;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import org.junit.jupiter.api.Test;
 
 public class BuilderRefTest {
@@ -85,4 +88,36 @@ public void tracksIfHasValue() {
 
         assertThat(strings.hasValue(), equalTo(false));
     }
+
+    @Test
+    public void createsSortedMaps() {
+        BuilderRef<Map<String, String>> sortedMap = BuilderRef.forSortedMap();
+        sortedMap.get().put("c", "d");
+        sortedMap.get().put("a", "b");
+        assertThat(sortedMap.peek().keySet(), containsInRelativeOrder("a", "c"));
+    }
+
+    @Test
+    public void createsSortedMapsWithCustomComparator() {
+        BuilderRef<Map<String, String>> sortedMap = BuilderRef.forSortedMap(String.CASE_INSENSITIVE_ORDER);
+        sortedMap.get().put("C", "d");
+        sortedMap.get().put("a", "b");
+        assertThat(sortedMap.peek().keySet(), containsInRelativeOrder("a", "C"));
+    }
+
+    @Test
+    public void createsSortedSets() {
+        BuilderRef<Set<String>> sortedSet = BuilderRef.forSortedSet();
+        sortedSet.get().add("b");
+        sortedSet.get().add("a");
+        assertThat(sortedSet.peek(), containsInRelativeOrder("a", "b"));
+    }
+
+    @Test
+    public void createsSortedSetsWithCustomComparator() {
+        BuilderRef<Set<String>> sortedSet = BuilderRef.forSortedSet(String.CASE_INSENSITIVE_ORDER);
+        sortedSet.get().add("B");
+        sortedSet.get().add("a");
+        assertThat(sortedSet.peek(), containsInRelativeOrder("a", "B"));
+    }
 }