Create deserialization utility in exp histo lib

Author: JonasKunz

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/ExponentialHistogramXContent.java

@@ -21,9 +21,15 @@
 
 package org.elasticsearch.exponentialhistogram;
 
+import org.elasticsearch.core.Types;
 import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xcontent.XContentParser;
 
 import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
 
 /**
  * Handles the serialization of an {@link ExponentialHistogram} to XContent.
@@ -101,4 +107,54 @@ private static void writeBuckets(XContentBuilder b, String fieldName, Exponentia
         b.endObject();
     }
 
+    /**
+     * Parses an {@link ExponentialHistogram} from the provided {@link XContentParser}.
+     * This method is neither optimized, nor does it do any validation of the parsed content.
+     * No estimation for missing sum/min/max is done.
+     * Therefore only intended for testing!
+     *
+     * @param xContent the serialized histogram to read
+     * @return the deserialized histogram
+     * @throws IOException if the XContentParser throws an IOException
+     */
+    public static ExponentialHistogram parseForTesting(XContentParser xContent) throws IOException {
+        return parseForTesting(xContent.map());
+    }
+
+    /**
+     * Parses an {@link ExponentialHistogram} from a {@link Map}.
+     * This method is neither optimized, nor does it do any validation of the parsed content.
+     * No estimation for missing sum/min/max is done.
+     * Therefore only intended for testing!
+     *
+     * @param xContent the serialized histogram as a map
+     * @return the deserialized histogram
+     */
+    public static ExponentialHistogram parseForTesting(Map<String, Object> xContent) {
+        int scale = ((Number) xContent.get(SCALE_FIELD)).intValue();
+        ExponentialHistogramBuilder builder = ExponentialHistogram.builder(scale, ExponentialHistogramCircuitBreaker.noop());
+
+        Map<String, Number> zero = Types.forciblyCast(xContent.getOrDefault(ZERO_FIELD, Collections.emptyMap()));
+        double zeroThreshold = zero.getOrDefault(ZERO_THRESHOLD_FIELD, 0).doubleValue();
+        long zeroCount = zero.getOrDefault(ZERO_COUNT_FIELD, 0).longValue();
+        builder.zeroBucket(ZeroBucket.create(zeroThreshold, zeroCount));
+
+        builder.sum(((Number) xContent.getOrDefault(SUM_FIELD, 0)).doubleValue());
+        builder.min(((Number) xContent.getOrDefault(MIN_FIELD, Double.NaN)).doubleValue());
+        builder.max(((Number) xContent.getOrDefault(MAX_FIELD, Double.NaN)).doubleValue());
+
+        parseBuckets(Types.forciblyCast(xContent.getOrDefault(NEGATIVE_FIELD, Collections.emptyMap())), builder::setNegativeBucket);
+        parseBuckets(Types.forciblyCast(xContent.getOrDefault(POSITIVE_FIELD, Collections.emptyMap())), builder::setPositiveBucket);
+
+        return builder.build();
+    }
+
+    private static void parseBuckets(Map<String, List<Number>> serializedBuckets, BiConsumer<Long, Long> bucketSetter) {
+        List<Number> indices = serializedBuckets.getOrDefault(BUCKET_INDICES_FIELD, Collections.emptyList());
+        List<Number> counts = serializedBuckets.getOrDefault(BUCKET_COUNTS_FIELD, Collections.emptyList());
+        assert indices.size() == counts.size();
+        for (int i = 0; i < indices.size(); i++) {
+            bucketSetter.accept(indices.get(i).longValue(), counts.get(i).longValue());
+        }
+    }
 }

libs/exponential-histogram/src/test/java/org/elasticsearch/exponentialhistogram/ExponentialHistogramXContentTests.java

@@ -23,6 +23,8 @@
 
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xcontent.XContentParser;
+import org.elasticsearch.xcontent.XContentParserConfiguration;
 import org.elasticsearch.xcontent.json.JsonXContent;
 
 import java.io.IOException;
@@ -62,18 +64,21 @@ public void testFullHistogram() {
                     + "}"
             )
         );
+        checkRoundTrip(histo);
     }
 
     public void testOnlyZeroThreshold() {
         ExponentialHistogram histo = createAutoReleasedHistogram(b -> b.scale(3).sum(1.1).zeroBucket(ZeroBucket.create(5.0, 0)));
         assertThat(toJson(histo), equalTo("{\"scale\":3,\"sum\":1.1,\"zero\":{\"threshold\":5.0}}"));
+        checkRoundTrip(histo);
     }
 
     public void testOnlyZeroCount() {
         ExponentialHistogram histo = createAutoReleasedHistogram(
             b -> b.zeroBucket(ZeroBucket.create(0.0, 7)).scale(2).sum(1.1).min(0).max(0)
         );
         assertThat(toJson(histo), equalTo("{\"scale\":2,\"sum\":1.1,\"min\":0.0,\"max\":0.0,\"zero\":{\"count\":7}}"));
+        checkRoundTrip(histo);
     }
 
     public void testOnlyPositiveBuckets() {
@@ -84,6 +89,7 @@ public void testOnlyPositiveBuckets() {
             toJson(histo),
             equalTo("{\"scale\":4,\"sum\":1.1,\"min\":0.5,\"max\":2.5,\"positive\":{\"indices\":[-1,2],\"counts\":[3,5]}}")
         );
+        checkRoundTrip(histo);
     }
 
     public void testOnlyNegativeBuckets() {
@@ -94,6 +100,7 @@ public void testOnlyNegativeBuckets() {
             toJson(histo),
             equalTo("{\"scale\":5,\"sum\":1.1,\"min\":-0.5,\"max\":-0.25,\"negative\":{\"indices\":[-1,2],\"counts\":[4,6]}}")
         );
+        checkRoundTrip(histo);
     }
 
     private static String toJson(ExponentialHistogram histo) {
@@ -105,4 +112,17 @@ private static String toJson(ExponentialHistogram histo) {
         }
     }
 
+    private static void checkRoundTrip(ExponentialHistogram histo) {
+        try (XContentBuilder builder = JsonXContent.contentBuilder()) {
+            ExponentialHistogramXContent.serialize(builder, histo);
+            String json = Strings.toString(builder);
+            try (XContentParser parser = JsonXContent.jsonXContent.createParser(XContentParserConfiguration.EMPTY, json)) {
+                ExponentialHistogram parsed = ExponentialHistogramXContent.parseForTesting(parser);
+                assertThat(parsed, equalTo(histo));
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
 }