@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

package/geos.xcframework/ios-arm64_arm64e/Headers/geos/geom/Geometry.h

@@ -1,1051 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2009 2011 Sandro Santilli <strk@kbt.io>
- * Copyright (C) 2005 2006 Refractions Research Inc.
- * Copyright (C) 2001-2002 Vivid Solutions Inc.
- *
- * This is free software; you can redistribute and/or modify it under
- * the terms of the GNU Lesser General Public Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************
- *
- * Last port: geom/Geometry.java rev. 1.112
- *
- **********************************************************************/
-
-#pragma once
-
-#ifndef USE_UNSTABLE_GEOS_CPP_API
-#ifndef _MSC_VER
-# warning "The GEOS C++ API is unstable, please use the C API instead"
-# warning "HINT: #include geos_c.h"
-#else
-#pragma message("The GEOS C++ API is unstable, please use the C API instead")
-#pragma message("HINT: #include geos_c.h")
-#endif
-#endif
-
-#include <geos/export.h>
-#include <geos/geom/Envelope.h>
-#include <geos/geom/Dimension.h> // for Dimension::DimensionType
-#include <geos/geom/GeometryComponentFilter.h> // for inheritance
-#include <geos/geom/CoordinateSequence.h> // to materialize CoordinateSequence
-
-#include <algorithm>
-#include <string>
-#include <iostream>
-#include <vector>
-#include <memory>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
-#pragma warning(disable: 4355) // warning C4355: 'this' : used in base member initializer list
-#endif
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class CoordinateFilter;
-class CoordinateSequence;
-class CoordinateSequenceFilter;
-class GeometryComponentFilter;
-class GeometryFactory;
-class GeometryFilter;
-class PrecisionModel;
-class Point;
-class IntersectionMatrix;
-}
-namespace io { // geos.io
-class Unload;
-} // namespace geos.io
-}
-
-namespace geos { // geos
-namespace geom { // geos::geom
-
-/// Geometry types
-enum GeometryTypeId : int {
-    /// a point
-    GEOS_POINT,
-    /// a linestring
-    GEOS_LINESTRING,
-    /// a linear ring (linestring with 1st point == last point)
-    GEOS_LINEARRING,
-    /// a polygon
-    GEOS_POLYGON,
-    /// a collection of points
-    GEOS_MULTIPOINT,
-    /// a collection of linestrings
-    GEOS_MULTILINESTRING,
-    /// a collection of polygons
-    GEOS_MULTIPOLYGON,
-    /// a collection of heterogeneus geometries
-    GEOS_GEOMETRYCOLLECTION,
-    GEOS_CIRCULARSTRING,
-    GEOS_COMPOUNDCURVE,
-    GEOS_CURVEPOLYGON,
-    GEOS_MULTICURVE,
-    GEOS_MULTISURFACE,
-};
-
-enum GeometrySortIndex {
-    SORTINDEX_POINT = 0,
-    SORTINDEX_MULTIPOINT = 1,
-    SORTINDEX_LINESTRING = 2,
-    SORTINDEX_LINEARRING = 3,
-    SORTINDEX_MULTILINESTRING = 4,
-    SORTINDEX_POLYGON = 5,
-    SORTINDEX_MULTIPOLYGON = 6,
-    SORTINDEX_GEOMETRYCOLLECTION = 7,
-    SORTINDEX_CIRCULARSTRING = 8,
-    SORTINDEX_COMPOUNDCURVE = 9,
-    SORTINDEX_CURVEPOLYGON = 10,
-    SORTINDEX_MULTICURVE = 11,
-    SORTINDEX_MULTISURFACE = 12,
-};
-
-/**
- * \class Geometry geom.h geos.h
- *
- * \brief Basic implementation of Geometry, constructed and
- * destructed by GeometryFactory.
- *
- *  <code>clone</code> returns a deep copy of the object.
- *  Use GeometryFactory to construct.
- *
- *  <H3>Binary Predicates</H3>
- * Because it is not clear at this time
- * what semantics for spatial
- *  analysis methods involving <code>GeometryCollection</code>s would be useful,
- *  <code>GeometryCollection</code>s are not supported as arguments to binary
- *  predicates (other than <code>convexHull</code>) or the <code>relate</code>
- *  method.
- *
- *  <H3>Set-Theoretic Methods</H3>
- *
- *  The spatial analysis methods will
- *  return the most specific class possible to represent the result. If the
- *  result is homogeneous, a <code>Point</code>, <code>LineString</code>, or
- *  <code>Polygon</code> will be returned if the result contains a single
- *  element; otherwise, a <code>MultiPoint</code>, <code>MultiLineString</code>,
- *  or <code>MultiPolygon</code> will be returned. If the result is
- *  heterogeneous a <code>GeometryCollection</code> will be returned. <P>
- *
- *  Because it is not clear at this time what semantics for set-theoretic
- *  methods involving <code>GeometryCollection</code>s would be useful,
- * <code>GeometryCollections</code>
- *  are not supported as arguments to the set-theoretic methods.
- *
- *  <H4>Representation of Computed Geometries </H4>
- *
- *  The SFS states that the result
- *  of a set-theoretic method is the "point-set" result of the usual
- *  set-theoretic definition of the operation (SFS 3.2.21.1). However, there are
- *  sometimes many ways of representing a point set as a <code>Geometry</code>.
- *  <P>
- *
- *  The SFS does not specify an unambiguous representation of a given point set
- *  returned from a spatial analysis method. One goal of JTS is to make this
- *  specification precise and unambiguous. JTS will use a canonical form for
- *  <code>Geometry</code>s returned from spatial analysis methods. The canonical
- *  form is a <code>Geometry</code> which is simple and noded:
- *  <UL>
- *    <LI> Simple means that the Geometry returned will be simple according to
- *    the JTS definition of <code>isSimple</code>.
- *    <LI> Noded applies only to overlays involving <code>LineString</code>s. It
- *    means that all intersection points on <code>LineString</code>s will be
- *    present as endpoints of <code>LineString</code>s in the result.
- *  </UL>
- *  This definition implies that non-simple geometries which are arguments to
- *  spatial analysis methods must be subjected to a line-dissolve process to
- *  ensure that the results are simple.
- *
- *  <H4> Constructed Points And The Precision Model </H4>
- *
- *  The results computed by the set-theoretic methods may
- *  contain constructed points which are not present in the input Geometry.
- *  These new points arise from intersections between line segments in the
- *  edges of the input Geometry. In the general case it is not
- *  possible to represent constructed points exactly. This is due to the fact
- *  that the coordinates of an intersection point may contain twice as many bits
- *  of precision as the coordinates of the input line segments. In order to
- *  represent these constructed points explicitly, JTS must truncate them to fit
- *  the PrecisionModel.
- *
- *  Unfortunately, truncating coordinates moves them slightly. Line segments
- *  which would not be coincident in the exact result may become coincident in
- *  the truncated representation. This in turn leads to "topology collapses" --
- *  situations where a computed element has a lower dimension than it would in
- *  the exact result.
- *
- *  When JTS detects topology collapses during the computation of spatial
- *  analysis methods, it will throw an exception. If possible the exception will
- *  report the location of the collapse.
- *
- *  equals(Object) and hashCode are not overridden, so that when two
- *  topologically equal Geometries are added to HashMaps and HashSets, they
- *  remain distinct. This behaviour is desired in many cases.
- *
- */
-class GEOS_DLL Geometry {
-
-public:
-
-    friend class GeometryFactory;
-
-    /// A vector of const Geometry pointers
-    using ConstVect = std::vector<const Geometry*>;
-
-    /// A vector of non-const Geometry pointers
-    using NonConstVect = std::vector<Geometry*>;
-
-    /// An unique_ptr of Geometry
-    using Ptr = std::unique_ptr<Geometry> ;
-
-    /// Make a deep-copy of this Geometry
-    std::unique_ptr<Geometry> clone() const { return std::unique_ptr<Geometry>(cloneImpl()); }
-
-    /// Destroy Geometry and all components
-    virtual ~Geometry();
-
-
-    /**
-     * \brief
-     * Gets the factory which contains the context in which this
-     * geometry was created.
-     *
-     * @return the factory for this geometry
-     */
-    const GeometryFactory*
-    getFactory() const
-    {
-        return _factory;
-    }
-
-    /**
-    * \brief
-    * A simple scheme for applications to add their own custom data to
-    * a Geometry.
-    * An example use might be to add an object representing a
-    * Coordinate Reference System.
-    *
-    * Note that user data objects are not present in geometries created
-    * by construction methods.
-    *
-    * @param newUserData an object, the semantics for which are
-    * defined by the application using this Geometry
-    */
-    void
-    setUserData(void* newUserData)
-    {
-        _userData = newUserData;
-    }
-
-    /**
-    * \brief
-    * Gets the user data object for this geometry, if any.
-    *
-    * @return the user data object, or <code>null</code> if none set
-    */
-    void*
-    getUserData() const
-    {
-        return _userData;
-    }
-
-    /** \brief
-     * Returns the ID of the Spatial Reference System used by the Geometry.
-     *
-     * GEOS supports Spatial Reference System information in the simple way
-     * defined in the SFS. A Spatial Reference System ID (SRID) is present
-     * in each Geometry object. Geometry provides basic accessor operations
-     * for this field, but no others. The SRID is represented as an integer.
-     *
-     * @return the ID of the coordinate space in which the Geometry is defined.
-     */
-    virtual int
-    getSRID() const
-    {
-        return SRID;
-    }
-
-    /** \brief
-     * Sets the ID of the Spatial Reference System used by the Geometry.
-     */
-    virtual void
-    setSRID(int newSRID)
-    {
-        SRID = newSRID;
-    }
-
-    /**
-     * \brief
-     * Get the PrecisionModel used to create this Geometry.
-     */
-    const PrecisionModel* getPrecisionModel() const;
-
-    /// Returns a vertex of this Geometry, or NULL if this is the empty geometry.
-    virtual const CoordinateXY* getCoordinate() const = 0; //Abstract
-
-    /**
-     * \brief
-     * Returns this Geometry vertices.
-     * Caller takes ownership of the returned object.
-     */
-    virtual std::unique_ptr<CoordinateSequence> getCoordinates() const = 0; //Abstract
-
-    /// Returns the count of this Geometrys vertices.
-    virtual std::size_t getNumPoints() const = 0; //Abstract
-
-    /// Returns false if the Geometry not simple.
-    virtual bool isSimple() const;
-
-    /// Return a string representation of this Geometry type
-    virtual std::string getGeometryType() const = 0; //Abstract
-
-    /// Returns whether the Geometry contains curved components
-    virtual bool hasCurvedComponents() const;
-
-    /// Return an integer representation of this Geometry type
-    virtual GeometryTypeId getGeometryTypeId() const = 0; //Abstract
-
-    /**
-     * \brief Returns the number of geometries in this collection,
-     * or 1 if this is not a collection.
-     *
-     * Empty collection or multi-geometry types return 0,
-     * and empty simple geometry types return 1.
-     */
-    virtual std::size_t
-    getNumGeometries() const
-    {
-        return 1;
-    }
-
-    /// \brief Returns a pointer to the nth Geometry in this collection
-    /// (or self if this is not a collection)
-    virtual const Geometry*
-    getGeometryN(std::size_t /*n*/) const
-    {
-        return this;
-    }
-
-    /**
-     * \brief Tests the validity of this <code>Geometry</code>.
-     *
-     * Subclasses provide their own definition of "valid".
-     *
-     * @return <code>true</code> if this <code>Geometry</code> is valid
-     *
-     * @see IsValidOp
-     */
-    virtual bool isValid() const;
-
-    /// Returns whether or not the set of points in this Geometry is empty.
-    virtual bool isEmpty() const = 0; //Abstract
-
-    /// Polygon overrides to check for actual rectangle
-    virtual bool
-    isRectangle() const
-    {
-        return false;
-    }
-
-    /// Returns the dimension of this Geometry (0=point, 1=line, 2=surface)
-    virtual Dimension::DimensionType getDimension() const = 0; //Abstract
-
-    /// Checks whether any component of this geometry has dimension d
-    virtual bool hasDimension(Dimension::DimensionType d) const {
-        return getDimension() == d;
-    }
-
-    /// Checks whether this Geometry consists only of components having dimension d.
-    virtual bool isDimensionStrict(Dimension::DimensionType d) const {
-        return d == getDimension();
-    }
-
-    bool isPuntal() const {
-        return isDimensionStrict(Dimension::P);
-    }
-
-    bool isLineal() const {
-        return isDimensionStrict(Dimension::L);
-    }
-
-    bool isPolygonal() const {
-        return isDimensionStrict(Dimension::A);
-    }
-
-    bool isMixedDimension() const;
-    bool isMixedDimension(Dimension::DimensionType* baseDim) const;
-
-    bool isCollection() const {
-        int t = getGeometryTypeId();
-        return t == GEOS_GEOMETRYCOLLECTION ||
-               t == GEOS_MULTIPOINT ||
-               t == GEOS_MULTILINESTRING ||
-               t == GEOS_MULTIPOLYGON;
-    }
-
-    static GeometryTypeId multiTypeId(GeometryTypeId typeId) {
-        switch (typeId) {
-            case GEOS_POINT: return GEOS_MULTIPOINT;
-            case GEOS_LINESTRING: return GEOS_MULTILINESTRING;
-            case GEOS_POLYGON: return GEOS_MULTIPOLYGON;
-            default: return typeId;
-        }
-    }
-
-    /// Returns the coordinate dimension of this Geometry (2=XY, 3=XYZ or XYM, 4=XYZM).
-    virtual uint8_t getCoordinateDimension() const = 0; //Abstract
-
-    virtual bool hasZ() const = 0;
-
-    virtual bool hasM() const = 0;
-
-    /**
-     * \brief
-     * Returns the boundary, or an empty geometry of appropriate
-     * dimension if this <code>Geometry</code>  is empty.
-     *
-     * (In the case of zero-dimensional geometries,
-     * an empty GeometryCollection is returned.)
-     * For a discussion of this function, see the OpenGIS Simple
-     * Features Specification. As stated in SFS Section 2.1.13.1,
-     * "the boundary of a Geometry is a set of Geometries of the
-     * next lower dimension."
-     *
-     * @return  the closure of the combinatorial boundary
-     *          of this <code>Geometry</code>.
-     *          Ownershipof the returned object transferred to caller.
-     */
-    virtual std::unique_ptr<Geometry> getBoundary() const = 0; //Abstract
-
-    /// Returns the dimension of this Geometrys inherent boundary.
-    virtual int getBoundaryDimension() const = 0; //Abstract
-
-    /// Returns this Geometrys bounding box.
-    virtual std::unique_ptr<Geometry> getEnvelope() const;
-
-    /** \brief
-     * Returns the minimum and maximum x and y values in this Geometry,
-     * or a null Envelope if this Geometry is empty.
-     */
-    virtual const Envelope* getEnvelopeInternal() const = 0;
-
-    /**
-     * Tests whether this geometry is disjoint from the specified geometry.
-     *
-     * The <code>disjoint</code> predicate has the following equivalent
-     * definitions:
-     *  - The two geometries have no point in common
-     *  - The DE-9IM Intersection Matrix for the two geometries matches
-     *    <code>[FF*FF****]</code>
-     *  - <code>! g.intersects(this)</code>
-     *    (<code>disjoint</code> is the inverse of <code>intersects</code>)
-     *
-     * @param  other  the Geometry with which to compare this Geometry
-     * @return true if the two <code>Geometry</code>s are disjoint
-     *
-     * @see Geometry::intersects
-     */
-    virtual bool disjoint(const Geometry* other) const;
-
-    /** \brief
-     * Returns true if the DE-9IM intersection matrix for the two
-     * Geometrys is FT*******, F**T***** or F***T****.
-     */
-    virtual bool touches(const Geometry* other) const;
-
-    /// Returns true if disjoint returns false.
-    virtual bool intersects(const Geometry* g) const;
-
-    /**
-     * Tests whether this geometry crosses the specified geometry.
-     *
-     * The <code>crosses</code> predicate has the following equivalent
-     * definitions:
-     *  - The geometries have some but not all interior points in common.
-     *  - The DE-9IM Intersection Matrix for the two geometries matches
-     *    - <code>[T*T******]</code> (for P/L, P/A, and L/A situations)
-     *    - <code>[T*****T**]</code> (for L/P, A/P, and A/L situations)
-     *    - <code>[0********]</code> (for L/L situations)
-     * For any other combination of dimensions this predicate returns
-     * <code>false</code>.
-     *
-     * The SFS defined this predicate only for P/L, P/A, L/L, and L/A
-     * situations.
-     * JTS extends the definition to apply to L/P, A/P and A/L situations
-     * as well, in order to make the relation symmetric.
-     *
-     * @param  g  the <code>Geometry</code> with which to compare this
-     *            <code>Geometry</code>
-     *@return  <code>true</code> if the two <code>Geometry</code>s cross.
-     */
-    virtual bool crosses(const Geometry* g) const;
-
-    /** \brief
-     * Returns true if the DE-9IM intersection matrix for the two
-     * Geometrys is T*F**F***.
-     */
-    virtual bool within(const Geometry* g) const;
-
-    /// Returns true if other.within(this) returns true.
-    virtual bool contains(const Geometry* g) const;
-
-    /** \brief
-     * Returns true if the DE-9IM intersection matrix for the two
-     * Geometrys is T*T***T** (for two points or two surfaces)
-     * 1*T***T** (for two curves).
-     */
-    virtual bool overlaps(const Geometry* g) const;
-
-    /**
-     * \brief
-     * Returns true if the elements in the DE-9IM intersection matrix
-     * for the two Geometrys match the elements in intersectionPattern.
-     *
-     * IntersectionPattern elements may be: 0 1 2 T ( = 0, 1 or 2)
-     * F ( = -1) * ( = -1, 0, 1 or 2).
-     *
-     * For more information on the DE-9IM, see the OpenGIS Simple
-     * Features Specification.
-     *
-     * @throws util::IllegalArgumentException if either arg is a collection
-     *
-     */
-    bool relate(const Geometry* g,
-                        const std::string& intersectionPattern) const;
-
-    bool
-    relate(const Geometry& g, const std::string& intersectionPattern) const
-    {
-        return relate(&g, intersectionPattern);
-    }
-
-    /// Returns the DE-9IM intersection matrix for the two Geometrys.
-    std::unique_ptr<IntersectionMatrix> relate(const Geometry* g) const;
-
-    std::unique_ptr<IntersectionMatrix> relate(const Geometry& g) const;
-
-    /**
-     * \brief
-     * Returns true if the DE-9IM intersection matrix for the two
-     * Geometrys is T*F**FFF*.
-     */
-    virtual bool equals(const Geometry* g) const;
-
-    /** \brief
-     * Returns <code>true</code> if this geometry covers the
-     * specified geometry.
-     *
-     * The <code>covers</code> predicate has the following
-     * equivalent definitions:
-     *
-     * - Every point of the other geometry is a point of this geometry.
-     * - The DE-9IM Intersection Matrix for the two geometries is
-     *    <code>T*****FF*</code>
-     *    or <code>*T****FF*</code>
-     *    or <code>***T**FF*</code>
-     *    or <code>****T*FF*</code>
-     * - <code>g.coveredBy(this)</code>
-     *   (<code>covers</code> is the inverse of <code>coveredBy</code>)
-     *
-     * If either geometry is empty, the value of this predicate
-     * is <tt>false</tt>.
-     *
-     * This predicate is similar to {@link #contains},
-     * but is more inclusive (i.e. returns <tt>true</tt> for more cases).
-     * In particular, unlike <code>contains</code> it does not distinguish
-     * between points in the boundary and in the interior of geometries.
-     * For most situations, <code>covers</code> should be used in
-     * preference to <code>contains</code>.
-     * As an added benefit, <code>covers</code> is more amenable to
-     * optimization, and hence should be more performant.
-     *
-     * @param  g
-     *         the <code>Geometry</code> with which to compare this
-     *         <code>Geometry</code>
-     *
-     * @return <code>true</code> if this <code>Geometry</code>
-     *                           covers <code>g</code>
-     *
-     * @see Geometry::contains
-     * @see Geometry::coveredBy
-     */
-    bool covers(const Geometry* g) const;
-
-    /** \brief
-     * Tests whether this geometry is covered by the
-     * specified geometry.
-     *
-     * The <code>coveredBy</code> predicate has the following
-     * equivalent definitions:
-     *
-     *  - Every point of this geometry is a point of the other geometry.
-     *  - The DE-9IM Intersection Matrix for the two geometries matches
-     *       <code>[T*F**F***]</code>
-     *    or <code>[*TF**F***]</code>
-     *    or <code>[**FT*F***]</code>
-     *    or <code>[**F*TF***]</code>
-     *  - <code>g.covers(this)</code>
-     *    (<code>coveredBy</code> is the converse of <code>covers</code>)
-     *
-     * If either geometry is empty, the value of this predicate
-     * is <tt>false</tt>.
-     *
-     * This predicate is similar to {@link #within},
-     * but is more inclusive (i.e. returns <tt>true</tt> for more cases).
-     *
-     * @param  g  the <code>Geometry</code> with which to compare
-     *            this <code>Geometry</code>
-     * @return  <code>true</code> if this <code>Geometry</code>
-     *                            is covered by <code>g</code>
-     *
-     * @see Geometry#within
-     * @see Geometry#covers
-     */
-    bool coveredBy(const Geometry* g) const;
-
-
-    /// Returns the Well-known Text representation of this Geometry.
-    virtual std::string toString() const;
-
-    virtual std::string toText() const;
-
-    /// Returns a buffer region around this Geometry having the given width.
-    ///
-    /// @throws util::TopologyException if a robustness error occurs
-    ///
-    std::unique_ptr<Geometry> buffer(double distance) const;
-
-    /// \brief
-    /// Returns a buffer region around this Geometry having the
-    /// given width and with a specified number of segments used
-    /// to approximate curves.
-    ///
-    /// @throws util::TopologyException if a robustness error occurs
-    ///
-    std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
-
-    /** \brief
-     * Computes a buffer area around this geometry having the given
-     * width and with a specified accuracy of approximation for circular
-     * arcs, and using a specified end cap style.
-     *
-     * Buffer area boundaries can contain circular arcs.
-     * To represent these arcs using linear geometry they must be
-     * approximated with line segments.
-     *
-     * The <code>quadrantSegments</code> argument allows controlling the
-     * accuracy of the approximation by specifying the number of line
-     * segments used to represent a quadrant of a circle
-     *
-     * The end cap style specifies the buffer geometry that will be
-     * created at the ends of linestrings.  The styles provided are:
-     *
-     * - BufferOp::CAP_ROUND - (default) a semi-circle
-     * - BufferOp::CAP_BUTT  - a straight line perpendicular to the
-     *                         end segment
-     * - BufferOp::CAP_SQUARE - a half-square
-     *
-     *
-     * @param distance the width of the buffer
-     *                 (may be positive, negative or 0)
-     *
-     * @param quadrantSegments the number of line segments used
-     *                         to represent a quadrant of a circle
-     *
-     * @param endCapStyle the end cap style to use
-     *
-     * @return an area geometry representing the buffer region
-     *
-     * @throws util::TopologyException if a robustness error occurs
-     *
-     * @see BufferOp
-     */
-    std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
-                             int endCapStyle) const;
-
-    /// \brief
-    /// Returns the smallest convex Polygon that contains
-    /// all the points in the Geometry.
-    virtual std::unique_ptr<Geometry> convexHull() const;
-
-    /** \brief
-     * Computes a new geometry which has all component coordinate sequences
-     * in reverse order (opposite orientation) to this one.
-     *
-     * @return a reversed geometry
-     */
-    std::unique_ptr<Geometry> reverse() const { return std::unique_ptr<Geometry>(reverseImpl()); }
-
-    /** \brief
-     * Returns a Geometry representing the points shared by
-     * this Geometry and other.
-     *
-     * @throws util::TopologyException if a robustness error occurs
-     * @throws util::IllegalArgumentException if either input is a
-     *         non-empty GeometryCollection
-     *
-     */
-    std::unique_ptr<Geometry> intersection(const Geometry* other) const;
-
-    /** \brief
-     * Returns a Geometry representing all the points in this Geometry
-     * and other.
-     *
-     * @throws util::TopologyException if a robustness error occurs
-     * @throws util::IllegalArgumentException if either input is a
-     *         non-empty GeometryCollection
-     *
-     */
-    std::unique_ptr<Geometry> Union(const Geometry* other) const;
-    // throw(IllegalArgumentException *, TopologyException *);
-
-    /** \brief
-     * Computes the union of all the elements of this geometry. Heterogeneous
-     * [GeometryCollections](@ref GeometryCollection) are fully supported.
-     *
-     * The result obeys the following contract:
-     *
-     * - Unioning a set of [LineStrings](@ref LineString) has the effect of fully noding
-     *   and dissolving the linework.
-     * - Unioning a set of [Polygons](@ref Polygon) will always
-     *   return a polygonal geometry (unlike Geometry::Union(const Geometry* other) const),
-     *   which may return geometrys of lower dimension if a topology collapse
-     *   occurred.
-     *
-     * @return the union geometry
-     *
-     * @see UnaryUnionOp
-     */
-    Ptr Union() const;
-    // throw(IllegalArgumentException *, TopologyException *);
-
-    /**
-     * \brief
-     * Returns a Geometry representing the points making up this
-     * Geometry that do not make up other.
-     *
-     * @throws util::TopologyException if a robustness error occurs
-     * @throws util::IllegalArgumentException if either input is a
-     *         non-empty GeometryCollection
-     *
-     */
-    std::unique_ptr<Geometry> difference(const Geometry* other) const;
-
-    /** \brief
-     * Returns a set combining the points in this Geometry not in other,
-     * and the points in other not in this Geometry.
-     *
-     * @throws util::TopologyException if a robustness error occurs
-     * @throws util::IllegalArgumentException if either input is a
-     *         non-empty GeometryCollection
-     *
-     */
-    std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
-
-    /** \brief
-     * Returns true iff the two Geometrys are of the same type and their
-     * vertices corresponding by index are equal up to a specified distance
-     * tolerance. Geometries are not required to have the same dimemsion;
-     * any Z/M values are ignored.
-     */
-    virtual bool equalsExact(const Geometry* other, double tolerance = 0)
-        const = 0; // Abstract
-
-    /** \brief
-     * Returns true if the two geometries are of the same type and their
-     * vertices corresponding by index are equal in all dimensions.
-     */
-    virtual bool equalsIdentical(const Geometry* other) const = 0;
-
-    virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
-    virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
-    virtual void apply_rw(GeometryFilter* filter);
-    virtual void apply_ro(GeometryFilter* filter) const;
-    virtual void apply_rw(GeometryComponentFilter* filter);
-    virtual void apply_ro(GeometryComponentFilter* filter) const;
-
-    /**
-     *  Performs an operation on the coordinates in this Geometry's
-     *  CoordinateSequences.
-     *  If the filter reports that a coordinate value has been changed,
-     *  {@link #geometryChanged} will be called automatically.
-     *
-     * @param  filter  the filter to apply
-     */
-    virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
-
-    /**
-     *  Performs a read-only operation on the coordinates in this
-     *  Geometry's CoordinateSequences.
-     *
-     * @param  filter  the filter to apply
-     */
-    virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
-
-    /** \brief
-     * Apply a filter to each component of this geometry.
-     * The filter is expected to provide a .filter(const Geometry*)
-     * method.
-     *
-     * I intend similar templated methods to replace
-     * all the virtual apply_rw and apply_ro functions...
-     *                --strk(2005-02-06);
-     */
-    template <class T>
-    void
-    applyComponentFilter(T& f) const
-    {
-        for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
-            f.filter(getGeometryN(i));
-        }
-    }
-
-    /**
-     * Reorganizes this Geometry into normal form (or canonical form).
-     * Starting point of rings is lower left, collections are ordered
-     * by geometry type, etc.
-     */
-    virtual void normalize() = 0; //Abstract
-
-    /// Comparator for sorting geometry
-    virtual int compareTo(const Geometry* geom) const;
-
-    /// Returns the area of this Geometry.
-    virtual double getArea() const;
-
-    /// Returns the length of this Geometry.
-    virtual double getLength() const;
-
-    /** Returns the minimum distance between this Geometry and the Geometry g
-     *
-     * @param g the Geometry to calculate distance to
-     * @return the distance in cartesian units
-     */
-    virtual double distance(const Geometry* g) const;
-
-
-    /** \brief
-     * Tests whether the distance from this Geometry  to another
-     * is less than or equal to a specified value.
-     *
-     * @param geom the Geometry to check the distance to
-     * @param cDistance the distance value to compare
-     * @return <code>true</code> if the geometries are less than
-     *  <code>distance</code> apart.
-     *
-     * @todo doesn't seem to need being virtual, make it concrete
-     */
-    virtual bool isWithinDistance(const Geometry* geom,
-                                  double cDistance) const;
-
-    /** \brief
-     * Computes the centroid of this <code>Geometry</code>.
-     *
-     * The centroid is equal to the centroid of the set of component
-     * Geometries of highest dimension (since the lower-dimension geometries
-     * contribute zero "weight" to the centroid)
-     *
-     * @return a {@link Point} which is the centroid of this Geometry
-     */
-    virtual std::unique_ptr<Point> getCentroid() const;
-
-    /// Computes the centroid of this Geometry as a Coordinate
-    //
-    /// Returns false if centroid cannot be computed (EMPTY geometry)
-    ///
-    virtual bool getCentroid(CoordinateXY& ret) const;
-
-    /** \brief
-     * Computes an interior point of this <code>Geometry</code>.
-     *
-     * An interior point is guaranteed to lie in the interior of the Geometry,
-     * if it possible to calculate such a point exactly. Otherwise,
-     * the point may lie on the boundary of the geometry.
-     *
-     * @return a Point which is in the interior of this Geometry, or
-     *         null if the geometry doesn't have an interior (empty)
-     */
-    std::unique_ptr<Point> getInteriorPoint() const;
-
-    /**
-     * \brief
-     * Notifies this Geometry that its Coordinates have been changed
-     * by an external party (using a CoordinateFilter, for example).
-     */
-    virtual void geometryChanged();
-
-    /**
-     * \brief
-     * Notifies this Geometry that its Coordinates have been changed
-     * by an external party.
-     */
-    virtual void geometryChangedAction() = 0;
-
-protected:
-    /// Make a deep-copy of this Geometry
-    virtual Geometry* cloneImpl() const = 0;
-
-    /// Make a geometry with coordinates in reverse order
-    virtual Geometry* reverseImpl() const = 0;
-
-    /// Returns true if the array contains any non-empty Geometrys.
-    template<typename T>
-    static bool hasNonEmptyElements(const std::vector<T>* geometries) {
-        return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
-    }
-
-    /// Returns true if the CoordinateSequence contains any null elements.
-    static bool hasNullElements(const CoordinateSequence* list);
-
-    /// Returns true if the vector contains any null elements.
-    template<typename T>
-    static bool hasNullElements(const std::vector<T>* geometries) {
-        return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
-    }
-
-//	static void reversePointOrder(CoordinateSequence* coordinates);
-//	static Coordinate& minCoordinate(CoordinateSequence* coordinates);
-//	static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
-//	static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
-//
-    /** \brief
-     * Returns whether the two Geometrys are equal, from the point
-     * of view of the equalsExact method.
-     */
-    virtual bool isEquivalentClass(const Geometry* other) const;
-
-    static void checkNotGeometryCollection(const Geometry* g);
-
-    virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
-
-    template<typename T>
-    static int compare(const T& a, const T& b)
-    {
-        std::size_t i = 0;
-        std::size_t j = 0;
-        while(i < a.size() && j < b.size()) {
-            const auto& aGeom = *a[i];
-            const auto& bGeom = *b[j];
-
-            int comparison = aGeom.compareTo(&bGeom);
-            if(comparison != 0) {
-                return comparison;
-            }
-
-            i++;
-            j++;
-        }
-
-        if(i < a.size()) {
-            return 1;
-        }
-
-        if(j < b.size()) {
-            return -1;
-        }
-
-        return 0;
-    }
-
-    bool equal(const CoordinateXY& a, const CoordinateXY& b,
-               double tolerance) const;
-    int SRID;
-
-    Geometry(const Geometry& geom);
-
-    /** \brief
-     * Construct a geometry with the given GeometryFactory.
-     *
-     * Will keep a reference to the factory, so don't
-     * delete it until al Geometry objects referring to
-     * it are deleted.
-     *
-     * @param factory
-     */
-    Geometry(const GeometryFactory* factory);
-
-    template<typename T>
-    static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
-        static_assert(std::is_base_of<Geometry, T>::value, "");
-        std::vector<std::unique_ptr<Geometry>> gv(v.size());
-        for (std::size_t i = 0; i < v.size(); i++) {
-            gv[i] = std::move(v[i]);
-        }
-        return gv;
-    }
-
-    static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<Geometry>> && v) {
-        return std::move(v);
-    }
-
-protected:
-
-    virtual int getSortIndex() const = 0;
-
-
-private:
-
-    class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
-    public:
-        void filter_rw(Geometry* geom) override;
-    };
-
-    static GeometryChangedFilter geometryChangedFilter;
-
-    /// The GeometryFactory used to create this Geometry
-    ///
-    /// Externally owned
-    ///
-    const GeometryFactory* _factory;
-
-    void* _userData;
-};
-
-/// \brief
-/// Write the Well-known Binary representation of this Geometry
-/// as an HEX string to the given output stream
-///
-GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
-
-struct GEOS_DLL GeometryGreaterThen {
-    bool operator()(const Geometry* first, const Geometry* second);
-};
-
-
-/// Return current GEOS version
-GEOS_DLL std::string geosversion();
-
-/**
- * \brief
- * Return the version of JTS this GEOS
- * release has been ported from.
- */
-GEOS_DLL std::string jtsport();
-
-// We use this instead of std::pair<unique_ptr<Geometry>> because C++11
-// forbids that construct:
-// http://lwg.github.com/issues/lwg-closed.html#2068
-struct GeomPtrPair {
-    typedef std::unique_ptr<Geometry> GeomPtr;
-    GeomPtr first;
-    GeomPtr second;
-};
-
-} // namespace geos::geom
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-