rgeo 2.3.1 → 3.0.0.pre.rc.2

data/ext/geos_c_impl/geometry_collection.c

@@ -10,13 +10,16 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+
+#include "coordinates.h"
+#include "errors.h"
 #include "factory.h"
 #include "geometry.h"
+#include "geometry_collection.h"
+#include "globals.h"
 #include "line_string.h"
 #include "polygon.h"
-#include "geometry_collection.h"
 
-#include "coordinates.h"
 
 RGEO_BEGIN_C
 
@@ -41,95 +44,69 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
   VALUE cast_type;
   GEOSGeometry* geom;
   GEOSGeometry* collection;
-  char problem;
-  GEOSGeometry* igeom;
-  GEOSGeometry* jgeom;
+  int state = 0;
 
   result = Qnil;
   Check_Type(array, T_ARRAY);
   len = (unsigned int)RARRAY_LEN(array);
   geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
-  if (geoms) {
-    factory_data = RGEO_FACTORY_DATA_PTR(factory);
-    geos_context = factory_data->geos_context;
-    klasses = Qnil;
-    cast_type = Qnil;
-    switch (type) {
+  if (!geoms) { rb_raise(rb_eRGeoError, "not enough memory available"); }
+
+  factory_data = RGEO_FACTORY_DATA_PTR(factory);
+  geos_context = factory_data->geos_context;
+  klasses = Qnil;
+  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) {
+    geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(array, i), factory, cast_type, &klass, &state);
+    if (state || !geom) {
       break;
     }
-    for (i=0; i<len; ++i) {
-      geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(array, i), factory, cast_type, &klass);
-      if (!geom) {
-        break;
-      }
-      geoms[i] = geom;
-      if (!NIL_P(klass) && NIL_P(klasses)) {
-        klasses = rb_ary_new2(len);
-        for (j=0; j<i; ++j) {
-          rb_ary_push(klasses, Qnil);
-        }
-      }
-      if (!NIL_P(klasses)) {
-        rb_ary_push(klasses, klass);
-      }
-    }
-    if (i != len) {
+    geoms[i] = geom;
+    if (!NIL_P(klass) && NIL_P(klasses)) {
+      klasses = rb_ary_new2(len);
       for (j=0; j<i; ++j) {
-        GEOSGeom_destroy_r(geos_context, geoms[j]);
+        rb_ary_push(klasses, Qnil);
       }
     }
-    else {
-      collection = GEOSGeom_createCollection_r(geos_context, type, geoms, len);
-      // Due to a limitation of GEOS, the MultiPolygon assertions are not checked.
-      // We do that manually here.
-      if (collection && type == GEOS_MULTIPOLYGON && (factory_data->flags & 1) == 0) {
-        problem = 0;
-        for (i=1; i<len; ++i) {
-          for (j=0; j<i; ++j) {
-            igeom = geoms[i];
-            jgeom = geoms[j];
-            problem = GEOSRelatePattern_r(geos_context, igeom, jgeom, "2********");
-            if (problem) {
-              break;
-            }
-            problem = GEOSRelatePattern_r(geos_context, igeom, jgeom, "****1****");
-            if (problem) {
-              break;
-            }
-          }
-          if (problem) {
-            break;
-          }
-        }
-        if (problem) {
-          GEOSGeom_destroy_r(geos_context, collection);
-          collection = NULL;
-        }
-      }
-      if (collection) {
-        result = rgeo_wrap_geos_geometry(factory, collection, module);
-        RGEO_GEOMETRY_DATA_PTR(result)->klasses = klasses;
-      }
-      // NOTE: We are assuming that GEOS will do its own cleanup of the
-      // element geometries if it fails to create the collection, so we
-      // are not doing that ourselves. If that turns out not to be the
-      // case, this will be a memory leak.
+    if (!NIL_P(klasses)) {
+      rb_ary_push(klasses, klass);
+    }
+  }
+  if (i != len) {
+    for (j=0; j<i; ++j) {
+      GEOSGeom_destroy_r(geos_context, geoms[j]);
+    }
+  }
+  else {
+    collection = GEOSGeom_createCollection_r(geos_context, type, geoms, len);
+    if (collection) {
+      result = rgeo_wrap_geos_geometry(factory, collection, module);
+      RGEO_GEOMETRY_DATA_PTR(result)->klasses = klasses;
     }
-    free(geoms);
+    // NOTE: We are assuming that GEOS will do its own cleanup of the
+    // element geometries if it fails to create the collection, so we
+    // are not doing that ourselves. If that turns out not to be the
+    // case, this will be a memory leak.
+  }
+  FREE(geoms);
+  if (state) {
+    rb_exc_raise(rb_errinfo()); // raise $!
   }
 
   return result;
 }
 
-
 /**** RUBY METHOD DEFINITIONS ****/
 
 
@@ -141,7 +118,7 @@ static VALUE method_geometry_collection_eql(VALUE self, VALUE rhs)
   result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
     self_data = RGEO_GEOMETRY_DATA_PTR(self);
-    result = rgeo_geos_geometry_collections_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
@@ -156,8 +133,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 +147,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 +215,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 +227,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 +253,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 +268,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 +314,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 +329,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 +367,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 +443,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 +458,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 +478,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 +556,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 +564,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,13 +584,13 @@ 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, "closed?", method_multi_line_string_is_closed, 0);
@@ -628,7 +598,7 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   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);
@@ -640,80 +610,6 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
 /**** OTHER PUBLIC FUNCTIONS ****/
 
 
-VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
-{
-  VALUE result;
-  int len1;
-  int len2;
-  int i;
-  const GEOSGeometry* sub_geom1;
-  const GEOSGeometry* sub_geom2;
-  int type1;
-  int type2;
-
-  result = Qnil;
-  if (geom1 && geom2) {
-    len1 = GEOSGetNumGeometries_r(context, geom1);
-    len2 = GEOSGetNumGeometries_r(context, geom2);
-    if (len1 >= 0 && len2 >= 0) {
-      if (len1 == len2) {
-        result = Qtrue;
-        for (i=0; i<len1; ++i) {
-          sub_geom1 = GEOSGetGeometryN_r(context, geom1, i);
-          sub_geom2 = GEOSGetGeometryN_r(context, geom2, i);
-          if (sub_geom1 && sub_geom2) {
-            type1 = GEOSGeomTypeId_r(context, sub_geom1);
-            type2 = GEOSGeomTypeId_r(context, sub_geom2);
-            if (type1 >= 0 && type2 >= 0) {
-              if (type1 == type2) {
-                switch (type1) {
-                case GEOS_POINT:
-                case GEOS_LINESTRING:
-                case GEOS_LINEARRING:
-                  result = rgeo_geos_coordseqs_eql(context, sub_geom1, sub_geom2, check_z);
-                  break;
-                case GEOS_POLYGON:
-                  result = rgeo_geos_polygons_eql(context, sub_geom1, sub_geom2, check_z);
-                  break;
-                case GEOS_GEOMETRYCOLLECTION:
-                case GEOS_MULTIPOINT:
-                case GEOS_MULTILINESTRING:
-                case GEOS_MULTIPOLYGON:
-                  result = rgeo_geos_geometry_collections_eql(context, sub_geom1, sub_geom2, check_z);
-                  break;
-                default:
-                  result = Qnil;
-                  break;
-                }
-                if (!RTEST(result)) {
-                  break;
-                }
-              }
-              else {
-                result = Qfalse;
-                break;
-              }
-            }
-            else {
-              result = Qnil;
-              break;
-            }
-          }
-          else {
-            result = Qnil;
-            break;
-          }
-        }
-      }
-      else {
-        result = Qfalse;
-      }
-    }
-  }
-  return result;
-}
-
-
 st_index_t rgeo_geos_geometry_collection_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
 {
   const GEOSGeometry* sub_geom;

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,18 +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);
-
-/*
-  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.

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