@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.64

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/io/CLocalizer.h

@@ -0,0 +1,53 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2008 Sean Gillies
+ *
+ * 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: ORIGINAL WORK
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <string>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+namespace geos {
+namespace io {
+
+/**
+ * \class CLocalizer io.h geos.h
+ */
+class GEOS_DLL CLocalizer {
+public:
+
+    CLocalizer();
+    ~CLocalizer();
+
+private:
+
+    std::string saved_locale;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+} // namespace io
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/io/CheckOrdinatesFilter.h

@@ -0,0 +1,68 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/CoordinateSequenceFilter.h>
+#include <geos/io/OrdinateSet.h>
+
+namespace geos {
+namespace io {
+
+class CheckOrdinatesFilter : public geom::CoordinateSequenceFilter {
+public:
+    CheckOrdinatesFilter(OrdinateSet checkOrdinateFlags) :
+        m_checkFlags(checkOrdinateFlags),
+        m_foundFlags(OrdinateSet::createXY())
+    {}
+
+    void filter_ro(const geom::CoordinateSequence& seq, std::size_t i) override {
+        bool checkZ = m_checkFlags.hasZ() && !m_foundFlags.hasZ();
+        bool checkM = m_checkFlags.hasM() && !m_foundFlags.hasM();
+
+        if (checkZ || checkM) {
+            seq.getAt(i, m_coord);
+
+            if (checkZ && !std::isnan(m_coord.z)) {
+                m_foundFlags.setZ(true);
+            }
+
+            if (checkM && !std::isnan(m_coord.m)) {
+                m_foundFlags.setM(true);
+            }
+        }
+    }
+
+    bool isGeometryChanged() const override {
+        return false;
+    }
+
+    bool isDone() const override {
+        return m_checkFlags == m_foundFlags;
+    }
+
+    OrdinateSet getFoundOrdinates() const {
+        return m_foundFlags;
+    }
+
+private:
+    OrdinateSet m_checkFlags;
+    OrdinateSet m_foundFlags;
+    geom::CoordinateXYZM m_coord;
+};
+
+}
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/io/GeoJSON.h

@@ -0,0 +1,154 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Jared Erickson
+ *
+ * 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 <map>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <cctype>
+#include <cstddef>
+#include <geos/geom/Geometry.h>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {
+namespace io {
+
+class GEOS_DLL GeoJSONValue {
+
+private:
+
+    enum class Type { NUMBER, STRING, NULLTYPE, BOOLEAN, OBJECT, ARRAY };
+
+    Type type;
+
+    union {
+        double d;
+        std::string s;
+        std::nullptr_t n;
+        bool b;
+        std::map<std::string, GeoJSONValue> o;
+        std::vector<GeoJSONValue> a;
+    };
+
+    void cleanup();
+
+public:
+
+    struct GeoJSONTypeError {};
+
+    GeoJSONValue(double);
+    GeoJSONValue(const std::string&);
+    GeoJSONValue();
+    GeoJSONValue(bool);
+    GeoJSONValue(const std::map<std::string, GeoJSONValue>&);
+    GeoJSONValue(const std::vector<GeoJSONValue>&);
+
+    ~GeoJSONValue();
+    GeoJSONValue(const GeoJSONValue&);
+    GeoJSONValue& operator=(const GeoJSONValue&);
+
+    double getNumber() const;
+    const std::string& getString() const;
+    std::nullptr_t getNull() const;
+    bool getBoolean() const;
+    const std::map<std::string, GeoJSONValue>& getObject() const;
+    const std::vector<GeoJSONValue>& getArray() const;
+
+    bool isNumber() const;
+    bool isString() const;
+    bool isNull() const;
+    bool isBoolean() const;
+    bool isObject() const;
+    bool isArray() const;
+
+};
+
+class GEOS_DLL GeoJSONFeature {
+
+public:
+
+    GeoJSONFeature(std::unique_ptr<geom::Geometry> g,
+                   const std::map<std::string, GeoJSONValue>& p);
+
+    GeoJSONFeature(std::unique_ptr<geom::Geometry> g,
+                   std::map<std::string, GeoJSONValue>&& p);
+
+    GeoJSONFeature(std::unique_ptr<geom::Geometry> g,
+                   const std::map<std::string, GeoJSONValue>& p,
+                   const std::string& id);
+
+    GeoJSONFeature(std::unique_ptr<geom::Geometry> g,
+                   std::map<std::string, GeoJSONValue>&& p, std::string id);
+
+    GeoJSONFeature(GeoJSONFeature const& other);
+
+    GeoJSONFeature(GeoJSONFeature&& other);
+
+    GeoJSONFeature& operator=(const GeoJSONFeature&);
+
+    GeoJSONFeature& operator=(GeoJSONFeature&&);
+
+    const geom::Geometry* getGeometry() const;
+
+    const std::map<std::string, GeoJSONValue>& getProperties() const;
+
+    const std::string& getId() const;
+
+private:
+
+    std::unique_ptr<geom::Geometry> geometry;
+
+    std::map<std::string, GeoJSONValue> properties;
+
+    std::string id;
+
+};
+
+class GEOS_DLL GeoJSONFeatureCollection {
+
+public:
+
+    GeoJSONFeatureCollection(const std::vector<GeoJSONFeature>& f);
+
+    GeoJSONFeatureCollection(std::vector<GeoJSONFeature>&& f);
+
+    const std::vector<GeoJSONFeature>& getFeatures() const;
+
+private:
+
+    std::vector<GeoJSONFeature> features;
+
+};
+
+} // namespace geos::io
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/io/GeoJSONReader.h

@@ -0,0 +1,126 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Jared Erickson
+ *
+ * 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/io/GeoJSON.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+#include <string>
+#include "geos/vend/include_nlohmann_json.hpp"
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class GeometryCollection;
+class Point;
+class LineString;
+class LinearRing;
+class Polygon;
+class MultiPoint;
+class MultiLineString;
+class MultiPolygon;
+class PrecisionModel;
+}
+}
+
+namespace geos {
+namespace io {
+
+/**
+ * \class GeoJSONReader
+ * \brief GeoJSON reader class; see also GeoJSONWriter.
+ */
+class GEOS_DLL GeoJSONReader {
+public:
+
+    /**
+     * \brief Initialize parser with given GeometryFactory.
+     *
+     * Note that all Geometry objects created by the
+     * parser will contain a pointer to the given factory
+     * so be sure you'll keep the factory alive for the
+     * whole GeoJSONReader and created Geometry life.
+     */
+    GeoJSONReader(const geom::GeometryFactory& gf);
+
+    /**
+     * \brief Initialize parser with default GeometryFactory.
+     *
+     */
+    GeoJSONReader();
+
+    ~GeoJSONReader() = default;
+
+    /// Parse a GeoJSON string returning a Geometry
+    std::unique_ptr<geom::Geometry> read(const std::string& geoJsonText) const;
+
+    GeoJSONFeatureCollection readFeatures(const std::string& geoJsonText) const;
+
+private:
+
+    const geom::GeometryFactory& geometryFactory;
+    mutable int parseDepth_ = 0;
+
+    std::unique_ptr<geom::Geometry> readFeatureForGeometry(const geos_nlohmann::json& j) const;
+
+    GeoJSONFeature readFeature(const geos_nlohmann::json& j) const;
+
+    std::map<std::string, GeoJSONValue> readProperties(const geos_nlohmann::json& p) const;
+
+    GeoJSONValue readProperty(const geos_nlohmann::json& p) const;
+
+    std::unique_ptr<geom::Geometry> readFeatureCollectionForGeometry(
+        const geos_nlohmann::json& j) const;
+
+    GeoJSONFeatureCollection readFeatureCollection(
+        const geos_nlohmann::json& j) const;
+
+    std::unique_ptr<geom::Geometry> readGeometry(
+        const geos_nlohmann::json& j) const;
+
+    std::unique_ptr<geom::Point> readPoint(const geos_nlohmann::json& j) const;
+
+    geom::Coordinate readCoordinate(const std::vector<double>& coords) const;
+
+    std::unique_ptr<geom::LineString> readLineString(
+        const geos_nlohmann::json& j) const;
+
+    std::unique_ptr<geom::Polygon> readPolygon(
+        const geos_nlohmann::json& j) const;
+
+    std::unique_ptr<geom::Polygon> readPolygon(
+        const std::vector<std::vector<std::vector<double>>>& c) const;
+
+    std::unique_ptr<geom::MultiPoint> readMultiPoint(
+        const geos_nlohmann::json& j) const;
+
+    std::unique_ptr<geom::MultiLineString> readMultiLineString(
+        const geos_nlohmann::json& j) const;
+
+    std::unique_ptr<geom::MultiPolygon> readMultiPolygon(
+        const geos_nlohmann::json& j) const;
+
+    std::unique_ptr<geom::GeometryCollection> readGeometryCollection(
+        const geos_nlohmann::json& j) const;
+
+};
+
+} // namespace io
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/io/GeoJSONWriter.h

@@ -0,0 +1,153 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Jared Erickson
+ *
+ * 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 "GeoJSON.h"
+#include <string>
+#include <cctype>
+#include "geos/vend/include_nlohmann_json.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class Geometry;
+class GeometryCollection;
+class Point;
+class LineString;
+class LinearRing;
+class Polygon;
+class MultiPoint;
+class MultiLineString;
+class MultiPolygon;
+class PrecisionModel;
+}
+namespace io {
+class Writer;
+}
+}
+
+
+namespace geos {
+namespace io {
+
+enum class GeoJSONType {
+    GEOMETRY, FEATURE, FEATURE_COLLECTION
+};
+
+/**
+ * \class GeoJSONWriter
+ *
+ * \brief Outputs the GeoJSON representation of a Geometry.
+ * See also GeoJSONReader for parsing.
+ *
+ */
+class GEOS_DLL GeoJSONWriter {
+public:
+    ~GeoJSONWriter() = default;
+
+    std::string write(const geom::Geometry* geometry, GeoJSONType type = GeoJSONType::GEOMETRY);
+
+    std::string writeFormatted(const geom::Geometry* geometry, GeoJSONType type = GeoJSONType::GEOMETRY, int indent = 4);
+
+    std::string write(const GeoJSONFeature& feature);
+
+    std::string write(const GeoJSONFeatureCollection& features);
+
+    /*
+     * \brief
+     * Returns the output dimension used by the
+     * <code>GeoJSONWriter</code>.
+     */
+    int
+    getOutputDimension() const
+    {
+        return defaultOutputDimension;
+    }
+
+    /*
+     * Sets the output dimension used by the <code>GeoJSONWriter</code>.
+     *
+     * @param newOutputDimension Supported values are 2 or 3.
+     *        Default since GEOS 3.12 is 3.
+     *        Note that 3 indicates up to 3 dimensions will be
+     *        written but 2D GeoJSON is still produced for 2D geometries.
+     */
+    void setOutputDimension(uint8_t newOutputDimension);
+
+    /*
+     * Sets whether the GeoJSON should be output following counter-clockwise orientation aka Right Hand Rule defined in
+     * RFC7946. See <a href="https://tools.ietf.org/html/rfc7946#section-3.1.6">RFC 7946 Specification</a>
+     * for more context.
+     *
+     * @param newIsForceCCW true if the GeoJSON should be output following the RFC7946
+     *                      counter-clockwise orientation aka Right Hand Rule
+     */
+    void setForceCCW(bool newIsForceCCW);
+
+private:
+    uint8_t defaultOutputDimension = 3;
+
+    bool isForceCCW = false;
+
+    std::vector<double> convertCoordinate(const geom::Coordinate* c);
+
+    std::vector<std::vector<double>> convertCoordinateSequence(const geom::CoordinateSequence* c);
+
+    std::vector<std::vector<std::vector<double>>> convertLinearRings(const geom::Polygon *poly);
+
+    void encode(const geom::Geometry* g, GeoJSONType type, geos_nlohmann::ordered_json& j);
+
+    void encodeGeometry(const geom::Geometry* g, geos_nlohmann::ordered_json& j);
+
+    void encodePoint(const geom::Point* p, geos_nlohmann::ordered_json& j);
+
+    void encodeLineString(const geom::LineString* l, geos_nlohmann::ordered_json& j);
+
+    void encodePolygon(const geom::Polygon* p, geos_nlohmann::ordered_json& j);
+
+    void encodeMultiPoint(const geom::MultiPoint* p, geos_nlohmann::ordered_json& j);
+
+    void encodeMultiLineString(const geom::MultiLineString* l, geos_nlohmann::ordered_json& j);
+
+    void encodeMultiPolygon(const geom::MultiPolygon* m, geos_nlohmann::ordered_json& j);
+
+    void encodeGeometryCollection(const geom::GeometryCollection* g, geos_nlohmann::ordered_json& j);
+
+    void encodeFeature(const geom::Geometry* g, geos_nlohmann::ordered_json& j);
+
+    void encodeFeatureCollection(const geom::Geometry* g, geos_nlohmann::ordered_json& j);
+
+    void encodeFeature(const GeoJSONFeature& feature, geos_nlohmann::ordered_json& j);
+
+    void encodeGeoJSONValue(const std::string& key, const GeoJSONValue& value, geos_nlohmann::ordered_json& j);
+
+};
+
+} // namespace geos::io
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/io/OrdinateSet.h

@@ -0,0 +1,119 @@
+/**********************************************************************
+ *
+ * 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 <geos/export.h>
+#include <geos/util/GEOSException.h>
+
+namespace geos {
+namespace io {
+
+/**
+ * \class OrdinateSet
+ * \brief Utility class to manipulate a set of flags indicating whether
+ *        X, Y, Z, or M dimensions are present.
+ *        Based on JTS EnumSet<Ordinate>.
+ */
+class GEOS_DLL OrdinateSet {
+private:
+    enum Ordinate : unsigned char {
+        X = 1,
+        Y = 2,
+        Z = 4,
+        M = 8,
+    };
+
+    enum Ordinates : unsigned char {
+        XY = Ordinate::X | Ordinate::Y,
+        XYZ = Ordinate::X | Ordinate::Y | Ordinate::Z,
+        XYM = Ordinate::X | Ordinate::Y | Ordinate::M,
+        XYZM = Ordinate::X | Ordinate::Y | Ordinate::Z | Ordinate::M
+    };
+
+    explicit OrdinateSet(Ordinates o) : m_value(o), m_changesAllowed(true) {}
+
+    Ordinates m_value;
+    bool m_changesAllowed;
+
+public:
+
+    static OrdinateSet createXY() {
+        return OrdinateSet(Ordinates::XY);
+    }
+
+    static OrdinateSet createXYZ() {
+        return OrdinateSet(Ordinates::XYZ);
+    }
+
+    static OrdinateSet createXYM() {
+        return OrdinateSet(Ordinates::XYM);
+    }
+
+    static OrdinateSet createXYZM() {
+        return OrdinateSet(Ordinates::XYZM);
+    }
+
+    void setZ(bool value) {
+        if (hasZ() != value) {
+            if (m_changesAllowed) {
+                m_value = static_cast<Ordinates>(static_cast<unsigned char>(m_value) ^ Ordinate::Z);
+            } else {
+                throw util::GEOSException("Cannot add additional ordinates.");
+            }
+        }
+    }
+
+    void setM(bool value) {
+        if (hasM() != value) {
+            if (m_changesAllowed){
+                m_value = static_cast<Ordinates>(static_cast<unsigned char>(m_value) ^ Ordinate::M);
+            } else {
+                throw util::GEOSException("Cannot add additional ordinates.");
+            }
+        }
+    }
+
+    bool hasZ() const {
+        return static_cast<unsigned char>(m_value) & static_cast<unsigned char>(Ordinate::Z);
+    }
+
+    bool hasM() const {
+        return static_cast<unsigned char>(m_value) & static_cast<unsigned char>(Ordinate::M);
+    }
+
+     int size() const {
+        return 2 + hasZ() + hasM();
+    }
+
+    bool changesAllowed() const {
+        return m_changesAllowed;
+    }
+
+    void setChangesAllowed(bool allowed) {
+        m_changesAllowed = allowed;
+    }
+
+    bool operator==(const OrdinateSet& other) const {
+        return this->m_value == other.m_value;
+    }
+
+    bool operator!=(const OrdinateSet& other) const {
+        return !(*this == other);
+    }
+
+};
+
+}
+}