rgeo 2.3.1 → 3.0.1

data/ext/geos_c_impl/geometry_collection.h

@@ -2,44 +2,30 @@
   Geometry collection methods for GEOS wrapper
 */
 
-
 #ifndef RGEO_GEOS_GEOMETRY_COLLECTION_INCLUDED
 #define RGEO_GEOS_GEOMETRY_COLLECTION_INCLUDED
 
-#include <ruby.h>
 #include <geos_c.h>
-
-#include "factory.h"
+#include <ruby.h>
 
 RGEO_BEGIN_C
 
-
 /*
   Initializes the geometry collection module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_geometry_collection(RGeo_Globals* globals);
-
-/*
-  Comopares the contents of two geometry collections. Does not test the
-  types of the collections themselves, but tests the types, values, and
-  contents of all the contents. The two given geometries MUST be
-  collection types-- i.e. GeometryCollection, MultiPoint, MultiLineString,
-  or MultiPolygon.
-  Returns Qtrue if the contents of the two geometry collections are equal,
-  Qfalse if they are inequal, or Qnil if an error occurs.
-*/
-VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
+void
+rgeo_init_geos_geometry_collection();
 
 /*
   A tool for building up hash values.
-  You must pass in the context, a geos geometry, and a seed hash.
+  You must pass in a geos geometry and a seed hash.
   Returns an updated hash.
   This call is useful in sequence, and should be bracketed by calls to
   rb_hash_start and rb_hash_end.
 */
-st_index_t rgeo_geos_geometry_collection_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
-
+st_index_t
+rgeo_geos_geometry_collection_hash(const GEOSGeometry* geom, st_index_t hash);
 
 RGEO_END_C
 

data/ext/geos_c_impl/globals.c

@@ -0,0 +1,169 @@
+#include "preface.h"
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include <ctype.h>
+#include <geos_c.h>
+#include <ruby.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "errors.h"
+#include "globals.h"
+
+RGEO_BEGIN_C
+
+VALUE rgeo_module;
+
+VALUE rgeo_feature_module;
+VALUE rgeo_feature_geometry_module;
+VALUE rgeo_feature_point_module;
+VALUE rgeo_feature_line_string_module;
+VALUE rgeo_feature_linear_ring_module;
+VALUE rgeo_feature_line_module;
+VALUE rgeo_feature_polygon_module;
+VALUE rgeo_feature_geometry_collection_module;
+VALUE rgeo_feature_multi_point_module;
+VALUE rgeo_feature_multi_line_string_module;
+VALUE rgeo_feature_multi_polygon_module;
+
+VALUE rgeo_geos_module;
+VALUE rgeo_geos_geometry_class;
+VALUE rgeo_geos_point_class;
+VALUE rgeo_geos_line_string_class;
+VALUE rgeo_geos_linear_ring_class;
+VALUE rgeo_geos_line_class;
+VALUE rgeo_geos_polygon_class;
+VALUE rgeo_geos_geometry_collection_class;
+VALUE rgeo_geos_multi_point_class;
+VALUE rgeo_geos_multi_line_string_class;
+VALUE rgeo_geos_multi_polygon_class;
+
+// The notice handler is very rarely used by GEOS, only in
+// GEOSIsValid_r (check for NOTICE_MESSAGE in GEOS codebase).
+// We still set it to make sure we do not miss any implementation
+// change. Use `DEBUG=1 rake` to show notice.
+static void
+notice_handler(const char* fmt, ...)
+{
+#ifdef DEBUG
+  va_list args;
+  va_start(args, fmt);
+  fprintf(stderr, "GEOS Notice -- ");
+  vfprintf(stderr, fmt, args);
+  fprintf(stderr, "\n");
+  va_end(args);
+#endif
+}
+
+static void
+error_handler(const char* fmt, ...)
+{
+  // See https://en.cppreference.com/w/c/io/vfprintf
+  va_list args1;
+  va_start(args1, fmt);
+  va_list args2;
+  va_copy(args2, args1);
+  int size = 1 + vsnprintf(NULL, 0, fmt, args1);
+  va_end(args1);
+  char geos_full_error[size];
+  vsnprintf(geos_full_error, sizeof geos_full_error, fmt, args2);
+  va_end(args2);
+
+  // NOTE: strtok is destructive, geos_full_error is not to be used afterwards.
+  char* geos_error = strtok(geos_full_error, ":");
+  char* geos_message = strtok(NULL, ":");
+  while (isspace(*geos_message))
+    geos_message++;
+
+  if (streq(geos_error, "UnsupportedOperationException")) {
+    rb_raise(rb_eRGeoUnsupportedOperation, "%s", geos_message);
+  } else if (streq(geos_error, "IllegalArgumentException")) {
+    rb_raise(rb_eRGeoInvalidGeometry, "%s", geos_message);
+  } else if (streq(geos_error, "ParseException")) {
+    rb_raise(rb_eRGeoParseError, "%s", geos_message);
+  } else if (geos_message) {
+    rb_raise(rb_eGeosError, "%s: %s", geos_error, geos_message);
+  } else {
+    rb_raise(rb_eGeosError, "%s", geos_error);
+  }
+}
+
+void
+rgeo_init_geos_globals()
+{
+  initGEOS(notice_handler, error_handler);
+
+  rgeo_module = rb_define_module("RGeo");
+  rb_gc_register_mark_object(rgeo_module);
+
+  rgeo_feature_module = rb_define_module_under(rgeo_module, "Feature");
+  rb_gc_register_mark_object(rgeo_feature_module);
+  rgeo_feature_geometry_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("Geometry"));
+  rb_gc_register_mark_object(rgeo_feature_geometry_module);
+  rgeo_feature_point_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("Point"));
+  rb_gc_register_mark_object(rgeo_feature_point_module);
+  rgeo_feature_line_string_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("LineString"));
+  rb_gc_register_mark_object(rgeo_feature_line_string_module);
+  rgeo_feature_linear_ring_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("LinearRing"));
+  rb_gc_register_mark_object(rgeo_feature_linear_ring_module);
+  rgeo_feature_line_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("Line"));
+  rb_gc_register_mark_object(rgeo_feature_line_module);
+  rgeo_feature_polygon_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("Polygon"));
+  rb_gc_register_mark_object(rgeo_feature_polygon_module);
+  rgeo_feature_geometry_collection_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("GeometryCollection"));
+  rb_gc_register_mark_object(rgeo_feature_geometry_collection_module);
+  rgeo_feature_multi_point_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("MultiPoint"));
+  rb_gc_register_mark_object(rgeo_feature_multi_point_module);
+  rgeo_feature_multi_line_string_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("MultiLineString"));
+  rb_gc_register_mark_object(rgeo_feature_multi_line_string_module);
+  rgeo_feature_multi_polygon_module =
+    rb_const_get_at(rgeo_feature_module, rb_intern("MultiPolygon"));
+  rb_gc_register_mark_object(rgeo_feature_multi_polygon_module);
+
+  rgeo_geos_module = rb_define_module_under(rgeo_module, "Geos");
+  rb_gc_register_mark_object(rgeo_geos_module);
+  rgeo_geos_geometry_class =
+    rb_define_class_under(rgeo_geos_module, "CAPIGeometryImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_geometry_class);
+  rgeo_geos_point_class =
+    rb_define_class_under(rgeo_geos_module, "CAPIPointImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_point_class);
+  rgeo_geos_line_string_class =
+    rb_define_class_under(rgeo_geos_module, "CAPILineStringImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_line_string_class);
+  rgeo_geos_linear_ring_class =
+    rb_define_class_under(rgeo_geos_module, "CAPILinearRingImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_linear_ring_class);
+  rgeo_geos_line_class =
+    rb_define_class_under(rgeo_geos_module, "CAPILineImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_line_class);
+  rgeo_geos_polygon_class =
+    rb_define_class_under(rgeo_geos_module, "CAPIPolygonImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_polygon_class);
+  rgeo_geos_geometry_collection_class = rb_define_class_under(
+    rgeo_geos_module, "CAPIGeometryCollectionImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_geometry_collection_class);
+  rgeo_geos_multi_point_class =
+    rb_define_class_under(rgeo_geos_module, "CAPIMultiPointImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_multi_point_class);
+  rgeo_geos_multi_line_string_class = rb_define_class_under(
+    rgeo_geos_module, "CAPIMultiLineStringImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_multi_line_string_class);
+  rgeo_geos_multi_polygon_class =
+    rb_define_class_under(rgeo_geos_module, "CAPIMultiPolygonImpl", rb_cObject);
+  rb_gc_register_mark_object(rgeo_geos_multi_polygon_class);
+}
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/globals.h

@@ -0,0 +1,46 @@
+/*
+  Per-interpreter globals.
+  Most of these are cached references to commonly used classes, modules,
+  and symbols so we don't have to do a lot of constant lookups and calls
+  to rb_intern.
+*/
+
+#ifndef RGEO_GEOS_GLOBALS_INCLUDED
+#define RGEO_GEOS_GLOBALS_INCLUDED
+
+#include <geos_c.h>
+
+RGEO_BEGIN_C
+
+extern VALUE rgeo_module;
+
+extern VALUE rgeo_feature_module;
+extern VALUE rgeo_feature_geometry_module;
+extern VALUE rgeo_feature_point_module;
+extern VALUE rgeo_feature_line_string_module;
+extern VALUE rgeo_feature_linear_ring_module;
+extern VALUE rgeo_feature_line_module;
+extern VALUE rgeo_feature_polygon_module;
+extern VALUE rgeo_feature_geometry_collection_module;
+extern VALUE rgeo_feature_multi_point_module;
+extern VALUE rgeo_feature_multi_line_string_module;
+extern VALUE rgeo_feature_multi_polygon_module;
+
+extern VALUE rgeo_geos_module;
+extern VALUE rgeo_geos_geometry_class;
+extern VALUE rgeo_geos_point_class;
+extern VALUE rgeo_geos_line_string_class;
+extern VALUE rgeo_geos_linear_ring_class;
+extern VALUE rgeo_geos_line_class;
+extern VALUE rgeo_geos_polygon_class;
+extern VALUE rgeo_geos_geometry_collection_class;
+extern VALUE rgeo_geos_multi_point_class;
+extern VALUE rgeo_geos_multi_line_string_class;
+extern VALUE rgeo_geos_multi_polygon_class;
+
+void
+rgeo_init_geos_globals();
+
+RGEO_END_C
+
+#endif