rgeo 2.1.1 → 2.4.0

data/ext/geos_c_impl/factory.h

@@ -10,59 +10,13 @@
 
 RGEO_BEGIN_C
 
-
-/*
-  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.
-*/
-typedef struct {
-  VALUE feature_module;
-  VALUE feature_geometry;
-  VALUE feature_point;
-  VALUE feature_line_string;
-  VALUE feature_linear_ring;
-  VALUE feature_line;
-  VALUE feature_polygon;
-  VALUE feature_geometry_collection;
-  VALUE feature_multi_point;
-  VALUE feature_multi_line_string;
-  VALUE feature_multi_polygon;
-  VALUE geos_module;
-  VALUE geos_geometry;
-  VALUE geos_point;
-  VALUE geos_line_string;
-  VALUE geos_linear_ring;
-  VALUE geos_line;
-  VALUE geos_polygon;
-  VALUE geos_geometry_collection;
-  VALUE geos_multi_point;
-  VALUE geos_multi_line_string;
-  VALUE geos_multi_polygon;
-  ID id_cast;
-  ID id_eql;
-  ID id_generate;
-  ID id_enum_for;
-  ID id_hash;
-  VALUE sym_force_new;
-  VALUE sym_keep_subtype;
-#ifndef RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
-  VALUE psych_wkt_generator;
-  VALUE marshal_wkb_generator;
-#endif
-} RGeo_Globals;
-
-
 /*
   Wrapped structure for Factory objects.
   A factory encapsulates the GEOS context, and GEOS serializer settings.
   It also stores the SRID for all geometries created by this factory,
   and the resolution for buffers created for this factory's geometries.
-  Finally, it provides easy access to the globals.
 */
 typedef struct {
-  RGeo_Globals* globals;
   GEOSContextHandle_t geos_context;
   GEOSWKTReader* wkt_reader;
   GEOSWKBReader* wkb_reader;
@@ -120,18 +74,30 @@ typedef struct {
 } RGeo_GeometryData;
 
 
+// Data types which indicate how RGeo types should be managed by Ruby.
+extern const rb_data_type_t rgeo_factory_type;
+
+extern const rb_data_type_t rgeo_geometry_type;
+
+
+// Convenient macros for checking the type of data from Ruby
+#define RGEO_FACTORY_TYPEDDATA_P(object) (_RGEO_TYPEDDATA_P(object, &rgeo_factory_type))
+#define RGEO_GEOMETRY_TYPEDDATA_P(object) (_RGEO_TYPEDDATA_P(object, &rgeo_geometry_type))
+
+#define _RGEO_TYPEDDATA_P(object, data_type) (TYPE(object) == T_DATA && RTYPEDDATA(object)->typed_flag == 1 && RTYPEDDATA(object)->type == data_type)
+
 // Returns the RGeo_FactoryData* given a ruby Factory object
-#define RGEO_FACTORY_DATA_PTR(factory) ((RGeo_FactoryData*)DATA_PTR(factory))
+#define RGEO_FACTORY_DATA_PTR(factory) ((RGeo_FactoryData*)RTYPEDDATA_DATA(factory))
 
 // Returns the RGeo_GeometryData* given a ruby Geometry object
-#define RGEO_GEOMETRY_DATA_PTR(geometry) ((RGeo_GeometryData*)DATA_PTR(geometry))
+#define RGEO_GEOMETRY_DATA_PTR(geometry) ((RGeo_GeometryData*)RTYPEDDATA_DATA(geometry))
 
 
 /*
   Initializes the factory module. This should be called first in the
   initialization process.
 */
-RGeo_Globals* rgeo_init_geos_factory();
+void rgeo_init_geos_factory();
 
 /*
   Given a GEOS geometry handle, wraps it in a ruby Geometry object of the
@@ -187,6 +153,11 @@ GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, V
 */
 char rgeo_is_geos_object(VALUE obj);
 
+/*
+  Raises a rgeo error if the object is not a GEOS Geometry implementation.
+*/
+void rgeo_check_geos_object(VALUE obj);
+
 /*
   Gets the underlying GEOS geometry for a given ruby object. Returns NULL
   if the given ruby object is not a GEOS geometry wrapper.

data/ext/geos_c_impl/geometry.c

@@ -11,6 +11,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 
@@ -180,13 +182,11 @@ static VALUE method_geometry_geometry_type(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
-  const GEOSGeometry* self_geom;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  self_geom = self_data->geom;
-  if (self_geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_geometry;
+  if (self_data->geom) {
+    result = rgeo_feature_geometry_module;
   }
   return result;
 }
@@ -271,7 +271,7 @@ static VALUE method_geometry_as_text(VALUE self)
     factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
     wkt_generator = factory_data->wkrep_wkt_generator;
     if (!NIL_P(wkt_generator)) {
-      result = rb_funcall(wkt_generator, factory_data->globals->id_generate, 1, self);
+      result = rb_funcall(wkt_generator, rb_intern("generate"), 1, self);
     }
     else {
       wkt_writer = factory_data->wkt_writer;
@@ -310,7 +310,7 @@ static VALUE method_geometry_as_binary(VALUE self)
     factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
     wkb_generator = factory_data->wkrep_wkb_generator;
     if (!NIL_P(wkb_generator)) {
-      result = rb_funcall(wkb_generator, factory_data->globals->id_generate, 1, self);
+      result = rb_funcall(wkb_generator, rb_intern("generate"), 1, self);
     }
     else {
       wkb_writer = factory_data->wkb_writer;
@@ -1045,12 +1045,13 @@ static VALUE method_geometry_invalid_reason(VALUE self)
   self_geom = self_data->geom;
   if (self_geom) {
     str = GEOSisValidReason_r(self_data->geos_context, self_geom);
-    if (str) {
-      result = rb_str_new2(str);
-    }
-    else {
-      result = rb_str_new2("Exception");
-    }
+    // Per documentation, a valid geometry should give an empty string.
+    // However it seems not to be the case. Hence the comparison against
+    // the string that is really given: `"Valid Geometry"`.
+    // See https://github.com/libgeos/geos/issues/431.
+    if (str) result = (str[0] == '\0' || !strcmp(str, "Valid Geometry")) ? Qnil : rb_str_new2(str);
+    else result = rb_str_new2("Exception");
+    GEOSFree_r(self_data->geos_context, str);
   }
   return result;
 }
@@ -1074,11 +1075,11 @@ static VALUE method_geometry_point_on_surface(VALUE self)
 /**** INITIALIZATION FUNCTION ****/
 
 
-void rgeo_init_geos_geometry(RGeo_Globals* globals)
+void rgeo_init_geos_geometry()
 {
   VALUE geos_geometry_methods;
 
-  geos_geometry_methods = rb_define_module_under(globals->geos_module, "CAPIGeometryMethods");
+  geos_geometry_methods = rb_define_module_under(rgeo_geos_module, "CAPIGeometryMethods");
 
   rb_define_method(geos_geometry_methods, "factory=", method_geometry_set_factory, 1);
   rb_define_method(geos_geometry_methods, "initialize_copy", method_geometry_initialize_copy, 1);
@@ -1094,8 +1095,8 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_method(geos_geometry_methods, "boundary", method_geometry_boundary, 0);
   rb_define_method(geos_geometry_methods, "_as_text", method_geometry_as_text, 0);
   rb_define_method(geos_geometry_methods, "as_binary", method_geometry_as_binary, 0);
-  rb_define_method(geos_geometry_methods, "is_empty?", method_geometry_is_empty, 0);
-  rb_define_method(geos_geometry_methods, "is_simple?", method_geometry_is_simple, 0);
+  rb_define_method(geos_geometry_methods, "empty?", method_geometry_is_empty, 0);
+  rb_define_method(geos_geometry_methods, "simple?", method_geometry_is_simple, 0);
   rb_define_method(geos_geometry_methods, "equals?", method_geometry_equals, 1);
   rb_define_method(geos_geometry_methods, "==", method_geometry_equals, 1);
   rb_define_method(geos_geometry_methods, "rep_equals?", method_geometry_eql, 1);

data/ext/geos_c_impl/geometry.h

@@ -6,8 +6,6 @@
 #ifndef RGEO_GEOS_GEOMETRY_INCLUDED
 #define RGEO_GEOS_GEOMETRY_INCLUDED
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -15,7 +13,7 @@ RGEO_BEGIN_C
   Initializes the geometry module. This should be called after the factory
   module is initialized, but before any of the other modules.
 */
-void rgeo_init_geos_geometry(RGeo_Globals* globals);
+void rgeo_init_geos_geometry();
 
 
 RGEO_END_C

data/ext/geos_c_impl/geometry_collection.c

@@ -10,6 +10,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "line_string.h"
@@ -56,13 +58,13 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
     cast_type = Qnil;
     switch (type) {
     case GEOS_MULTIPOINT:
-      cast_type = factory_data->globals->feature_point;
+      cast_type = rgeo_feature_point_module;
       break;
     case GEOS_MULTILINESTRING:
-      cast_type = factory_data->globals->feature_line_string;
+      cast_type = rgeo_feature_line_string_module;
       break;
     case GEOS_MULTIPOLYGON:
-      cast_type = factory_data->globals->feature_polygon;
+      cast_type = rgeo_feature_polygon_module;
       break;
     }
     for (i=0; i<len; ++i) {
@@ -156,8 +158,7 @@ static VALUE method_geometry_collection_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_geometry_collection, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_geometry_collection_module, hash);
   hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -171,7 +172,7 @@ static VALUE method_geometry_collection_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_geometry_collection;
+    result = rgeo_feature_geometry_collection_module;
   }
   return result;
 }
@@ -239,6 +240,8 @@ static VALUE method_geometry_collection_brackets(VALUE self, VALUE n)
 
 static VALUE method_geometry_collection_each(VALUE self)
 {
+  RETURN_ENUMERATOR(self, 0, 0); /* return enum_for(__callee__) unless block_given? */
+
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   int len;
@@ -249,27 +252,22 @@ static VALUE method_geometry_collection_each(VALUE self)
 
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
 
-  if (rb_block_given_p()) {
-    self_geom = self_data->geom;
-    if (self_geom) {
-      GEOSContextHandle_t self_context = self_data->geos_context;
-      len = GEOSGetNumGeometries_r(self_context, self_geom);
-      if (len > 0) {
-        klasses = self_data->klasses;
-        for (i=0; i<len; ++i) {
-          elem_geom = GEOSGetGeometryN_r(self_context, self_geom, i);
-          elem = rgeo_wrap_geos_geometry_clone(self_data->factory, elem_geom, NIL_P(klasses) ? Qnil : rb_ary_entry(klasses, i));
-          if (!NIL_P(elem)) {
-            rb_yield(elem);
-          }
+  self_geom = self_data->geom;
+  if (self_geom) {
+    GEOSContextHandle_t self_context = self_data->geos_context;
+    len = GEOSGetNumGeometries_r(self_context, self_geom);
+    if (len > 0) {
+      klasses = self_data->klasses;
+      for (i=0; i<len; ++i) {
+        elem_geom = GEOSGetGeometryN_r(self_context, self_geom, i);
+        elem = rgeo_wrap_geos_geometry_clone(self_data->factory, elem_geom, NIL_P(klasses) ? Qnil : rb_ary_entry(klasses, i));
+        if (!NIL_P(elem)) {
+          rb_yield(elem);
         }
       }
     }
-    return self;
-  }
-  else {
-    return rb_funcall(self, RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->id_enum_for, 0);
   }
+  return self;
 }
 
 static VALUE method_multi_point_geometry_type(VALUE self)
@@ -280,7 +278,7 @@ static VALUE method_multi_point_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_multi_point;
+    result = rgeo_feature_multi_point_module;
   }
   return result;
 }
@@ -295,8 +293,7 @@ static VALUE method_multi_point_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_multi_point, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_multi_point_module, hash);
   hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -342,7 +339,7 @@ static VALUE method_multi_line_string_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_multi_line_string;
+    result = rgeo_feature_multi_line_string_module;
   }
   return result;
 }
@@ -357,8 +354,7 @@ static VALUE method_multi_line_string_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_multi_line_string, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_multi_line_string_module, hash);
   hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -396,7 +392,7 @@ static VALUE method_multi_line_string_coordinates(VALUE self)
 
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
-  
+
   if(self_geom) {
     zCoordinate = RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M;
     context = self_data->geos_context;
@@ -472,7 +468,7 @@ static VALUE method_multi_polygon_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_multi_polygon;
+    result = rgeo_feature_multi_polygon_module;
   }
   return result;
 }
@@ -487,8 +483,7 @@ static VALUE method_multi_polygon_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_multi_polygon, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_multi_polygon_module, hash);
   hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -508,7 +503,7 @@ static VALUE method_multi_polygon_coordinates(VALUE self)
 
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
-  
+
   if(self_geom) {
     zCoordinate = RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M;
     context = self_data->geos_context;
@@ -586,7 +581,7 @@ static VALUE cmethod_multi_polygon_create(VALUE module, VALUE factory, VALUE arr
 /**** INITIALIZATION FUNCTION ****/
 
 
-void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
+void rgeo_init_geos_geometry_collection()
 {
   VALUE geos_geometry_collection_methods;
   VALUE geos_multi_point_methods;
@@ -594,13 +589,13 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   VALUE geos_multi_polygon_methods;
 
   // Class methods for geometry collection classes
-  rb_define_module_function(globals->geos_geometry_collection, "create", cmethod_geometry_collection_create, 2);
-  rb_define_module_function(globals->geos_multi_point, "create", cmethod_multi_point_create, 2);
-  rb_define_module_function(globals->geos_multi_line_string, "create", cmethod_multi_line_string_create, 2);
-  rb_define_module_function(globals->geos_multi_polygon, "create", cmethod_multi_polygon_create, 2);
+  rb_define_module_function(rgeo_geos_geometry_collection_class, "create", cmethod_geometry_collection_create, 2);
+  rb_define_module_function(rgeo_geos_multi_point_class, "create", cmethod_multi_point_create, 2);
+  rb_define_module_function(rgeo_geos_multi_line_string_class, "create", cmethod_multi_line_string_create, 2);
+  rb_define_module_function(rgeo_geos_multi_polygon_class, "create", cmethod_multi_polygon_create, 2);
 
   // Methods for GeometryCollectionImpl
-  geos_geometry_collection_methods = rb_define_module_under(globals->geos_module, "CAPIGeometryCollectionMethods");
+  geos_geometry_collection_methods = rb_define_module_under(rgeo_geos_module, "CAPIGeometryCollectionMethods");
   rb_define_method(geos_geometry_collection_methods, "rep_equals?", method_geometry_collection_eql, 1);
   rb_define_method(geos_geometry_collection_methods, "eql?", method_geometry_collection_eql, 1);
   rb_define_method(geos_geometry_collection_methods, "hash", method_geometry_collection_hash, 0);
@@ -614,21 +609,21 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
 
 
   // Methods for MultiPointImpl
-  geos_multi_point_methods = rb_define_module_under(globals->geos_module, "CAPIMultiPointMethods");
+  geos_multi_point_methods = rb_define_module_under(rgeo_geos_module, "CAPIMultiPointMethods");
   rb_define_method(geos_multi_point_methods, "geometry_type", method_multi_point_geometry_type, 0);
   rb_define_method(geos_multi_point_methods, "hash", method_multi_point_hash, 0);
   rb_define_method(geos_multi_point_methods, "coordinates", method_multi_point_coordinates, 0);
 
   // Methods for MultiLineStringImpl
-  geos_multi_line_string_methods = rb_define_module_under(globals->geos_module, "CAPIMultiLineStringMethods");
+  geos_multi_line_string_methods = rb_define_module_under(rgeo_geos_module, "CAPIMultiLineStringMethods");
   rb_define_method(geos_multi_line_string_methods, "geometry_type", method_multi_line_string_geometry_type, 0);
   rb_define_method(geos_multi_line_string_methods, "length", method_multi_line_string_length, 0);
-  rb_define_method(geos_multi_line_string_methods, "is_closed?", method_multi_line_string_is_closed, 0);
+  rb_define_method(geos_multi_line_string_methods, "closed?", method_multi_line_string_is_closed, 0);
   rb_define_method(geos_multi_line_string_methods, "hash", method_multi_line_string_hash, 0);
   rb_define_method(geos_multi_line_string_methods, "coordinates", method_multi_line_string_coordinates, 0);
 
   // Methods for MultiPolygonImpl
-  geos_multi_polygon_methods = rb_define_module_under(globals->geos_module, "CAPIMultiPolygonMethods");
+  geos_multi_polygon_methods = rb_define_module_under(rgeo_geos_module, "CAPIMultiPolygonMethods");
   rb_define_method(geos_multi_polygon_methods, "geometry_type", method_multi_polygon_geometry_type, 0);
   rb_define_method(geos_multi_polygon_methods, "area", method_multi_polygon_area, 0);
   rb_define_method(geos_multi_polygon_methods, "centroid", method_multi_polygon_centroid, 0);

data/ext/geos_c_impl/geometry_collection.h

@@ -9,8 +9,6 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -18,7 +16,7 @@ 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);
+void rgeo_init_geos_geometry_collection();
 
 /*
   Comopares the contents of two geometry collections. Does not test the

data/ext/geos_c_impl/globals.c

@@ -0,0 +1,91 @@
+#include "preface.h"
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include <ruby.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;
+
+void rgeo_init_geos_globals()
+{
+  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,45 @@
+/*
+  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 <ruby.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