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

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/index/intervalrtree/SortedPackedIntervalRTree.h

@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <geos/export.h>
 #include <geos/index/intervalrtree/IntervalRTreeNode.h>
 #include <geos/index/intervalrtree/IntervalRTreeBranchNode.h>
 #include <geos/index/intervalrtree/IntervalRTreeLeafNode.h>
@@ -48,7 +49,7 @@ namespace intervalrtree {
  * @author Martin Davis
  *
  */
-class SortedPackedIntervalRTree {
+class GEOS_DLL SortedPackedIntervalRTree { 
 private:
     std::vector<IntervalRTreeLeafNode> leaves;
     std::vector<IntervalRTreeBranchNode> branches;

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/index/kdtree/KdNode.h

@@ -42,15 +42,15 @@ public:
     KdNode(double p_x, double p_y, void* p_data);
     KdNode(const geom::Coordinate& p_p, void* p_data);
 
-    double getX() { return p.x; }
-    double getY() { return p.y; }
-    const geom::Coordinate& getCoordinate() { return p; }
+    double getX() const { return p.x; }
+    double getY() const { return p.y; }
+    const geom::Coordinate& getCoordinate() const { return p; }
     void* getData() { return data; }
     KdNode* getLeft() { return left; }
     KdNode* getRight() { return right; }
     void increment() { count++; }
-    std::size_t getCount() { return count; }
-    bool isRepeated() { return count > 1; }
+    std::size_t getCount() const { return count; }
+    bool isRepeated() const { return count > 1; }
     void setLeft(KdNode* p_left) { left = p_left; }
     void setRight(KdNode* p_right) { right = p_right; }
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/index/kdtree/KdNodeVisitor.h

@@ -35,6 +35,7 @@ public:
     KdNodeVisitor() {};
     virtual void visit(KdNode *node) = 0;
 
+    virtual ~KdNodeVisitor() = default;
 
 };
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/index/kdtree/KdTree.h

@@ -19,9 +19,7 @@
 #include <geos/index/kdtree/KdNodeVisitor.h>
 #include <geos/index/kdtree/KdNode.h>
 
-#include <memory>
 #include <vector>
-#include <string>
 #include <deque>
 
 #ifdef _MSC_VER
@@ -64,8 +62,8 @@ private:
     KdNode* findBestMatchNode(const geom::Coordinate& p);
     KdNode* insertExact(const geom::Coordinate& p, void* data);
 
-    void queryNode(KdNode* currentNode, const geom::Envelope& queryEnv, bool odd, KdNodeVisitor& visitor);
-    KdNode* queryNodePoint(KdNode* currentNode, const geom::Coordinate& queryPt, bool odd);
+    static void queryNode(KdNode* currentNode, const geom::Envelope& queryEnv, bool odd, KdNodeVisitor& visitor);
+    static KdNode* queryNodePoint(KdNode* currentNode, const geom::Coordinate& queryPt, bool odd);
 
     /**
     * Create a node on a locally managed deque to allow easy
@@ -85,15 +83,16 @@ private:
         KdNode* getNode();
         void visit(KdNode* node) override;
 
+        // Declare type as noncopyable
+        BestMatchVisitor(const BestMatchVisitor& other) = delete;
+        BestMatchVisitor& operator=(const BestMatchVisitor& rhs) = delete;
+
     private:
         // Members
         double tolerance;
         KdNode* matchNode;
         double matchDist;
         const geom::Coordinate& p;
-        // Declare type as noncopyable
-        BestMatchVisitor(const BestMatchVisitor& other);
-        BestMatchVisitor& operator=(const BestMatchVisitor& rhs);
     };
 
     /**
@@ -102,16 +101,17 @@ private:
     */
     class AccumulatingVisitor : public KdNodeVisitor {
     public:
-        AccumulatingVisitor(std::vector<KdNode*>& p_nodeList) :
+        explicit AccumulatingVisitor(std::vector<KdNode*>& p_nodeList) :
             nodeList(p_nodeList) {};
         void visit(KdNode* node) override { nodeList.push_back(node); }
 
+        // Declare type as noncopyable
+        AccumulatingVisitor(const AccumulatingVisitor& other) = delete;
+        AccumulatingVisitor& operator=(const AccumulatingVisitor& rhs) = delete;
+
     private:
         // Members
         std::vector<KdNode*>& nodeList;
-        // Declare type as noncopyable
-        AccumulatingVisitor(const AccumulatingVisitor& other);
-        AccumulatingVisitor& operator=(const AccumulatingVisitor& rhs);
     };
 
 
@@ -119,25 +119,25 @@ private:
 public:
 
     /**
-    * Converts a collection of {@link KdNode}s to an vector of {@link geom::Coordinate}s.
+    * Converts a collection of {@link KdNode}s to a vector of {@link geom::Coordinate}s.
     *
-    * @param kdnodes a collection of nodes
-    * @return an vector of the coordinates represented by the nodes
+    * @param kdNodes a collection of nodes
+    * @return a vector of the coordinates represented by the nodes
     */
-    static std::unique_ptr<std::vector<geom::Coordinate>> toCoordinates(std::vector<KdNode*>& kdnodes);
+    static std::vector<geom::Coordinate> toCoordinates(const std::vector<KdNode*>& kdNodes);
 
     /**
     * Converts a collection of {@link KdNode}s
-    * to an vector of {@link geom::Coordinate}s,
+    * to a vector of {@link geom::Coordinate}s,
     * specifying whether repeated nodes should be represented
     * by multiple coordinates.
     *
-    * @param kdnodes a collection of nodes
+    * @param kdNodes a collection of nodes
     * @param includeRepeated true if repeated nodes should
     *   be included multiple times
-    * @return an vector of the coordinates represented by the nodes
+    * @return a vector of the coordinates represented by the nodes
     */
-    static std::unique_ptr<std::vector<geom::Coordinate>> toCoordinates(std::vector<KdNode*>& kdnodes, bool includeRepeated);
+    static std::vector<geom::Coordinate> toCoordinates(const std::vector<KdNode*>& kdNodes, bool includeRepeated);
 
     KdTree() :
         root(nullptr),
@@ -145,7 +145,7 @@ public:
         tolerance(0.0)
         {};
 
-    KdTree(double p_tolerance) :
+    explicit KdTree(double p_tolerance) :
         root(nullptr),
         numberOfNodes(0),
         tolerance(p_tolerance)
@@ -167,7 +167,7 @@ public:
     /**
     * Performs a range search of the points in the index.
     */
-    std::unique_ptr<std::vector<KdNode*>> query(const geom::Envelope& queryEnv);
+    std::vector<KdNode*> query(const geom::Envelope& queryEnv);
 
     /**
     * Performs a range search of the points in the index.

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/io/GeoJSONReader.h

@@ -75,6 +75,7 @@ public:
 private:
 
     const geom::GeometryFactory& geometryFactory;
+    mutable int parseDepth_ = 0;
 
     std::unique_ptr<geom::Geometry> readFeatureForGeometry(const geos_nlohmann::json& j) const;
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/io/WKBReader.h

@@ -124,6 +124,16 @@ public:
      */
     std::unique_ptr<geom::Geometry> readHEX(std::istream& is);
 
+    /**
+     * \brief Reads a Geometry hex format.
+     *
+     * @param hex the string to read
+     * @return the Geometry read
+     * @throws IOException
+     * @throws ParseException
+     */
+    std::unique_ptr<geom::Geometry> readHEX(const std::string& hex);
+
     /**
      * \brief Print WKB in HEX form to out stream
      *
@@ -146,6 +156,8 @@ private:
 
     std::array<double, 4> ordValues;
 
+    int parseDepth_ = 0;
+
     std::unique_ptr<geom::Geometry> readGeometry();
 
     std::unique_ptr<geom::Point> readPoint();

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/io/WKTReader.h

@@ -115,6 +115,7 @@ public:
     }
 
     std::unique_ptr<geom::Geometry> read(const std::string& wellKnownText) const;
+    std::unique_ptr<geom::CoordinateSequence> readCoordinates(const std::string& wellKnownText) const;
 
 protected:
     std::unique_ptr<geom::CoordinateSequence> getCoordinates(io::StringTokenizer* tokenizer, OrdinateSet& ordinates) const;
@@ -148,6 +149,7 @@ private:
     const geom::GeometryFactory* geometryFactory;
     const geom::PrecisionModel* precisionModel;
     bool fixStructure;
+    mutable int parseDepth_ = 0;
 
     void getPreciseCoordinate(io::StringTokenizer* tokenizer, OrdinateSet& ordinateFlags, geom::CoordinateXYZM&) const;
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/linearref/LengthIndexedLine.h

@@ -64,14 +64,13 @@ public:
      *
      * If the index is out of range the first or last point on the
      * line will be returned.
-     * The Z-ordinate of the computed point will be interpolated from
-     * the Z-ordinates of the line segment containing it, if they exist.
+     * The Z and M ordinates of the computed point will be interpolated from
+     * the Z and M ordinates of the line segment containing it, if they exist.
      *
      * @param index the index of the desired point
      * @return the Coordinate at the given index
      */
-    geom::Coordinate extractPoint(double index) const;
-
+    geom::CoordinateXYZM extractPoint(double index) const;
 
     /**
      * \brief
@@ -138,7 +137,7 @@ public:
      * slightly off the line and is equidistant from two different
      * points on the line.
      *
-     * The supplied point does not `*necessarily* have to lie precisely
+     * The supplied point does not *necessarily* have to lie precisely
      * on the line, but if it is far from the line the accuracy and
      * performance of this function is not guaranteed.
      * Use {@link #project} to compute a guaranteed result for points

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/linearref/LinearLocation.h

@@ -84,6 +84,8 @@ public:
      */
     static geom::Coordinate pointAlongSegmentByFraction(const geom::Coordinate& p0, const geom::Coordinate& p1,
             double frac);
+    static geom::CoordinateXYZM pointAlongSegmentByFraction(const geom::CoordinateXYZM& p0, const geom::CoordinateXYZM& p1,
+            double frac);
 
 
     /** \brief
@@ -161,7 +163,7 @@ public:
      * @param linearGeom the linear geometry referenced by this location
      * @return the Coordinate at the location
      */
-    geom::Coordinate getCoordinate(const geom::Geometry* linearGeom) const;
+    geom::CoordinateXYZM getCoordinate(const geom::Geometry* linearGeom) const;
 
     /** \brief
      * Gets a [LineSegment](@ref geom::LineSegment) representing the segment of the

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/math/DD.h

@@ -114,6 +114,7 @@ class GEOS_DLL DD {
         int signum() const;
         DD rint() const;
 
+        void setNaN();
 
     public:
         DD(double p_hi, double p_lo) : hi(p_hi), lo(p_lo) {};
@@ -158,6 +159,7 @@ class GEOS_DLL DD {
         friend GEOS_DLL DD operator* (const DD &lhs, double rhs);
         friend GEOS_DLL DD operator/ (const DD &lhs, const DD &rhs);
         friend GEOS_DLL DD operator/ (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator- (const DD& x);
 
         static DD determinant(const DD &x1, const DD &y1, const DD &x2, const DD &y2);
         static DD determinant(double x1, double y1, double x2, double y2);
@@ -165,6 +167,7 @@ class GEOS_DLL DD {
         static DD pow(const DD &d, int exp);
         static DD trunc(const DD &d);
 
+        bool isInf() const;
         bool isNaN() const;
         bool isNegative() const;
         bool isPositive() const;

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/ArcIntersectionAdder.h

@@ -0,0 +1,44 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025 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/algorithm/CircularArcIntersector.h>
+#include <geos/noding/ArcIntersector.h>
+
+namespace geos::noding {
+
+class GEOS_DLL ArcIntersectionAdder : public ArcIntersector {
+
+public:
+    explicit ArcIntersectionAdder(algorithm::CircularArcIntersector& cai) :
+        m_intersector(cai) {}
+
+    void processIntersections(ArcString& e0, std::size_t segIndex0, ArcString& e1, std::size_t segIndex1) override;
+
+    void processIntersections(ArcString& e0, std::size_t segIndex0, SegmentString& e1, std::size_t segIndex1) override;
+
+    void processIntersections(SegmentString& e0, std::size_t segIndex0, SegmentString& e1, std::size_t segIndex1) override;
+
+private:
+    static bool isAdjacentSegments(std::size_t i1, std::size_t i2);
+
+    bool isTrivialIntersection(const PathString* e0, std::size_t segIndex0,
+                               const PathString* e1, std::size_t segIndex1) const;
+
+    algorithm::CircularArcIntersector& m_intersector;
+};
+
+}

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/ArcIntersector.h

@@ -0,0 +1,44 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025 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/noding/ArcString.h>
+#include <geos/noding/SegmentString.h>
+
+namespace geos::noding {
+
+class GEOS_DLL ArcIntersector {
+public:
+    virtual void processIntersections(ArcString& e0, std::size_t arcIndex0,
+                                      ArcString& e1, std::size_t arcIndex1) = 0;
+    virtual void processIntersections(SegmentString& e0, std::size_t segIndex0,
+                                      SegmentString& e1, std::size_t segIndex1) = 0;
+    virtual void processIntersections(ArcString& e0, std::size_t arcIndex0,
+                                      SegmentString& e1, std::size_t segIndex1) = 0;
+
+    virtual void processIntersections(SegmentString& e0, std::size_t segIndex0,
+                                      ArcString& e1, std::size_t arcIndex1) {
+        processIntersections(e1, arcIndex1, e0, segIndex0);
+    }
+
+    virtual bool isDone() const {
+        return false;
+    }
+
+    virtual ~ArcIntersector() = default;
+};
+
+}

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/ArcNoder.h

@@ -0,0 +1,53 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025 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/noding/ArcIntersector.h>
+#include <geos/noding/Noder.h>
+
+namespace geos::noding {
+class PathString;
+}
+
+namespace geos::noding {
+
+class GEOS_DLL ArcNoder : public Noder {
+
+public:
+    ArcNoder() = default;
+
+    explicit ArcNoder(ArcIntersector& intersector) :
+        m_intersector(&intersector) {}
+
+    ~ArcNoder() override;
+
+    void setArcIntersector(ArcIntersector& arcIntersector) {
+        m_intersector = &arcIntersector;
+    }
+
+    void computeNodes(const std::vector<SegmentString*>& segStrings) override;
+
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
+
+    void computePathNodes(const std::vector<PathString*>& inputPaths) override = 0;
+
+    std::vector<std::unique_ptr<PathString>> getNodedPaths() override = 0;
+
+protected:
+    ArcIntersector* m_intersector{nullptr};
+};
+
+}

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/ArcString.h

@@ -0,0 +1,72 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025 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/CircularArc.h>
+#include <geos/noding/PathString.h>
+
+#include <vector>
+
+namespace geos::noding {
+
+/** \brief
+ *  An interface for classes which represent a sequence of contiguous
+ *  circular arcs, analogous to the SegmentString for contiguous line
+ *  segments.
+ */
+class GEOS_DLL ArcString : public PathString {
+public:
+    explicit ArcString(std::vector<geom::CircularArc> arcs) : m_arcs(std::move(arcs)) {
+    }
+
+    ArcString(std::vector<geom::CircularArc> arcs, const std::shared_ptr<const geom::CoordinateSequence>& seq, const void* p_context)
+        : PathString(p_context),
+          m_arcs(std::move(arcs)),
+          m_seq(seq)
+    {}
+
+    std::size_t getSize() const override {
+        return m_arcs.size();
+    }
+
+    double getLength() const override {
+        double tot = 0;
+        for (const auto &arc: m_arcs) {
+            tot += arc.getLength();
+        }
+        return tot;
+    }
+
+    const geom::CircularArc &getArc(std::size_t i) const {
+        return m_arcs[i];
+    }
+
+    auto begin() const {
+        return m_arcs.begin();
+    }
+
+    auto end() const {
+        return m_arcs.end();
+    }
+
+    const std::shared_ptr<const geom::CoordinateSequence>& getCoordinates() const override;
+
+protected:
+    std::vector<geom::CircularArc> m_arcs;
+    std::shared_ptr<const geom::CoordinateSequence> m_seq;
+};
+
+}

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/BasicSegmentString.h

@@ -50,7 +50,7 @@ public:
     /// @param newPts CoordinateSequence representing the string, externally owned
     /// @param newContext the context associated to this SegmentString
     ///
-    BasicSegmentString(geom::CoordinateSequence* newPts,
+    BasicSegmentString(const std::shared_ptr<const geom::CoordinateSequence>& newPts,
                        const void* newContext)
         :
         SegmentString(newContext, newPts)

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/BoundaryChainNoder.h

@@ -66,8 +66,8 @@ private:
             SegmentString* segString;
             std::vector<bool> isBoundary;
 
-            static SegmentString* createChain(
-                const SegmentString* segString,
+            static std::unique_ptr<SegmentString> createChain(
+                const SegmentString *segString,
                 std::size_t startIndex,
                 std::size_t endIndex,
                 bool constructZ,
@@ -84,7 +84,7 @@ private:
                 };
 
             void setBoundarySegment(std::size_t index);
-            void createChains(std::vector<SegmentString*>& chains, bool constructZ, bool constructM);
+            void createChains(std::vector<std::unique_ptr<SegmentString>> &chains, bool constructZ, bool constructM);
     };
 
     class Segment {
@@ -137,26 +137,25 @@ public:
     using SegmentSet = std::unordered_set<Segment, Segment::HashCode>;
 
     BoundaryChainNoder()
-        : m_chainList(nullptr)
-        , m_constructZ(false)
+        : m_constructZ(false)
         , m_constructM(false)
         {};
 
     // Noder virtual methods
-    std::vector<SegmentString*>* getNodedSubstrings() const override;
-    void computeNodes(std::vector<SegmentString*>* inputSegStrings) override;
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
+    void computeNodes(const std::vector<SegmentString*>& inputSegStrings) override;
 
 
 private:
 
     // Members
-    std::vector<SegmentString*>* m_chainList;
+    std::vector<std::unique_ptr<SegmentString>> m_chainList;
     std::vector<std::unique_ptr<geom::CoordinateSequence>> m_substrings;
     bool m_constructZ;
     bool m_constructM;
 
     // Methods
-    void addSegments(std::vector<SegmentString*>* segStrings,
+    void addSegments(const std::vector<SegmentString*>& segStrings,
         SegmentSet& segSet,
         std::vector<BoundaryChainMap>& includedSegs);
 
@@ -169,26 +168,26 @@ private:
 
     static void markBoundarySegments(SegmentSet& segSet);
 
-    std::vector<SegmentString*>* extractChains(std::vector<BoundaryChainMap>& sections) const;
+    std::vector<std::unique_ptr<SegmentString>> extractChains(std::vector<BoundaryChainMap>& sections) const;
 
-    Coordinate::UnorderedSet findNodePts(
-        const std::vector<SegmentString*>* segStrings) const;
+    static Coordinate::UnorderedSet findNodePts(
+        const std::vector<std::unique_ptr<SegmentString>>& segStrings);
 
-    std::vector<SegmentString*>* nodeChains(
-        const std::vector<SegmentString*>* chains,
-        const Coordinate::UnorderedSet& nodePts);
+    static std::vector<std::unique_ptr<SegmentString>> nodeChains(
+        std::vector<std::unique_ptr<SegmentString>> &chains,
+        const Coordinate::UnorderedSet &nodePts);
 
-    void nodeChain(
-        SegmentString* chain,
-        const Coordinate::UnorderedSet& nodePts,
-        std::vector<SegmentString*>* nodedChains);
+    static void nodeChain(
+        std::unique_ptr<SegmentString> chain,
+        const Coordinate::UnorderedSet &nodePts,
+        std::vector<std::unique_ptr<SegmentString>> &nodedChains);
 
-    std::size_t findNodeIndex(
+    static std::size_t findNodeIndex(
         const SegmentString* chain,
         std::size_t start,
-        const Coordinate::UnorderedSet& nodePts) const;
+        const Coordinate::UnorderedSet& nodePts);
 
-    noding::BasicSegmentString* substring(
+    static std::unique_ptr<BasicSegmentString> substring(
         const SegmentString* segString,
         std::size_t start, std::size_t end);
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/DirectionIndependentArcString.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 <memory>
+#include <geos/export.h>
+
+
+namespace geos::noding {
+class ArcString;
+}
+
+namespace geos::noding {
+
+/// The DirectionIndependentArcString is a thin wrapper over an ArcString that provides specialized
+/// equality-testing and hashing functions. DirectionIndependentArcStrings are considered equal
+/// if they cover the same path, regardless of direction. The control points of arcs are not required
+/// to be identical, but must describe the same arc.
+class GEOS_DLL DirectionIndependentArcString {
+
+public:
+
+    explicit DirectionIndependentArcString(const ArcString& as) : m_as(as) {}
+
+    const ArcString& getArcString() const
+    {
+        return m_as;
+    }
+
+    bool operator==(const DirectionIndependentArcString& other) const;
+
+private:
+    const ArcString& m_as;
+};
+}
+
+template<>
+struct GEOS_DLL std::hash<geos::noding::DirectionIndependentArcString> {
+    std::size_t operator()(const geos::noding::DirectionIndependentArcString& as) const noexcept;
+};