@crossbind/port-geos-linuxmusl 0.0.0-bootstrap.0 → 2.0.0-beta.63

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/CoordinateSequenceFilter.h

@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009  Sandro Santilli <strk@kbt.io>
+ *
+ * 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/CoordinateSequenceFilter.java rev. 1.3 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <cassert>
+#include <cstddef>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+
+/** \brief
+ * Interface for classes which provide operations that can be applied to
+ * the coordinates in a CoordinateSequence.
+ *
+ * A CoordinateSequence filter can either record information about each
+ * coordinate or change the coordinate in some way.
+ * CoordinateSequence filters can be used to implement such things as
+ * coordinate transformations, centroid and envelope computation, and many
+ * other functions.
+ * For maximum efficiency, the execution of filters can be short-circuited.
+ * Geometry classes support the concept of applying a CoordinateSequenceFilter
+ * to each CoordinateSequences they contain.
+ *
+ * CoordinateSequenceFilter is an example of the Gang-of-Four Visitor pattern.
+ *
+ * @see Geometry::apply_ro(CoordinateSequenceFilter& filter) const
+ * @see Geometry::apply_rw(CoordinateSequenceFilter& filter)
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL CoordinateSequenceFilter {
+
+public:
+
+    virtual
+    ~CoordinateSequenceFilter() {}
+
+    /** \brief
+     * Performs an operation on a coordinate in a CoordinateSequence.
+     *
+     * **param** `seq`  the CoordinateSequence to which the filter is applied
+     * **param** `i` the index of the coordinate to apply the filter to
+     */
+    virtual void
+    filter_rw(CoordinateSequence& /*seq*/, std::size_t /*i*/)
+    {
+        assert(0);
+    }
+
+    /** \brief
+     * Performs an operation on a coordinate in a CoordinateSequence.
+     *
+     * **param** `seq`  the CoordinateSequence to which the filter is applied
+     * **param** `i` the index of the coordinate to apply the filter to
+     */
+    virtual void
+    filter_ro(const CoordinateSequence& /*seq*/, std::size_t /*i*/)
+    {
+        assert(0);
+    }
+
+    /** \brief
+     * Reports whether the application of this filter can be terminated.
+     *
+     * Once this method returns `false`, it should continue to return
+     * `false` on every subsequent call.
+     *
+     * @return `true` if the application of this filter can be terminated.
+     */
+    virtual bool isDone() const = 0;
+
+
+    /** \brief
+     * Reports whether the execution of this filter has modified
+     * the coordinates of the geometry.
+     *
+     * If so, Geometry::geometryChanged() will be executed after this
+     * filter has finished being executed.
+     *
+     * Most filters can simply return a constant value reflecting whether
+     * they are able to change the coordinates.
+     *
+     * @return `true` if this filter has changed the coordinates of the geometry
+     */
+    virtual bool isGeometryChanged() const = 0;
+
+};
+
+} // namespace geos::geom
+} // namespace geos
+
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/CoordinateSequenceIterator.h

@@ -0,0 +1,126 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2022 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 <cstddef>
+#include <iterator>
+
+namespace geos {
+namespace geom {
+
+template<typename SequenceType, typename CoordinateType>
+class CoordinateSequenceIterator {
+
+public:
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = CoordinateType;
+    using reference = CoordinateType&;
+    using pointer = CoordinateType;
+    using difference_type = std::ptrdiff_t;
+
+private:
+    SequenceType* m_seq;
+    difference_type m_pos;
+
+public:
+    CoordinateSequenceIterator(SequenceType* seq) : m_seq(seq), m_pos(0) {}
+
+    CoordinateSequenceIterator(SequenceType* seq, std::size_t size) : m_seq(seq), m_pos(static_cast<difference_type>(size)) {}
+
+    reference operator*() const {
+        return m_seq->template getAt<value_type>(static_cast<std::size_t>(m_pos));
+    }
+
+    pointer operator->() const {
+        return &m_seq->template getAt<value_type>(static_cast<std::size_t>(m_pos));
+    }
+
+    CoordinateSequenceIterator& operator++() {
+        m_pos++;
+        return *this;
+    }
+
+    CoordinateSequenceIterator operator++(int) {
+        CoordinateSequenceIterator ret = *this;
+        m_pos++;
+        return ret;
+    }
+
+    CoordinateSequenceIterator& operator--() {
+        m_pos--;
+        return *this;
+    }
+
+    CoordinateSequenceIterator operator--(int) {
+        CoordinateSequenceIterator ret = *this;
+        m_pos--;
+        return ret;
+    }
+
+    difference_type operator-(const CoordinateSequenceIterator& other) const {
+        return this->m_pos - other.m_pos;
+    }
+
+    CoordinateSequenceIterator operator+(difference_type n) const {
+        return CoordinateSequenceIterator(m_seq, static_cast<std::size_t>(m_pos + n));
+    }
+
+    CoordinateSequenceIterator operator+=(difference_type n) {
+        this->m_pos += n;
+        return *this;
+    }
+
+    CoordinateSequenceIterator operator-(difference_type n) const {
+        return CoordinateSequenceIterator(m_seq, static_cast<std::size_t>(m_pos - n));
+    }
+
+    CoordinateSequenceIterator operator-=(difference_type n) {
+        this->m_pos -= n;
+        return *this;
+    }
+
+    CoordinateType& operator[](difference_type n) const {
+        return *(*this + n);
+    }
+
+    bool operator==(const CoordinateSequenceIterator& other) const {
+        return this->m_pos == other.m_pos;
+    }
+
+    bool operator!=(const CoordinateSequenceIterator& other) const {
+        return !(*this == other);
+    }
+
+    bool operator<(const CoordinateSequenceIterator& other) const {
+        return this->m_pos < other.m_pos;
+    }
+
+    bool operator<=(const CoordinateSequenceIterator& other) const {
+        return this->m_pos <= other.m_pos;
+    }
+
+    bool operator>(const CoordinateSequenceIterator& other) const {
+        return this->m_pos > other.m_pos;
+    }
+
+    bool operator>=(const CoordinateSequenceIterator& other) const {
+        return this->m_pos >= other.m_pos;
+    }
+
+};
+
+}
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/CoordinateSequences.h

@@ -0,0 +1,76 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 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/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+
+namespace geos {
+namespace geom {
+
+///
+/// \brief The CoordinateSequences class provides utility methods to operate
+///        on CoordinateSequences. Methods that do not benefit from access to the
+/// 	   CoordinateSequence internals can be placed here.
+///
+class CoordinateSequences {
+
+private:
+    template<typename CoordinateType>
+    static constexpr int
+    type_pair(const CoordinateType& typ1, const CoordinateType& typ2) {
+        return (static_cast<int>(typ1) << 4) | static_cast<int>(typ2);
+    }
+
+public:
+    ///
+    /// \brief binaryDispatch calls a functor template, explicitly providing the backing types of two CoordinateSequences. The
+    /// CoordinateSequences are not provided to the functor as arguments but can be provided along with any other arguments
+    /// through the `args` argument.
+    template<typename F, class... Args>
+    static void binaryDispatch(const CoordinateSequence& seq1, const CoordinateSequence& seq2, F& fun, Args... args)
+    {
+        using CoordinateXYZ = Coordinate;
+
+        auto typ1 = seq1.getCoordinateType();
+        auto typ2 = seq2.getCoordinateType();
+
+        switch(type_pair(typ1, typ2)) {
+            case type_pair(CoordinateType::XY, CoordinateType::XY):     fun.template operator()<CoordinateXY, CoordinateXY>(args...);   break;
+            case type_pair(CoordinateType::XY, CoordinateType::XYZ):    fun.template operator()<CoordinateXY, CoordinateXYZ>(args...);  break;
+            case type_pair(CoordinateType::XY, CoordinateType::XYM):    fun.template operator()<CoordinateXY, CoordinateXYM>(args...);  break;
+            case type_pair(CoordinateType::XY, CoordinateType::XYZM):   fun.template operator()<CoordinateXY, CoordinateXYZM>(args...); break;
+
+            case type_pair(CoordinateType::XYZ, CoordinateType::XY):    fun.template operator()<CoordinateXYZ, CoordinateXY>(args...);   break;
+            case type_pair(CoordinateType::XYZ, CoordinateType::XYZ):   fun.template operator()<CoordinateXYZ, CoordinateXYZ>(args...);  break;
+            case type_pair(CoordinateType::XYZ, CoordinateType::XYM):   fun.template operator()<CoordinateXYZ, CoordinateXYM>(args...);  break;
+            case type_pair(CoordinateType::XYZ, CoordinateType::XYZM):  fun.template operator()<CoordinateXYZ, CoordinateXYZM>(args...); break;
+
+            case type_pair(CoordinateType::XYM, CoordinateType::XY):    fun.template operator()<CoordinateXYM, CoordinateXY>(args...);   break;
+            case type_pair(CoordinateType::XYM, CoordinateType::XYZ):   fun.template operator()<CoordinateXYM, CoordinateXYZ>(args...);  break;
+            case type_pair(CoordinateType::XYM, CoordinateType::XYM):   fun.template operator()<CoordinateXYM, CoordinateXYM>(args...);  break;
+            case type_pair(CoordinateType::XYM, CoordinateType::XYZM):  fun.template operator()<CoordinateXYM, CoordinateXYZM>(args...); break;
+
+            case type_pair(CoordinateType::XYZM, CoordinateType::XY):   fun.template operator()<CoordinateXYZM, CoordinateXY>(args...);   break;
+            case type_pair(CoordinateType::XYZM, CoordinateType::XYZ):  fun.template operator()<CoordinateXYZM, CoordinateXYZ>(args...);  break;
+            case type_pair(CoordinateType::XYZM, CoordinateType::XYM):  fun.template operator()<CoordinateXYZM, CoordinateXYM>(args...);  break;
+            case type_pair(CoordinateType::XYZM, CoordinateType::XYZM): fun.template operator()<CoordinateXYZM, CoordinateXYZM>(args...); break;
+        }
+    }
+
+};
+
+}
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/Curve.h

@@ -0,0 +1,103 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 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/geom/Geometry.h>
+
+namespace geos::geom {
+    class LineString;
+}
+
+namespace geos {
+namespace geom {
+
+class SimpleCurve;
+
+class GEOS_DLL Curve : public Geometry {
+
+public:
+    using Geometry::apply_ro;
+    using Geometry::apply_rw;
+
+    void apply_ro(GeometryComponentFilter* filter) const override;
+
+    void apply_ro(GeometryFilter* filter) const override;
+
+    void apply_rw(GeometryComponentFilter* filter) override;
+
+    void apply_rw(GeometryFilter* filter) override;
+
+    /**
+     * \brief
+     * Returns Dimension::False for a closed Curve,
+     * 0 otherwise (Curve boundary is a MultiPoint)
+     */
+    int
+    getBoundaryDimension() const override
+    {
+        return isClosed() ? Dimension::False : 0;
+    }
+
+    /// Returns line dimension (1)
+    Dimension::DimensionType getDimension() const override
+    {
+        return Dimension::L; // line
+    }
+
+    virtual const CoordinateXY& getEndCoordinate() const = 0;
+
+    /// \brief
+    /// Return the end point of the Curve
+    /// or NULL if this is an EMPTY Curve.
+    virtual std::unique_ptr<Point> getEndPoint() const = 0;
+
+    /// \brief
+    /// Return the n'th point of the Curve
+    /// or NULL if this is an EMPTY Curve.
+    virtual std::unique_ptr<Point> getPointN(std::size_t n) const = 0;
+
+    virtual const CoordinateXY& getStartCoordinate() const = 0;
+
+    /// \brief
+    /// Return the start point of the Curve
+    /// or NULL if this is an EMPTY Curve.
+    virtual std::unique_ptr<Point> getStartPoint() const = 0;
+
+    std::unique_ptr<LineString> getLinearized(const algorithm::CurveToLineParams&) const;
+
+    std::unique_ptr<Curve> getCurved(const algorithm::LineToCurveParams&) const;
+
+    /// Returns true if the first and last coordinate in the Curve are the same
+    virtual bool isClosed() const = 0;
+
+    /// Returns true if the curve is closed and simple
+    bool isRing() const;
+
+    virtual std::size_t getNumCurves() const = 0;
+
+    virtual const SimpleCurve* getCurveN(std::size_t) const = 0;
+
+    std::unique_ptr<Curve> clone() const;
+
+    std::unique_ptr<Curve> reverse() const;
+
+protected:
+    Curve(const GeometryFactory& factory) : Geometry(&factory) {}
+
+    Curve* getCurvedImpl(const algorithm::LineToCurveParams&) const override = 0;
+};
+
+}
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/CurvePolygon.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 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/geom/SurfaceImpl.h>
+#include <geos/geom/Polygon.h>
+
+namespace geos {
+namespace geom {
+
+class GEOS_DLL CurvePolygon : public SurfaceImpl<Curve> {
+    friend class GeometryFactory;
+
+public:
+    ~CurvePolygon() override = default;
+
+    double getArea() const override;
+
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    std::unique_ptr<CoordinateSequence> getCoordinates() const override;
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    std::unique_ptr<CurvePolygon> getCurved(const algorithm::LineToCurveParams&) {
+        return std::unique_ptr<CurvePolygon>(cloneImpl());
+    }
+
+    std::unique_ptr<Polygon> getLinearized(const algorithm::CurveToLineParams&) const;
+
+    bool hasCurvedComponents() const override;
+
+    bool hasCurvedTypes() const override {
+        return true;
+    }
+
+    void normalize() override;
+
+protected:
+    using SurfaceImpl::SurfaceImpl;
+
+    CurvePolygon* cloneImpl() const override;
+
+    Polygon* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
+    CurvePolygon* getCurvedImpl(const algorithm::LineToCurveParams&) const override { return cloneImpl(); }
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_CURVEPOLYGON;
+    }
+
+    Geometry* reverseImpl() const override;
+};
+
+
+}
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/Dimension.h

@@ -0,0 +1,64 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+namespace geos {
+namespace geom { // geos::geom
+
+/// Constants representing the dimensions of a point, a curve and a surface.
+///
+/// Also, constants representing the dimensions of the empty geometry and
+/// non-empty geometries, and a wildcard dimension meaning "any dimension".
+///
+class GEOS_DLL Dimension {
+public:
+    enum DimensionType {
+        /// Dimension value for any dimension (= {FALSE, TRUE}).
+        DONTCARE = -3,
+
+        /// Dimension value of non-empty geometries (= {P, L, A}).
+        True = -2,
+
+        /// Dimension value of the empty geometry (-1).
+        False = -1,
+
+        /// Dimension value of a point (0).
+        P = 0,
+
+        /// Dimension value of a curve (1).
+        L = 1,
+
+        /// Dimension value of a surface (2).
+        A = 2
+    };
+
+    //static const int P = 0;			/// Dimension value of a point (0).
+    //static const int L = 1;			/// Dimension value of a curve (1).
+    //static const int A = 2;			/// Dimension value of a surface (2).
+    //static const int False = -1;	/// Dimension value of the empty geometry (-1).
+    //static const int True = -2;		/// Dimension value of non-empty geometries (= {P, L, A}).
+    //static const int DONTCARE = -3;	/// Dimension value for any dimension (= {FALSE, TRUE}).
+    static char toDimensionSymbol(int dimensionValue);
+
+    static int toDimensionValue(char dimensionSymbol);
+
+};
+
+} // namespace geos::geom
+} // namespace geos
+
+