@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0-beta.23

package/dist/prebuilt/Android-x86_64/include/geos/geom/LineString.h

@@ -0,0 +1,151 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005 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.
+ *
+ **********************************************************************
+ *
+ * Last port: geom/LineString.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Geometry.h> // for inheritance
+#include <geos/geom/CoordinateSequence.h> // for proper use of unique_ptr<>
+#include <geos/geom/Envelope.h> // for proper use of unique_ptr<>
+#include <geos/geom/Dimension.h> // for Dimension::DimensionType
+#include <geos/geom/SimpleCurve.h>
+
+#include <string>
+#include <vector>
+#include <memory> // for unique_ptr
+
+
+#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 Coordinate;
+class CoordinateSequenceFilter;
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+
+/**
+ *  Models an OGC-style <code>LineString</code>.
+ *
+ *  A LineString consists of a sequence of two or more vertices,
+ *  along with all points along the linearly-interpolated curves
+ *  (line segments) between each
+ *  pair of consecutive vertices.
+ *  Consecutive vertices may be equal.
+ *  The line segments in the line may intersect each other (in other words,
+ *  the linestring may "curl back" in itself and self-intersect).
+ *  Linestrings with exactly two identical points are invalid.
+ *
+ *  A linestring must have either 0 or 2 or more points.
+ *  If these conditions are not met, the constructors throw
+ *  an {@link util::IllegalArgumentException}.
+ */
+class GEOS_DLL LineString: public SimpleCurve {
+
+public:
+
+    friend class GeometryFactory;
+
+    /// A vector of const LineString pointers
+    typedef std::vector<const LineString*> ConstVect;
+
+    ~LineString() override;
+
+    /**
+     * \brief
+     * Creates and returns a full copy of this {@link LineString} object
+     * (including all coordinates contained by it)
+     *
+     * @return A clone of this instance
+     */
+    std::unique_ptr<LineString> clone() const
+    {
+        return std::unique_ptr<LineString>(cloneImpl());
+    }
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    double getLength() const override;
+
+    bool isCurved() const override {
+        return false;
+    }
+
+    /**
+     * Creates a LineString whose coordinates are in the reverse
+     * order of this object's
+     *
+     * @return a LineString with coordinates in the reverse order
+     */
+    std::unique_ptr<LineString> reverse() const { return std::unique_ptr<LineString>(reverseImpl()); }
+
+protected:
+
+    LineString(const LineString& ls);
+
+    /// \brief
+    /// Constructs a LineString taking ownership the
+    /// given CoordinateSequence.
+    LineString(CoordinateSequence::Ptr && pts,
+               const GeometryFactory& newFactory);
+
+    LineString* cloneImpl() const override { return new LineString(*this); }
+
+    LineString* reverseImpl() const override;
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_LINESTRING;
+    };
+
+    void geometryChangedAction() override
+    {
+        envelope = computeEnvelopeInternal(true);
+    }
+
+private:
+
+    void validateConstruction();
+};
+
+struct GEOS_DLL  LineStringLT {
+    bool
+    operator()(const LineString* ls1, const LineString* ls2) const
+    {
+        return ls1->compareTo(ls2) < 0;
+    }
+};
+
+} // namespace geos::geom
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/LinearRing.h

@@ -0,0 +1,128 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005 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.
+ *
+ **********************************************************************
+ *
+ * Last port: geom/LinearRing.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+#include <vector>
+#include <geos/geom/LineString.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom { // geos::geom
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+
+/**
+ * \brief
+ * Models an OGC SFS LinearRing. A LinearRing is a LineString which is both
+ * closed and simple.
+ *
+ * In other words, the first and last coordinate in the ring must be equal,
+ * and the ring must not self-intersect.  Either orientation
+ * of the ring is allowed.
+ *
+ * A ring must have either 0 or 3 or more points. The first and last points
+ * must be equal (in 2D). If these conditions are not met, the constructors
+ * throw an {@link geos::util::IllegalArgumentException}
+ * A ring with 3 points is invalid, because it is collapsed
+ * and thus has a self-intersection.  It is allowed to be constructed
+ * so that it can be represented, and repaired if needed.
+ */
+class GEOS_DLL LinearRing : public LineString {
+
+public:
+
+    /** \brief
+     * The minimum number of vertices allowed in a valid non-empty ring.
+     * Empty rings with 0 vertices are also valid.
+     */
+    static const unsigned int MINIMUM_VALID_SIZE = 3;
+
+    LinearRing(const LinearRing& lr);
+
+    /**
+     * \brief Constructs a LinearRing with the given points.
+     *
+     * @param  points  points forming a closed and simple linestring, or
+     *      <code>null</code> or an empty array to create the empty
+     *      geometry.
+     *      This array must not contain <code>null</code> elements.
+     *	If not null LinearRing will take ownership of points.
+     *
+     * @param newFactory the GeometryFactory used to create this geometry
+     *
+     */
+    LinearRing(CoordinateSequence::Ptr && points,
+            const GeometryFactory& newFactory);
+
+    std::unique_ptr<LinearRing> clone() const
+    {
+        return std::unique_ptr<LinearRing>(cloneImpl());
+    }
+
+    ~LinearRing() override = default;
+
+    /** \brief
+     * Returns <code>Dimension.FALSE</code>, since by definition
+     * LinearRings do not have a boundary.
+     *
+     * @return Dimension::False
+     */
+    int getBoundaryDimension() const override;
+
+    bool isClosed() const override;
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    void setPoints(const CoordinateSequence* cl);
+
+    std::unique_ptr<LinearRing> reverse() const { return std::unique_ptr<LinearRing>(reverseImpl()); }
+
+    void orient(bool isCW);
+
+protected:
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_LINEARRING;
+    };
+
+    LinearRing* cloneImpl() const override { return new LinearRing(*this); }
+
+    LinearRing* reverseImpl() const override;
+
+private:
+
+    void validateConstruction();
+};
+
+
+} // namespace geos::geom
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/Location.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>
+#include <iostream> // for ostream
+
+
+namespace geos {
+namespace geom { // geos::geom
+
+/** \brief
+ * Constants representing the location of a point relative to a geometry.
+ *
+ * They can also be thought of as the row or column index of a DE-9IM matrix.
+ * For a description of the DE-9IM, see the
+ * [OpenGIS Simple Features Specification for SQL](http://www.opengis.org/techno/specs.htm").
+ */
+
+enum class Location : char {
+    /**
+     *  Used for uninitialized location values.
+     */
+    NONE = (char)(-1), // Instead of NULL
+
+    /**
+     * DE-9IM row index of the interior of the first geometry and
+     * column index of the interior of the second geometry.
+     * Location value for the interior of a geometry.
+     */
+    INTERIOR = 0,
+
+    /**
+     * DE-9IM row index of the boundary of the first geometry and
+     * column index of the boundary of the second geometry.
+     * Location value for the boundary of a geometry.
+     */
+    BOUNDARY = 1,
+
+    /**
+     * DE-9IM row index of the exterior of the first geometry and
+     * column index of the exterior of the second geometry.
+     * Location value for the exterior of a geometry.
+     */
+    EXTERIOR = 2
+};
+
+GEOS_DLL std::ostream& operator<<(std::ostream& os, const Location& loc);
+
+} // namespace geos::geom
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/MultiCurve.h

@@ -0,0 +1,126 @@
+/**********************************************************************
+ *
+ * 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/Curve.h>
+#include <geos/geom/GeometryCollection.h>
+
+namespace geos {
+namespace geom {
+
+class GEOS_DLL MultiCurve : public GeometryCollection {
+    friend class GeometryFactory;
+
+public:
+    ~MultiCurve() override = default;
+
+    std::unique_ptr<MultiCurve> clone() const
+    {
+        return std::unique_ptr<MultiCurve>(cloneImpl());
+    };
+
+    /// Returns a (possibly empty) [MultiPoint](@ref geom::MultiPoint)
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    /**
+     * \brief
+     * Returns Dimension::False if all [Curves](@ref geom::Curve) in the collection
+     * are closed, 0 otherwise.
+     */
+    int getBoundaryDimension() const override;
+
+    /// Returns line dimension (1)
+    Dimension::DimensionType getDimension() const override;
+
+    const Curve* getGeometryN(std::size_t n) const override;
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    bool hasDimension(Dimension::DimensionType d) const override
+    {
+        return d == Dimension::L;
+    }
+
+    /// Returns true if the MultiCurve is not empty, and every included
+    /// Curve is also closed.
+    bool isClosed() const;
+
+    bool isDimensionStrict(Dimension::DimensionType d) const override
+    {
+        return d == Dimension::L;
+    }
+
+    /**
+     * Creates a MultiCurve in the reverse
+     * order to this object.
+     * Both the order of the component Curves
+     * and the order of their coordinate sequences
+     * are reversed.
+     *
+     * @return a MultiCurve in the reverse order
+     */
+    std::unique_ptr<MultiCurve> reverse() const
+    {
+        return std::unique_ptr<MultiCurve>(reverseImpl());
+    }
+
+protected:
+
+    /**
+     * \brief Constructs a MultiCurve.
+     *
+     * @param  newLines The [Curves](@ref geom::Curve) for this
+     *                  MultiCurve, or `null`
+     *                  or an empty array to create the empty geometry.
+     *                  Elements may be empty Curve,
+     *                  but not `null`s.
+     *
+     * @param newFactory The GeometryFactory used to create this geometry.
+     *                   Caller must keep the factory alive for the life-time
+     *                   of the constructed MultiCurve.
+     *
+     * @note Constructed object will take ownership of
+     *       the vector and its elements.
+     *
+     */
+    MultiCurve(std::vector<std::unique_ptr<Curve>>&& newLines,
+               const GeometryFactory& newFactory);
+
+    MultiCurve(std::vector<std::unique_ptr<Geometry>>&& newLines,
+               const GeometryFactory& newFactory);
+
+    MultiCurve(const MultiCurve& mp)
+        : GeometryCollection(mp)
+    {}
+
+    MultiCurve* cloneImpl() const override
+    {
+        return new MultiCurve(*this);
+    }
+
+    MultiCurve* reverseImpl() const override;
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_MULTICURVE;
+    };
+
+};
+
+}
+}

package/dist/prebuilt/Android-x86_64/include/geos/geom/MultiLineString.h

@@ -0,0 +1,160 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005 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.
+ *
+ **********************************************************************
+ *
+ * Last port: geom/MultiLineString.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/GeometryCollection.h> // for inheritance
+#include <geos/geom/Dimension.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/MultiPoint.h>
+
+#include <string>
+#include <vector>
+
+
+// Forward declarations
+namespace geos {
+namespace geom { // geos::geom
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4250) // T1 inherits T2 via dominance
+#endif
+
+/// Models a collection of [LineStrings](@ref geom::LineString).
+class GEOS_DLL MultiLineString: public GeometryCollection {
+
+public:
+
+    friend class GeometryFactory;
+
+    ~MultiLineString() override = default;
+
+    /// Returns line dimension (1)
+    Dimension::DimensionType getDimension() const override;
+
+    bool hasDimension(Dimension::DimensionType d) const override {
+        return d == Dimension::L;
+    }
+
+    bool isDimensionStrict(Dimension::DimensionType d) const override {
+        return d == Dimension::L;
+    }
+
+    /**
+     * \brief
+     * Returns Dimension::False if all [LineStrings](@ref geom::LineString) in the collection
+     * are closed, 0 otherwise.
+     */
+    int getBoundaryDimension() const override;
+
+    /// Returns a (possibly empty) [MultiPoint](@ref geom::MultiPoint)
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    const LineString* getGeometryN(std::size_t n) const override;
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    bool isClosed() const;
+
+    std::unique_ptr<MultiLineString> clone() const
+    {
+        return std::unique_ptr<MultiLineString>(cloneImpl());
+    };
+
+    /**
+     * Creates a MultiLineString in the reverse
+     * order to this object.
+     * Both the order of the component LineStrings
+     * and the order of their coordinate sequences
+     * are reversed.
+     *
+     * @return a MultiLineString in the reverse order
+     */
+    std::unique_ptr<MultiLineString> reverse() const { return std::unique_ptr<MultiLineString>(reverseImpl()); }
+
+protected:
+
+    /**
+     * \brief Constructs a MultiLineString.
+     *
+     * @param  newLines The [LineStrings](@ref geom::LineString) for this
+     *                  MultiLineString, or `null`
+     *                  or an empty array to create the empty geometry.
+     *                  Elements may be empty LineString,
+     *                  but not `null`s.
+     *
+     * @param newFactory The GeometryFactory used to create this geometry.
+     *                   Caller must keep the factory alive for the life-time
+     *                   of the constructed MultiLineString.
+     *
+     * @note Constructed object will take ownership of
+     *       the vector and its elements.
+     *
+     */
+    MultiLineString(std::vector<std::unique_ptr<LineString>> && newLines,
+            const GeometryFactory& newFactory);
+
+    MultiLineString(std::vector<std::unique_ptr<Geometry>> && newLines,
+                    const GeometryFactory& newFactory);
+
+    MultiLineString(const MultiLineString& mp)
+        : GeometryCollection(mp)
+        {};
+
+    MultiLineString* cloneImpl() const override { return new MultiLineString(*this); }
+
+    MultiLineString* reverseImpl() const override;
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_MULTILINESTRING;
+    };
+
+    bool hasCurvedComponents() const override
+    {
+        return false;
+    }
+
+};
+
+
+} // namespace geos::geom
+} // namespace geos
+
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+
+
+
+