Separate parsing geo format from fields API geo formats (#73806)

This change removes the current GeometryFormat interface and replace then with a GeometryParser that deals 
with Parsing formats and a GeometryFormatFactory that deals with fields API formats.

Author: iverase

modules/lang-painless/src/main/java/org/elasticsearch/painless/action/PainlessExecuteAction.java

@@ -36,10 +36,8 @@
 import org.elasticsearch.common.CheckedBiFunction;
 import org.elasticsearch.common.xcontent.ParseField;
 import org.elasticsearch.common.bytes.BytesReference;
-import org.elasticsearch.common.geo.GeoJsonGeometryFormat;
+import org.elasticsearch.common.geo.GeoFormatterFactory;
 import org.elasticsearch.common.geo.GeoPoint;
-import org.elasticsearch.common.geo.GeometryFormat;
-import org.elasticsearch.common.geo.GeometryParser;
 import org.elasticsearch.common.inject.Inject;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
@@ -94,6 +92,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.Function;
 
 import static java.util.Collections.emptyMap;
 import static org.elasticsearch.action.ValidateActions.addValidationError;
@@ -589,10 +588,10 @@ static Response innerShardOperation(Request request, ScriptService scriptService
                     List<GeoPoint> points = new ArrayList<>();
                     geoPointFieldScript.runGeoPointForDoc(0, gp -> points.add(new GeoPoint(gp)));
                     // convert geo points to the standard format of the fields api
-                    GeometryFormat<Geometry> gf = new GeometryParser(true, true, true).geometryFormat(GeoJsonGeometryFormat.NAME);
+                    Function<Geometry, Object> format = GeoFormatterFactory.getFormatter(GeoFormatterFactory.GEOJSON);
                     List<Object> objects = new ArrayList<>();
                     for (GeoPoint gp : points) {
-                        objects.add(gf.toXContentAsObject(new Point(gp.getLon(), gp.getLat())));
+                        objects.add(format.apply(new Point(gp.getLon(), gp.getLat())));
                     }
                     return new Response(objects);
                 }, indexService);

server/src/main/java/org/elasticsearch/common/geo/GeoFormatterFactory.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.common.geo;
+
+import org.elasticsearch.geometry.Geometry;
+import org.elasticsearch.geometry.utils.WellKnownText;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * Output formatters supported by geo fields.
+ */
+public class GeoFormatterFactory {
+
+    public static final String GEOJSON = "geojson";
+    public static final String WKT = "wkt";
+
+    private static final Map<String, Function<Geometry, Object>> FORMATTERS = new HashMap<>();
+    static {
+        FORMATTERS.put(GEOJSON, GeoJson::toMap);
+        FORMATTERS.put(WKT, WellKnownText::toWKT);
+    }
+
+    /**
+     * Returns a formatter by name
+     */
+    public static Function<Geometry, Object> getFormatter(String name) {
+        Function<Geometry, Object> format = FORMATTERS.get(name);
+        if (format == null) {
+            throw new IllegalArgumentException("Unrecognized geometry format [" + format + "].");
+        }
+        return format;
+    }
+}

server/src/main/java/org/elasticsearch/common/geo/GeoJsonGeometryFormat.java

@@ -27,56 +27,25 @@
 import java.util.Map;
 
 /**
- * An utility class with a geometry parser methods supporting different shape representation formats
+ * An utility class with to read geometries from a XContentParser or generic object.
  */
 public final class GeometryParser {
 
-    private final GeoJsonGeometryFormat jsonGeometryFormat;
-    private final WKTGeometryFormat wktGeometryFormat;
-    private final boolean ignoreZValue;
+    private final boolean rightOrientation, coerce, ignoreZValue;
+    private final GeometryValidator validator;
 
     public GeometryParser(boolean rightOrientation, boolean coerce, boolean ignoreZValue) {
-        final GeometryValidator validator = StandardValidator.instance(ignoreZValue);
-        jsonGeometryFormat = new GeoJsonGeometryFormat(validator, coerce, rightOrientation);
-        wktGeometryFormat = new WKTGeometryFormat(validator, coerce);
+        this.rightOrientation = rightOrientation;
+        this.coerce = coerce;
         this.ignoreZValue = ignoreZValue;
+        this.validator = StandardValidator.instance(ignoreZValue);
     }
 
     /**
      * Parses supplied XContent into Geometry
      */
     public Geometry parse(XContentParser parser) throws IOException, ParseException {
-        return geometryFormat(parser).fromXContent(parser);
-    }
-
-    /**
-     * Returns a geometry format object that can parse and then serialize the object back to the same format.
-     */
-    public GeometryFormat<Geometry> geometryFormat(String format) {
-        if (format.equals(GeoJsonGeometryFormat.NAME)) {
-            return jsonGeometryFormat;
-        } else if (format.equals(WKTGeometryFormat.NAME)) {
-            return wktGeometryFormat;
-        } else {
-            throw new IllegalArgumentException("Unrecognized geometry format [" + format + "].");
-        }
-    }
-
-    /**
-     * Returns a geometry format object that can parse and then serialize the object back to the same format.
-     * This method automatically recognizes the format by examining the provided {@link XContentParser}.
-     */
-    public GeometryFormat<Geometry> geometryFormat(XContentParser parser) {
-        if (parser.currentToken() == XContentParser.Token.START_OBJECT) {
-            return jsonGeometryFormat;
-        } else if (parser.currentToken() == XContentParser.Token.VALUE_STRING) {
-            return wktGeometryFormat;
-        } else if (parser.currentToken() == XContentParser.Token.VALUE_NULL) {
-            // We don't know the format of the original geometry - so going with default
-            return jsonGeometryFormat;
-        } else {
-            throw new ElasticsearchParseException("shape must be an object consisting of type and coordinates");
-        }
+        return GeometryParserFormat.geometryFormat(parser).fromXContent(validator, coerce, rightOrientation, parser);
     }
 
     /**

server/src/main/java/org/elasticsearch/common/geo/GeometryFormat.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.common.geo;
+
+import org.elasticsearch.ElasticsearchParseException;
+import org.elasticsearch.common.xcontent.ToXContent;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.geometry.Geometry;
+import org.elasticsearch.geometry.utils.GeometryValidator;
+import org.elasticsearch.geometry.utils.WellKnownText;
+
+import java.io.IOException;
+import java.text.ParseException;
+
+/**
+ * Supported formats to read/write JSON geometries.
+ */
+public enum GeometryParserFormat {
+
+    WKT {
+        @Override
+        public XContentBuilder toXContent(Geometry geometry, XContentBuilder builder, ToXContent.Params params) throws IOException {
+            if (geometry != null) {
+                return builder.value(WellKnownText.toWKT(geometry));
+            } else {
+                return builder.nullValue();
+            }
+        }
+
+        @Override
+        public Geometry fromXContent(GeometryValidator validator, boolean coerce, boolean rightOrientation, XContentParser parser)
+            throws IOException, ParseException {
+            if (parser.currentToken() == XContentParser.Token.VALUE_NULL) {
+                return null;
+            }
+            return WellKnownText.fromWKT(validator, coerce, parser.text());
+        }
+
+    },
+    GEOJSON {
+        @Override
+        public XContentBuilder toXContent(Geometry geometry, XContentBuilder builder, ToXContent.Params params) throws IOException {
+            if (geometry != null) {
+                return GeoJson.toXContent(geometry, builder, params);
+            } else {
+                return builder.nullValue();
+            }
+        }
+
+        @Override
+        public Geometry fromXContent(GeometryValidator validator, boolean coerce, boolean rightOrientation, XContentParser parser)
+            throws IOException, ParseException {
+            if (parser.currentToken() == XContentParser.Token.VALUE_NULL) {
+                return null;
+            }
+            return GeoJson.fromXContent(validator, coerce, rightOrientation, parser);
+        }
+    };
+
+    /**
+     * Serializes the geometry into its JSON representation
+     */
+    public abstract XContentBuilder toXContent(Geometry geometry, XContentBuilder builder, ToXContent.Params params) throws IOException;
+
+    /**
+     * Parser JSON representation of a geometry
+     */
+    public abstract Geometry fromXContent(GeometryValidator validator, boolean coerce, boolean rightOrientation, XContentParser parser)
+        throws IOException, ParseException;
+
+    /**
+     * Returns a geometry parser format object that can parse and then serialize the object back to the same format.
+     * This method automatically recognizes the format by examining the provided {@link XContentParser}.
+     */
+    public static GeometryParserFormat geometryFormat(XContentParser parser) {
+        switch (parser.currentToken()) {
+            case START_OBJECT:
+            case VALUE_NULL: // We don't know the format of the original geometry - so going with default
+                return GEOJSON;
+            case VALUE_STRING:  return WKT;
+            default: throw new ElasticsearchParseException("shape must be an object consisting of type and coordinates");
+        }
+    }
+}