[dnm] sort stringified set elements

Stringified set elements are now outputted in sorted order according to
their stringified representation, where previously the output order was
determined by the record ordinals.

Note that this doesn't sort number elements correctly, e.g.,

```
"10"
"2"
```

Author: kvoli

hollow/src/main/java/com/netflix/hollow/tools/stringifier/HollowRecordJsonStringifier.java

@@ -40,6 +40,7 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -284,15 +285,28 @@ private void appendSetStringify(Writer writer, HollowDataAccess dataAccess, Holl
 
         int elementOrdinal = iter.next();
 
-        if (elementOrdinal == HollowOrdinalIterator.NO_MORE_ORDINALS) {
+
+        List<Integer> elementOrdinals = new java.util.ArrayList<>();
+        while (elementOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) {
+            elementOrdinals.add(elementOrdinal);
+            elementOrdinal = iter.next();
+        }
+
+        elementOrdinals.sort((o1, o2) -> {
+            String element1 = stringify(dataAccess, elementType, o1);
+            String element2 = stringify(dataAccess, elementType, o2);
+            return element1.compareTo(element2);
+        });
+
+        if (elementOrdinals.isEmpty()) {
             writer.append("[]");
         } else {
             boolean firstElement = true;
             writer.append("[");
             if (prettyPrint)
                 writer.append(NEWLINE);
 
-            while(elementOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) {
+            for (int ord : elementOrdinals) {
                 if (firstElement)
                     firstElement = false;
                 else
@@ -301,9 +315,7 @@ private void appendSetStringify(Writer writer, HollowDataAccess dataAccess, Holl
                 if (prettyPrint)
                     appendIndentation(writer, indentation);
 
-                appendStringify(writer, dataAccess, elementType, elementOrdinal, indentation);
-
-                elementOrdinal = iter.next();
+                appendStringify(writer, dataAccess, elementType, ord, indentation);
             }
 
             if (prettyPrint) {

hollow/src/main/java/com/netflix/hollow/tools/stringifier/HollowRecordStringifier.java

@@ -38,6 +38,7 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -184,15 +185,25 @@ private void appendSetStringify(Writer writer, HollowDataAccess dataAccess,
 
         int elementOrdinal = iter.next();
 
+        List<Integer> elementOrdinals = new java.util.ArrayList<>();
         while(elementOrdinal != NO_MORE_ORDINALS) {
+            elementOrdinals.add(elementOrdinal);
+            elementOrdinal = iter.next();
+        }
+
+        elementOrdinals.sort((o1, o2) -> {
+            String element1 = stringify(dataAccess, elementType, o1);
+            String element2 = stringify(dataAccess, elementType, o2);
+            return element1.compareTo(element2);
+        });
+
+        for (Integer sortedElementOrd : elementOrdinals) {
             writer.append(NEWLINE);
 
             appendIndentation(writer, indentation);
             writer.append("e: ");
 
-            appendStringify(writer, dataAccess, elementType, elementOrdinal, indentation);
-
-            elementOrdinal = iter.next();
+            appendStringify(writer, dataAccess, elementType, sortedElementOrd, indentation);
         }
     }
 

hollow/src/test/java/com/netflix/hollow/tools/stringifier/AbstractHollowRecordStringifierTest.java

@@ -24,6 +24,7 @@
 import com.netflix.hollow.core.write.objectmapper.HollowObjectMapper;
 import java.io.IOException;
 import java.io.StringWriter;
+import java.util.Set;
 
 /**
  * Code shared between HollowRecordStringifierTest and HollowRecordJsonStringifierTest.
@@ -73,6 +74,13 @@ public TypeWithNestedNonPrimitive(Double value, TypeWithNonPrimitive nestedType)
         }
     }
 
+    static class TypeWithSetOfPrimitives {
+        private final Set<TypeWithPrimitive> values;
+
+        public TypeWithSetOfPrimitives(Set<TypeWithPrimitive> values) {
+            this.values = values;
+        }
+    }
 
     /**
      * Sends instances of a type through the HollowRecordStringifier. This concatenates records

hollow/src/test/java/com/netflix/hollow/tools/stringifier/HollowRecordJsonStringifierTest.java

@@ -206,6 +206,20 @@ public void testStringifyStringWithEscapeChars() throws IOException {
                 stringifyType(TypeWithString.class, true, false, new TypeWithString(testString)));
     }
 
+    @Test
+    public void testStringifySetOfPrimitives() throws IOException {
+        // We expect that the set of primitives will be sorted and
+        Assert.assertEquals("Set of primitives should be printed correctly",
+                "[100,200,300]",
+                stringifyType(TypeWithSetOfPrimitives.class, false, false,
+                        new TypeWithSetOfPrimitives(
+                                new java.util.HashSet<>(Arrays.asList(
+                                        new TypeWithPrimitive(100),
+                                        new TypeWithPrimitive(300),
+                                        new TypeWithPrimitive(200)
+                                )))));
+    }
+
     private static <T> String stringifyType(Class<T> clazz, boolean prettyPrint, boolean expanded, T... instances) throws IOException {
         HollowRecordJsonStringifier stringifier = new HollowRecordJsonStringifier(prettyPrint, !expanded);
         // HollowRecordJsonStringifier stringifier = expanded

hollow/src/test/java/com/netflix/hollow/tools/stringifier/HollowRecordStringifierTest.java

@@ -135,6 +135,22 @@ public void testStringifyIterator() throws IOException {
                         "\n]", writer.toString());
     }
 
+    @Test
+    public void testStringifySetOfPrimitives() throws IOException {
+        // We expect that the set of primitives will be sorted and
+        Assert.assertEquals("Set of primitives should be printed correctly",
+                "\n  e: 100\n" +
+                        "  e: 200\n" +
+                        "  e: 300",
+                stringifyType(TypeWithSetOfPrimitives.class, false,
+                        new TypeWithSetOfPrimitives(
+                                new java.util.HashSet<>(Arrays.asList(
+                                        new TypeWithPrimitive(100),
+                                        new TypeWithPrimitive(300),
+                                        new TypeWithPrimitive(200)
+                                )))));
+    }
+
     private static <T> String stringifyType(Class<T> clazz, boolean expanded, T... instances) throws IOException {
         HollowRecordStringifier stringifier = expanded
             ? new HollowRecordStringifier(true, true, false) : new HollowRecordStringifier();