@crossbind/port-geos-ios 2.0.0-beta.56 → 2.0.0-beta.60

package/geos.xcframework/ios-arm64/Headers/geos/geom/LinearRing.h

@@ -78,6 +78,9 @@ public:
     LinearRing(CoordinateSequence::Ptr && points,
             const GeometryFactory& newFactory);
 
+    LinearRing(const std::shared_ptr<const CoordinateSequence>& points,
+            const GeometryFactory& newFactory);
+
     std::unique_ptr<LinearRing> clone() const
     {
         return std::unique_ptr<LinearRing>(cloneImpl());

package/geos.xcframework/ios-arm64/Headers/geos/geom/MultiCurve.h

@@ -16,6 +16,7 @@
 
 #include <geos/geom/Curve.h>
 #include <geos/geom/GeometryCollection.h>
+#include <geos/geom/MultiLineString.h>
 
 namespace geos {
 namespace geom {
@@ -50,6 +51,14 @@ public:
 
     GeometryTypeId getGeometryTypeId() const override;
 
+    std::unique_ptr<MultiLineString> getLinearized(const algorithm::CurveToLineParams& params) const {
+        return std::unique_ptr<MultiLineString>(getLinearizedImpl(params));
+    }
+
+    bool hasCurvedTypes() const override {
+        return true;
+    }
+
     bool hasDimension(Dimension::DimensionType d) const override
     {
         return d == Dimension::L;
@@ -114,6 +123,10 @@ protected:
 
     MultiCurve* reverseImpl() const override;
 
+    MultiCurve* getCurvedImpl(const algorithm::LineToCurveParams&) const override { return cloneImpl(); }
+
+    MultiLineString* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
     int
     getSortIndex() const override
     {

package/geos.xcframework/ios-arm64/Headers/geos/geom/MultiLineString.h

@@ -81,6 +81,10 @@ public:
 
     GeometryTypeId getGeometryTypeId() const override;
 
+    std::unique_ptr<MultiLineString> getLinearized(const algorithm::CurveToLineParams&) const {
+        return clone();
+    }
+
     bool isClosed() const;
 
     std::unique_ptr<MultiLineString> clone() const
@@ -124,6 +128,9 @@ protected:
     MultiLineString(std::vector<std::unique_ptr<Geometry>> && newLines,
                     const GeometryFactory& newFactory);
 
+    MultiLineString(std::vector<std::unique_ptr<Curve>> && newLines,
+                    const GeometryFactory& newFactory);
+
     MultiLineString(const MultiLineString& mp)
         : GeometryCollection(mp)
         {};
@@ -132,6 +139,10 @@ protected:
 
     MultiLineString* reverseImpl() const override;
 
+    GeometryCollection* getCurvedImpl(const algorithm::LineToCurveParams&) const override;
+
+    MultiLineString* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
     int
     getSortIndex() const override
     {

package/geos.xcframework/ios-arm64/Headers/geos/geom/MultiPolygon.h

@@ -26,7 +26,6 @@
 #include <geos/geom/GeometryCollection.h> // for inheritance
 #include <geos/geom/Polygon.h> // for inheritance
 #include <geos/geom/Dimension.h> // for Dimension::DimensionType
-#include <geos/geom/GeometryCollection.h>
 
 
 // Forward declarations
@@ -132,6 +131,10 @@ protected:
 
     MultiPolygon* cloneImpl() const override { return new MultiPolygon(*this); }
 
+    GeometryCollection* getCurvedImpl(const algorithm::LineToCurveParams&) const override;
+
+    MultiPolygon* getLinearizedImpl(const algorithm::CurveToLineParams&) const override { return cloneImpl(); }
+
     MultiPolygon* reverseImpl() const override;
 
     int

package/geos.xcframework/ios-arm64/Headers/geos/geom/MultiSurface.h

@@ -49,6 +49,14 @@ public:
 
     GeometryTypeId getGeometryTypeId() const override;
 
+    std::unique_ptr<MultiPolygon> getLinearized(const algorithm::CurveToLineParams& params) const {
+        return std::unique_ptr<MultiPolygon>(getLinearizedImpl(params));
+    }
+
+    bool hasCurvedTypes() const override {
+        return true;
+    }
+
     bool hasDimension(Dimension::DimensionType d) const override
     {
         return d == Dimension::A;
@@ -81,6 +89,10 @@ protected:
         return new MultiSurface(*this);
     }
 
+    MultiSurface* getCurvedImpl(const algorithm::LineToCurveParams&) const override { return cloneImpl(); }
+
+    MultiPolygon* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
     int
     getSortIndex() const override
     {

package/geos.xcframework/ios-arm64/Headers/geos/geom/Point.h

@@ -187,6 +187,10 @@ protected:
 
     Point(const Point& p);
 
+    Point* getCurvedImpl(const algorithm::LineToCurveParams&) const override { return cloneImpl(); };
+
+    Point* getLinearizedImpl(const algorithm::CurveToLineParams&) const override { return cloneImpl(); };
+
     Point* cloneImpl() const override { return new Point(*this); }
 
     Point* reverseImpl() const override { return new Point(*this); }

package/geos.xcframework/ios-arm64/Headers/geos/geom/Polygon.h

@@ -94,6 +94,12 @@ public:
     std::string getGeometryType() const override;
     GeometryTypeId getGeometryTypeId() const override;
 
+    std::unique_ptr<Surface> getCurved(const algorithm::LineToCurveParams& params) const {
+        return std::unique_ptr<Surface>(getCurvedImpl(params));
+    }
+
+    std::unique_ptr<Polygon> getLinearized(const algorithm::CurveToLineParams&) const;
+
     void normalize() override;
 
     std::unique_ptr<Polygon> reverse() const { return std::unique_ptr<Polygon>(reverseImpl()); }
@@ -116,6 +122,10 @@ protected:
 
     using SurfaceImpl::SurfaceImpl;
 
+    Surface* getCurvedImpl(const algorithm::LineToCurveParams&) const override;
+
+    Polygon* getLinearizedImpl(const algorithm::CurveToLineParams&) const override { return cloneImpl(); };
+
     Polygon* cloneImpl() const override { return new Polygon(*this); }
 
     Polygon* reverseImpl() const override;
@@ -129,7 +139,7 @@ protected:
 
 private:
 
-    void normalize(LinearRing* ring, bool clockwise);
+    static void normalize(LinearRing* ring, bool clockwise);
 
 };
 

package/geos.xcframework/ios-arm64/Headers/geos/geom/Quadrant.h

@@ -70,7 +70,7 @@ public:
             std::ostringstream s;
             s << "Cannot compute the quadrant for point ";
             s << "(" << dx << "," << dy << ")" << std::endl;
-            throw util::IllegalArgumentException(s.str());
+            throw geos::util::IllegalArgumentException(s.str());
         }
         if(dx >= 0) {
             if(dy >= 0) {
@@ -98,7 +98,7 @@ public:
     static int quadrant(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
     {
         if(p1.x == p0.x && p1.y == p0.y) {
-            throw util::IllegalArgumentException("Cannot compute the quadrant for two identical points " + p0.toString());
+            throw geos::util::IllegalArgumentException("Cannot compute the quadrant for two identical points " + p0.toString());
         }
 
         if(p1.x >= p0.x) {

package/geos.xcframework/ios-arm64/Headers/geos/geom/SimpleCurve.h

@@ -61,13 +61,18 @@ public:
     /// Returns a read-only pointer to internal CoordinateSequence
     const CoordinateSequence* getCoordinatesRO() const;
 
+    /// Returns a read-only pointer to internal CoordinateSequence
+    const std::shared_ptr<const CoordinateSequence>& getSharedCoordinates() const;
+
     const SimpleCurve* getCurveN(std::size_t) const override;
 
+    const CoordinateXY& getEndCoordinate() const override;
+
     /// \brief
     /// Return the end point of the LineString
     /// or NULL if this is an EMPTY LineString.
     ///
-    virtual std::unique_ptr<Point> getEndPoint() const;
+    std::unique_ptr<Point> getEndPoint() const override;
 
     const Envelope* getEnvelopeInternal() const override
     {
@@ -78,13 +83,15 @@ public:
 
     std::size_t getNumPoints() const override;
 
-    virtual std::unique_ptr<Point> getPointN(std::size_t n) const;
+    std::unique_ptr<Point> getPointN(std::size_t n) const override;
+
+    const CoordinateXY& getStartCoordinate() const override;
 
     /// \brief
     /// Return the start point of the LineString
     /// or NULL if this is an EMPTY LineString.
     ///
-    virtual std::unique_ptr<Point> getStartPoint() const;
+    std::unique_ptr<Point> getStartPoint() const override;
 
     bool hasM() const override;
 
@@ -98,28 +105,18 @@ public:
 
     bool isEmpty() const override;
 
-    /** \brief
-     * Normalizes a SimpleCurve.
-     *
-     * A normalized simple curve
-     * has the first point which is not equal to its reflected point
-     * less than the reflected point.
-     */
-    void normalize() override;
+    std::unique_ptr<SimpleCurve> clone() const;
 
-    /**
-     * \brief
-     * Take ownership of the CoordinateSequence managed by this geometry.
-     * After releasing the coordinates, the geometry should be considered
-     * in a moved-from state and should not be accessed.
-     * @return this Geometry's CoordinateSequence.
-     */
-    std::unique_ptr<CoordinateSequence> releaseCoordinates();
+    std::unique_ptr<SimpleCurve> reverse() const;
 
 protected:
 
     SimpleCurve(const SimpleCurve& other);
 
+    SimpleCurve(const std::shared_ptr<const CoordinateSequence>& newCoords,
+                bool isLinear,
+                const GeometryFactory& factory);
+
     SimpleCurve(std::unique_ptr<CoordinateSequence>&& newCoords,
                 bool isLinear,
                 const GeometryFactory& factory);
@@ -128,14 +125,8 @@ protected:
 
     Envelope computeEnvelopeInternal(bool isLinear) const;
 
-    // TODO: hold value or shared_ptr instead of unique_ptr?
-    std::unique_ptr<CoordinateSequence> points;
+    std::shared_ptr<const CoordinateSequence> points;
     mutable Envelope envelope;
-
-
-private:
-
-    void normalizeClosed();
 };
 
 }

package/geos.xcframework/ios-arm64/Headers/geos/geom/Surface.h

@@ -49,6 +49,8 @@ public:
 
     void apply_rw(const CoordinateFilter* filter) override;
 
+    std::unique_ptr<Surface> clone() const;
+
     std::unique_ptr<Geometry> convexHull() const override;
 
     bool
@@ -109,6 +111,8 @@ protected:
 
     void geometryChangedAction() override {}
 
+    void validateConstruction() const;
+
 };
 
 }

package/geos.xcframework/ios-arm64/Headers/geos/geom/SurfaceImpl.h

@@ -70,6 +70,8 @@ protected:
         if (shell == nullptr) {
             shell.reset(static_cast<RingType*>(createEmptyRing(newFactory).release()));
         }
+
+        validateConstruction();
     }
 
     SurfaceImpl(std::unique_ptr<RingType>&& newShell,
@@ -83,12 +85,7 @@ protected:
             shell.reset(static_cast<RingType*>(createEmptyRing(newFactory).release()));
         }
 
-        if(shell->isEmpty() && hasNonEmptyElements(&holes)) {
-            throw geos::util::IllegalArgumentException("shell is empty but holes are not");
-        }
-        if (hasNullElements(&holes)) {
-            throw geos::util::IllegalArgumentException("holes must not contain null elements");
-        }
+        validateConstruction();
     }
 
 public:

package/geos.xcframework/ios-arm64/Headers/geos/geom/util/CurveBuilder.h

@@ -0,0 +1,89 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 ISciences LLC
+ *
+ * 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 Foundations.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <memory>
+#include <vector>
+
+namespace geos::geom {
+class CoordinateSequence;
+class Curve;
+class GeometryFactory;
+class SimpleCurve;
+}
+
+namespace geos::geom::util {
+
+/// The CurveBuilder is a utility class to assist in construction of simple or
+/// compound curves, such as when combining coordinates from a list of Edges.
+class GEOS_DLL CurveBuilder {
+public:
+    CurveBuilder(const GeometryFactory& gfact, bool hasZ, bool hasM);
+
+    // Add all coordinates in the provided geometry
+    void add(const Curve& geom);
+
+    // Add all coordinates in the provided sequence
+    void add(const CoordinateSequence& seq, bool isCurved);
+
+    // Add coordinates between the specified indices (inclusive)
+    void add(const CoordinateSequence& seq, std::size_t from, std::size_t to, bool isCurved);
+
+    // Close the ring, if necessary, using a linear segment
+    void closeRing();
+
+    // Get the result geometry
+    std::unique_ptr<Curve> getGeometry();
+
+    // Get a reference to the CoordinateSequence to which
+    // coordinates are currently being added.
+    CoordinateSequence& getSeq(bool isCurved);
+
+    bool hasZ() const {
+        return m_hasZ;
+    }
+
+    bool hasM() const {
+        return m_hasM;
+    }
+
+    bool hasActiveSequence() const {
+        return m_pts != nullptr;
+    }
+
+    bool isCurved() const {
+        return m_isCurved;
+    }
+
+    void setOutputLinearRing(bool outputLinearRing) {
+        m_outputLinearRing = outputLinearRing;
+    }
+
+private:
+    void finishCurve();
+    void finishLine();
+
+    std::vector<std::unique_ptr<SimpleCurve>> m_curves;
+    std::unique_ptr<CoordinateSequence> m_pts{nullptr};
+    const GeometryFactory& m_gfact;
+    const bool m_hasZ;
+    const bool m_hasM;
+    bool m_outputLinearRing{true};
+    bool m_isCurved{false};
+};
+
+}

package/geos.xcframework/ios-arm64/Headers/geos/geom/util/GeometryTransformer.h

@@ -41,6 +41,11 @@ class MultiPoint;
 class MultiPolygon;
 class MultiLineString;
 class GeometryCollection;
+class CircularString;
+class CompoundCurve;
+class CurvePolygon;
+class MultiCurve;
+class MultiSurface;
 namespace util {
 //class GeometryEditorOperation;
 }
@@ -121,6 +126,14 @@ protected:
         const LineString* geom,
         const Geometry* parent);
 
+    virtual Geometry::Ptr transformCircularString(
+        const CircularString* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformCompoundCurve(
+        const CompoundCurve* geom,
+        const Geometry* parent);
+
     virtual Geometry::Ptr transformMultiLineString(
         const MultiLineString* geom,
         const Geometry* parent);
@@ -129,10 +142,22 @@ protected:
         const Polygon* geom,
         const Geometry* parent);
 
+    virtual Geometry::Ptr transformCurvePolygon(
+        const CurvePolygon* geom,
+        const Geometry* parent);
+
     virtual Geometry::Ptr transformMultiPolygon(
         const MultiPolygon* geom,
         const Geometry* parent);
 
+    virtual Geometry::Ptr transformMultiCurve(
+        const MultiCurve* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformMultiSurface(
+        const MultiSurface* geom,
+        const Geometry* parent);
+
     virtual Geometry::Ptr transformGeometryCollection(
         const GeometryCollection* geom,
         const Geometry* parent);

package/geos.xcframework/ios-arm64/Headers/geos/geom/util/LinealExtracter.h

@@ -0,0 +1,51 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 ISciences LLC
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Geometry.h>
+#include <vector>
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * \brief Extracts the lineal (LineString/LinearRing/CircularString/CompoundCurve/MultiLineString/MultiCurve)
+ * elements from a Geometry.
+ */
+class GEOS_DLL LinealExtracter {
+
+public:
+
+    /**
+     * Pushes the lineal elements from a geometry into the provided vector.
+     * 
+     * @param geom the geometry to extract from
+     * @param lineals the vector to add the polygonal elements to
+     */
+    static void getLineals(const Geometry& geom, std::vector<const Geometry*>& lineals);
+
+    static void getLineals(const Geometry* geom, std::vector<const Geometry*>& lineals);
+
+    // Declare type as noncopyable
+    LinealExtracter(const LinealExtracter& other) = delete;
+    LinealExtracter& operator=(const LinealExtracter& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/geos.xcframework/ios-arm64/Headers/geos/geom/util/SimpleCurveExtracter.h

@@ -0,0 +1,52 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 ISciences LLC
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <geos/geom/GeometryComponentFilter.h>
+
+namespace geos::geom {
+class SimpleCurve;
+}
+
+namespace geos::geom::util {
+
+/**
+ * Extracts all SimpleCurve components from a Geometry
+ */
+class GEOS_DLL SimpleCurveExtracter: public GeometryComponentFilter {
+
+public:
+
+    static void getCurves(const Geometry& geom, std::vector<const SimpleCurve*>& ret);
+
+    explicit SimpleCurveExtracter(std::vector<const SimpleCurve*>& newComps);
+
+    void filter_ro(const Geometry* geom) override;
+
+private:
+
+    std::vector<const SimpleCurve*>& comps;
+
+    // Declare type as noncopyable
+    SimpleCurveExtracter(const SimpleCurveExtracter& other) = delete;
+    SimpleCurveExtracter& operator=(const SimpleCurveExtracter& rhs) = delete;
+
+};
+
+} // namespace geos.geom.util
+

package/geos.xcframework/ios-arm64/Headers/geos/geom/util/SurfaceExtracter.h

@@ -0,0 +1,60 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 ISciences LLC
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/GeometryFilter.h>
+#include <vector>
+
+namespace geos::geom {
+class Surface;
+}
+
+namespace geos::geom::util {
+
+/**
+ * Extracts all the 2-dimensional (Surface) components from a Geometry.
+ */
+class GEOS_DLL SurfaceExtracter: public GeometryFilter {
+
+public:
+
+    /**
+     * Pushes the Surface components from a single geometry into
+     * the provided vector.
+     */
+    static void getSurfaces(const Geometry& geom, std::vector<const Surface*>& ret);
+
+    /**
+     * Constructs a SurfaceExtracter with a list in which
+     * to store Surfaces found.
+     */
+    SurfaceExtracter(std::vector<const Surface*>& newComps);
+
+    void filter_rw(Geometry* geom) override;
+
+    void filter_ro(const Geometry* geom) override;
+
+private:
+
+    std::vector<const Surface*>& comps;
+
+    // Declare type as noncopyable
+    SurfaceExtracter(const SurfaceExtracter& other) = delete;
+    SurfaceExtracter& operator=(const SurfaceExtracter& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+

package/geos.xcframework/ios-arm64/Headers/geos/geomgraph/EdgeNodingValidator.h

@@ -54,19 +54,13 @@ namespace geomgraph { // geos.geomgraph
 class GEOS_DLL EdgeNodingValidator final {
 
 private:
-    std::vector<noding::SegmentString*>& toSegmentStrings(std::vector<Edge*>& edges);
+    const std::vector<std::unique_ptr<noding::SegmentString>>& toSegmentStrings(std::vector<Edge*>& edges);
 
     // Make sure this member is initialized *before*
     // the NodingValidator, as initialization of
     // NodingValidator will use toSegmentString(), that
     // in turn expects this member to be initialized
-    std::vector<noding::SegmentString*> segStr;
-
-    // Make sure this member is initialized *before*
-    // the NodingValidator, as initialization of
-    // NodingValidator will use toSegmentString(), that
-    // in turn expects this member to be initialized
-    std::vector<geom::CoordinateSequence*> newCoordSeq;
+    std::vector<std::unique_ptr<noding::SegmentString>> segStr;
 
     noding::FastNodingValidator nv;
 
@@ -91,7 +85,6 @@ public:
     EdgeNodingValidator(std::vector<Edge*>& edges)
         :
         segStr(),
-        newCoordSeq(),
         nv(toSegmentStrings(edges))
     {}
 

package/geos.xcframework/ios-arm64/Headers/geos/index/intervalrtree/IntervalRTreeLeafNode.h

@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <geos/export.h>
 #include <geos/index/intervalrtree/IntervalRTreeNode.h> // inherited
 
 
@@ -30,7 +31,7 @@ namespace geos {
 namespace index {
 namespace intervalrtree {
 
-class IntervalRTreeLeafNode : public IntervalRTreeNode {
+class GEOS_DLL IntervalRTreeLeafNode : public IntervalRTreeNode {
 private:
     /// externally owned
     void* item;

package/geos.xcframework/ios-arm64/Headers/geos/index/intervalrtree/IntervalRTreeNode.h

@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <geos/export.h>
 #include <geos/constants.h>
 #include <vector>
 #include <limits>
@@ -31,7 +32,7 @@ namespace geos {
 namespace index {
 namespace intervalrtree {
 
-class IntervalRTreeNode {
+class GEOS_DLL IntervalRTreeNode {
 private:
 protected:
     double min;