rgeo 2.3.0 → 3.0.0.pre.rc.1

data/ext/geos_c_impl/geometry_collection.c

@@ -10,10 +10,13 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "line_string.h"
 #include "polygon.h"
+#include "geometry.h"
 #include "geometry_collection.h"
 
 #include "coordinates.h"
@@ -41,9 +44,6 @@ 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;
 
   result = Qnil;
   Check_Type(array, T_ARRAY);
@@ -56,13 +56,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) {
@@ -88,32 +88,6 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
     }
     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;
@@ -141,7 +115,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 +130,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 +144,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 +212,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 +224,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 +250,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 +265,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 +311,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 +326,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 +364,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 +440,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 +455,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 +475,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 +553,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 +561,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 +581,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);
@@ -640,80 +607,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