rgeo 0.1.12 → 0.1.13

data/History.rdoc

@@ -1,8 +1,14 @@
-=== 0.1.12 / 2010-10-23
+=== 0.1.13 / 2010-10-26
 
-Further development and fixes in the geographic coordinate systems.
+* Reworked the way casting is done. Casting has two dimensions: factory casting and type casting, either or both of which can be done at once. Implemented a standard casting algorithm to handle these cases, and an override mechanism for factories that want to do some of their own casting. Removed Factory#cast and Geometry#cast, and implemented a global Features::cast entry point instead.
+* All factory and relational methods now perform auto-casting on inputs.
+* Removed the "auto-flattening" behavior of Factory#multi_point, Factory#multi_line_string, and Factory#multi_polygon because it seemed overkill for factory methods. These methods now just attempt to auto-cast the immediate objects.
+* Filled out more test cases for SimpleSpherical.
+* Provided SimpleCartesian as a fallback implementation in case Geos is not available. SimpleCartesian is like SimpleSpherical in that some operations are not provided, but it is pure ruby and doesn't depend on external libraries.
+* Improved feature type checking facilities.
+* Documentation updates.
 
-Changes since 0.1.11:
+=== 0.1.12 / 2010-10-23
 
 * API CHANGE: Factory#coerce renamed to Factory#cast. I think this should be the final name for this function.
 * Some new tests and a lot of fixes in SimpleMercator and SimpleSpherical.
@@ -12,10 +18,6 @@ Changes since 0.1.11:
 
 === 0.1.11 / 2010-10-21
 
-Further development and fixing in the geographic coordinate systems.
-
-Changes since 0.1.10:
-
 * API CHANGE: Factory#convert renamed to Factory#coerce.
 * Some implementations that inherit from RGeo::Features::Geometry (e.g. the Geography implementations) raised Unimplemented from operator implementations because they had aliased the wrong methods. Fixed.
 * Geos coercer didn't properly coerce "contained" elements in a compound geometry. Fixed.

data/README.rdoc

@@ -42,7 +42,9 @@ Use RGeo to:
 RGeo has the following prerequisites:
 
 * Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
-* GEOS 3.2 or later. This C/C++ library may be available via your
+  Rubinius and JRuby are not yet supported.
+* GEOS 3.2 or later highly recommended. Some functions will not be
+  available without it. This C/C++ library may be available via your
   operating system's package manager, or you can download it from
   http://trac.osgeo.org/geos/
 
@@ -71,12 +73,12 @@ For example:
 RGeo is currently under development and several planned features are not
 yet complete. These include:
 
-* Test coverage of the SimpleMercator implementation.
-* The spherical geometry data objects.
+* Some operations on SimpleCartesian and SimpleSpherical.
 * Rails (ActiveRecord or ActiveModel) integration.
 * Other third-party integration, including possibly SimpleGeo.
-* JRuby support via JTS.
-* Rubinius support.
+* Support for additional formats such as ESRI shapefiles.
+* JRuby support via JTS integration.
+* Rubinius support for Geos integration.
 
 Additionally, not all implemented features are well-tested yet. In
 general, we currently consider this library to be "pre-alpha" quality,

data/Version

@@ -1 +1 @@
-0.1.12
+0.1.13

data/ext/geos_c_impl/factory.c

@@ -49,12 +49,7 @@
 #include "polygon.h"
 #include "geometry_collection.h"
 
-#ifdef __cplusplus
-extern "C" {
-#if 0
-}
-#endif
-#endif
+RGEO_BEGIN_C
 
 
 /**** RUBY AND GEOS CALLBACKS ****/
@@ -330,9 +325,9 @@ VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VAL
 }
 
 
-const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj)
+const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type)
 {
-  VALUE object = rb_funcall(factory, rb_intern("cast"), 1, obj);
+  VALUE object = rb_funcall(RGEO_GLOBALS_FROM_FACTORY(factory)->features_module, rb_intern("cast"), 3, obj, factory, type);
   const GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
     geom = RGEO_GET_GEOS_GEOMETRY(object);
@@ -341,21 +336,24 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj)
 }
 
 
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(RGeo_Globals* globals, VALUE obj, VALUE* klasses)
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(RGeo_Globals* globals, VALUE obj, VALUE type, VALUE* klasses)
 {
   if (klasses) {
     *klasses = Qnil;
   }
-  VALUE object = rb_funcall(globals->default_factory, rb_intern("cast"), 2, obj, Qtrue);
+  VALUE object = rb_funcall(globals->features_module, rb_intern("cast"), 5, obj, globals->default_factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
   GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
     geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;
+    if (klasses) {
+      *klasses = RGEO_KLASSES_FROM_GEOMETRY(object);
+      if (NIL_P(*klasses)) {
+        *klasses = CLASS_OF(object);
+      }
+    }
     RGEO_GEOMETRY_DATA_PTR(object)->geom = NULL;
     RGEO_GEOMETRY_DATA_PTR(object)->factory = Qnil;
     RGEO_GEOMETRY_DATA_PTR(object)->klasses = Qnil;
-    if (klasses) {
-      *klasses = rgeo_is_geos_object(obj) ? RGEO_KLASSES_FROM_GEOMETRY(obj) : Qnil;
-    }
   }
   return geom;
 }
@@ -458,11 +456,6 @@ VALUE rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2)
 }
 
 
-#ifdef __cplusplus
-#if 0
-{
-#endif
-}
-#endif
+RGEO_END_C
 
 #endif

data/ext/geos_c_impl/factory.h

@@ -41,12 +41,7 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#ifdef __cplusplus
-extern "C" {
-#if 0
-}
-#endif
-#endif
+RGEO_BEGIN_C
 
 
 // Per-interpreter globals
@@ -158,25 +153,29 @@ VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VAL
 /*
   Gets the GEOS geometry for a given ruby Geometry object. If the given
   ruby object is not a GEOS geometry implementation, it is converted to a
-  GEOS implementation first. The returned GEOS geometry is owned by rgeo,
+  GEOS implementation first. You may also optionally cast it to a type,
+  specified by an appropriate feature module. Passing Qnil for the type
+  disables this auto-cast. The returned GEOS geometry is owned by rgeo,
   and you should not dispose it or take ownership of it yourself.
 */
-const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj);
+const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type);
 
 /*
   Gets a GEOS geometry for a given ruby Geometry object. If the given
   ruby object is not a GEOS geometry implementation, it is converted to a
-  GEOS implementation first. The returned GEOS geometry is owned by the
+  GEOS implementation first. You may also optionally cast it to a type,
+  specified by an appropriate feature module. Passing Qnil for the type
+  disables this auto-cast. The returned GEOS geometry is owned by the
   caller-- that is, if the original ruby object is a GEOS implementation,
   the returned GEOS geometry is a clone of the original.
   If the klasses parameters is not NULL, its referent is set to the
-  klasses saved in the original ruby Geometry object (if any), or to Qnil
-  if the original object is not a GEOS implementation. This is so that
-  you can use the result of this function to build a GEOS-backed clone
-  of the original geometry, or to include the given geometry in a
-  collection while keeping the klasses intact.
+  klasses saved in the original ruby Geometry object (if any), or else to
+  the class of the converted GEOS object. This is so that you can use the
+  result of this function to build a GEOS-backed clone of the original
+  geometry, or to include the given geometry in a collection while keeping
+  the klasses intact.
 */
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(RGeo_Globals* globals, VALUE obj, VALUE* klasses);
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(RGeo_Globals* globals, VALUE obj, VALUE type, VALUE* klasses);
 
 /*
   Returns 1 if the given ruby object is a GEOS Geometry implementation,
@@ -207,11 +206,6 @@ VALUE rgeo_geos_coordseqs_eql(GEOSContextHandle_t context, const GEOSGeometry* g
 VALUE rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2);
 
 
-#ifdef __cplusplus
-#if 0
-{
-#endif
-}
-#endif
+RGEO_END_C
 
 #endif

data/ext/geos_c_impl/geometry.c

@@ -46,12 +46,7 @@
 #include "factory.h"
 #include "geometry.h"
 
-#ifdef __cplusplus
-extern "C" {
-#if 0
-}
-#endif
-#endif
+RGEO_BEGIN_C
 
 
 /**** INTERNAL UTILITY FUNCTIONS ****/
@@ -121,17 +116,10 @@ static VALUE method_geometry_factory(VALUE self)
 }
 
 
-static VALUE method_geometry_cast(VALUE self, VALUE type)
+static VALUE method_geometry_set_factory(VALUE self, VALUE factory)
 {
-  VALUE result = Qnil;
-  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
-  if (self_geom) {
-    char* my_type_str = GEOSGeomType_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
-    VALUE type_name = rb_funcall(type, rb_intern("name"), 0);
-    result = strcmp(my_type_str, StringValuePtr(type_name)) ? Qnil : self;
-    free(my_type_str);
-  }
-  return result;
+  RGEO_GEOMETRY_DATA_PTR(self)->factory = factory;
+  return factory;
 }
 
 
@@ -305,7 +293,7 @@ static VALUE method_geometry_disjoint(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSDisjoint_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom);
       if (val == 0) {
@@ -325,7 +313,7 @@ static VALUE method_geometry_intersects(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSIntersects_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom);
       if (val == 0) {
@@ -345,7 +333,7 @@ static VALUE method_geometry_touches(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSTouches_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom);
       if (val == 0) {
@@ -365,7 +353,7 @@ static VALUE method_geometry_crosses(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSCrosses_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom);
       if (val == 0) {
@@ -385,7 +373,7 @@ static VALUE method_geometry_within(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSWithin_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom);
       if (val == 0) {
@@ -405,7 +393,7 @@ static VALUE method_geometry_contains(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSContains_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom);
       if (val == 0) {
@@ -425,7 +413,7 @@ static VALUE method_geometry_overlaps(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSOverlaps_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom);
       if (val == 0) {
@@ -445,7 +433,7 @@ static VALUE method_geometry_relate(VALUE self, VALUE rhs, VALUE pattern)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       char val = GEOSRelatePattern_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom, StringValuePtr(pattern));
       if (val == 0) {
@@ -465,7 +453,7 @@ static VALUE method_geometry_distance(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       double dist;
       if (GEOSDistance_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom, &dist)) {
@@ -505,7 +493,7 @@ static VALUE method_geometry_intersection(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSIntersection_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom), Qnil);
     }
@@ -519,7 +507,7 @@ static VALUE method_geometry_union(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSUnion_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom), Qnil);
     }
@@ -533,7 +521,7 @@ static VALUE method_geometry_difference(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSDifference_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom), Qnil);
     }
@@ -547,7 +535,7 @@ static VALUE method_geometry_sym_difference(VALUE self, VALUE rhs)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs);
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSSymDifference_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, rhs_geom), Qnil);
     }
@@ -596,10 +584,10 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   VALUE geos_geometry_class = rb_define_class_under(globals->geos_module, "GeometryImpl", rb_cObject);
   
   rb_define_alloc_func(geos_geometry_class, alloc_geometry);
+  rb_define_method(geos_geometry_class, "_set_factory", method_geometry_set_factory, 1);
   rb_define_method(geos_geometry_class, "initialize_copy", method_geometry_initialize_copy, 1);
   rb_define_method(geos_geometry_class, "initialized?", method_geometry_initialized_p, 0);
   rb_define_method(geos_geometry_class, "factory", method_geometry_factory, 0);
-  rb_define_method(geos_geometry_class, "cast", method_geometry_cast, 1);
   rb_define_method(geos_geometry_class, "dimension", method_geometry_dimension, 0);
   rb_define_method(geos_geometry_class, "geometry_type", method_geometry_geometry_type, 0);
   rb_define_method(geos_geometry_class, "srid", method_geometry_srid, 0);
@@ -634,11 +622,6 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
 }
 
 
-#ifdef __cplusplus
-#if 0
-{
-#endif
-}
-#endif
+RGEO_END_C
 
 #endif

data/ext/geos_c_impl/geometry.h

@@ -40,12 +40,7 @@
 
 #include "factory.h"
 
-#ifdef __cplusplus
-extern "C" {
-#if 0
-}
-#endif
-#endif
+RGEO_BEGIN_C
 
 
 /*
@@ -55,11 +50,6 @@ extern "C" {
 void rgeo_init_geos_geometry(RGeo_Globals* globals);
 
 
-#ifdef __cplusplus
-#if 0
-{
-#endif
-}
-#endif
+RGEO_END_C
 
 #endif

data/ext/geos_c_impl/geometry_collection.c

@@ -48,179 +48,64 @@
 #include "polygon.h"
 #include "geometry_collection.h"
 
-#ifdef __cplusplus
-extern "C" {
-#if 0
-}
-#endif
-#endif
+RGEO_BEGIN_C
 
 
 /**** INTERNAL IMPLEMENTATION OF CREATE ****/
 
 
-static char compute_collection_klasses_internal(int type, VALUE factory, const GEOSGeometry* geom, VALUE in_klass, VALUE out_klasses)
-{
-  char good = 1;
-  int geom_type = GEOSGeomTypeId_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom);
-  if (type == GEOS_MULTIPOINT && geom_type == GEOS_POINT ||
-      type == GEOS_MULTILINESTRING && (geom_type == GEOS_LINESTRING || geom_type == GEOS_LINEARRING) ||
-      type == GEOS_MULTIPOLYGON && geom_type == GEOS_POLYGON) {
-    rb_ary_push(out_klasses, in_klass);
-  }
-  else if (geom_type == GEOS_GEOMETRYCOLLECTION || type == geom_type) {
-    int len = GEOSGetNumGeometries_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom);
-    int i;
-    for (i=0; i<len; ++i) {
-      const GEOSGeometry* sub_geom = GEOSGetGeometryN_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom, i);
-      if (sub_geom) {
-        VALUE sub_klass = (TYPE(in_klass) == T_ARRAY) ? rb_ary_entry(in_klass, i) : Qnil;
-        good = compute_collection_klasses_internal(type, factory, sub_geom, sub_klass, out_klasses);
-        if (!good) {
-          break;
-        }
-      }
-      else {
-        good = 0;
-        break;
-      }
-    }
-  }
-  else {
-    good = 0;
-  }
-  return good;
-}
-
-
-// This walks through an array of geometry objects, and determines the
-// size of the collection that should be built. For straight
-// GeometryCollection objects, the size is the same as the length of
-// the array. For MultiPoint, MultiLineString, and MultiPolygon, we do
-// recursive gathering of any sub-geometries, so the resulting collection
-// may have a different length.
-// We also build an array of the klasses for the geometries gathered.
-// The array is returned. If a problem occurs-- usually a type mismatch
-// such as trying to add a LineString to a MultiPoint-- we return Qnil.
+// Main implementation of the "create" class method for geometry collections.
+// You must pass in the correct GEOS geometry type ID.
 
-static VALUE compute_collection_klasses(int type, VALUE factory, VALUE array)
+static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
 {
+  VALUE result = Qnil;
+  Check_Type(array, T_ARRAY);
   unsigned int len = (unsigned int)RARRAY_LEN(array);
-  VALUE result = rb_ary_new();
-  unsigned int i;
-  for (i=0; i<len; ++i) {
-    VALUE entry = rb_ary_entry(array, i);
-    const GEOSGeometry* geom = rgeo_get_geos_geometry_safe(entry);
-    if (!geom) {
-      result = Qnil;
+  GEOSGeometry** geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
+  if (geoms) {
+    VALUE klass;
+    unsigned int i,j;
+    VALUE klasses = Qnil;
+    VALUE cast_type = Qnil;
+    switch (type) {
+    case GEOS_MULTIPOINT:
+      cast_type = rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->features_module, rb_intern("Point"));
+      break;
+    case GEOS_MULTILINESTRING:
+      cast_type = rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->features_module, rb_intern("LineString"));
+      break;
+    case GEOS_MULTIPOLYGON:
+      cast_type = rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->features_module, rb_intern("Polygon"));
       break;
     }
-    VALUE klass = RGEO_KLASSES_FROM_GEOMETRY(entry);
-    if (NIL_P(klass)) {
-      klass = CLASS_OF(entry);
-    }
-    if (type == GEOS_GEOMETRYCOLLECTION) {
-      rb_ary_push(result, klass);
-    }
-    else {
-      char good = compute_collection_klasses_internal(type, factory, geom, klass, result);
-      if (!good) {
-        result = Qnil;
-        break;
-      }
-    }
-  }
-  return result;
-}
-
-
-static char gather_geometry_collection_internal(int type, VALUE factory, GEOSGeometry** geoms, unsigned int* ci, const GEOSGeometry* geom, char geom_mine)
-{
-  char good = 1;
-  int geom_type = GEOSGeomTypeId_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom);
-  if (type != GEOS_GEOMETRYCOLLECTION && (geom_type == GEOS_GEOMETRYCOLLECTION || geom_type == type)) {
-    int len = GEOSGetNumGeometries_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom);
-    int i;
     for (i=0; i<len; ++i) {
-      const GEOSGeometry* sub_geom = GEOSGetGeometryN_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom, i);
-      if (sub_geom) {
-        good = gather_geometry_collection_internal(type, factory, geoms, ci, sub_geom, 0);
-        if (!good) {
-          break;
-        }
-      }
-      else {
-        good = 0;
+      GEOSGeometry* geom = rgeo_convert_to_detached_geos_geometry(RGEO_GLOBALS_FROM_FACTORY(factory), rb_ary_entry(array, i), cast_type, &klass);
+      if (!geom) {
         break;
       }
-    }
-  }
-  else {
-    geoms[(*ci)++] = geom_mine ? (GEOSGeometry*)geom : GEOSGeom_clone_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom);
-  }
-  return good;
-}
-
-
-// This walks through the array of geometries and builds a C array of the
-// geometries to add to the collection we're building. If we're building
-// a simple GeometryCollection, we just gather the geometries as they are.
-// If we're building a MultiPoint, MultiLineString, or MultiPolygon, we
-// recursively gather the contents of any collections we encounter.
-
-static GEOSGeometry** gather_geometry_collection(int type, VALUE factory, VALUE array, unsigned int len)
-{
-  GEOSGeometry** geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
-  unsigned int ci = 0;
-  if (geoms) {
-    unsigned int array_len = (unsigned int)RARRAY_LEN(array);
-    unsigned int ai;
-    for (ai=0; ai<array_len; ++ai) {
-      GEOSGeometry* geom = rgeo_convert_to_detached_geos_geometry(RGEO_GLOBALS_FROM_FACTORY(factory), rb_ary_entry(array, ai), NULL);
-      if (geom) {
-        if (!gather_geometry_collection_internal(type, factory, geoms, &ci, geom, 1)) {
-          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);
         }
       }
-      else {
-        break;
+      if (!NIL_P(klasses)) {
+        rb_ary_push(klasses, klass);
       }
     }
-  }
-  if (ci != len) {
-    unsigned int i;
-    for (i=0; i<ci; ++i) {
-      GEOSGeom_destroy_r(RGEO_CONTEXT_FROM_FACTORY(factory), geoms[i]);
+    if (i != len) {
+      for (j=0; j<i; ++j) {
+        GEOSGeom_destroy_r(RGEO_CONTEXT_FROM_FACTORY(factory), geoms[j]);
+      }
     }
-    free(geoms);
-    geoms = NULL;
-  }
-  return geoms;
-}
-
-
-// Main implementation of the "create" class method for geometry collections.
-// You must pass in the correct GEOS geometry type ID.
-
-static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
-{
-  VALUE result = Qnil;
-  Check_Type(array, T_ARRAY);
-  // First pass: we determine the size of the collection to create, and
-  // build the klasses array.
-  VALUE klasses = compute_collection_klasses(type, factory, array);
-  if (!NIL_P(klasses)) {
-    unsigned int len = (unsigned int)RARRAY_LEN(klasses);
-    // Second pass: we gather the actual geometries into a C array
-    GEOSGeometry** geoms = gather_geometry_collection(type, factory, array, len);
-    if (geoms) {
-      // Create the collection itself.
+    else {
       GEOSGeometry* collection = GEOSGeom_createCollection_r(RGEO_CONTEXT_FROM_FACTORY(factory), 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 && (RGEO_FACTORY_DATA_PTR(factory)->flags & 1) == 0) {
         char problem = 0;
-        unsigned int i, j;
         for (i=1; i<len; ++i) {
           for (j=0; j<i; ++j) {
             GEOSGeometry* igeom = geoms[i];
@@ -251,9 +136,10 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
       // 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);
     }
+    free(geoms);
   }
+  
   return result;
 }
 
@@ -570,11 +456,6 @@ VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOS
 }
 
 
-#ifdef __cplusplus
-#if 0
-{
-#endif
-}
-#endif
+RGEO_END_C
 
 #endif