rgeo 0.3.13 → 0.3.14

data/ext/geos_c_impl/geometry_collection.h

@@ -63,6 +63,15 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals);
 */
 VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
 
+/*
+  A tool for building up hash values.
+  You must pass in the context, a geos geometry, and a seed hash.
+  Returns an updated hash.
+  This call is useful in sequence, and should be bracketed by calls to
+  rb_hash_start and rb_hash_end.
+*/
+st_index_t rgeo_geos_geometry_collection_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
+
 
 RGEO_END_C
 

data/ext/geos_c_impl/line_string.c

@@ -307,6 +307,54 @@ static VALUE method_line_string_eql(VALUE self, VALUE rhs)
 }
 
 
+static VALUE method_line_string_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  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_line_string, hash);
+  hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
+static VALUE method_linear_ring_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  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_linear_ring, hash);
+  hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
+static VALUE method_line_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  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_line, hash);
+  hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
 static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char close)
 {
   RGeo_FactoryData* factory_data;
@@ -543,51 +591,46 @@ static VALUE cmethod_linear_ring_copy_from(VALUE klass, VALUE factory, VALUE ori
 
 void rgeo_init_geos_line_string(RGeo_Globals* globals)
 {
-  VALUE geos_line_string_class;
-  VALUE geos_linear_ring_class;
-  VALUE geos_line_class;
-
-  geos_line_string_class = rb_define_class_under(globals->geos_module, "LineStringImpl", globals->geos_geometry);
-  globals->geos_line_string = geos_line_string_class;
-  globals->feature_line_string = rb_const_get_at(globals->feature_module, rb_intern("LineString"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    rb_const_get_at(globals->feature_module, rb_intern("Curve")), geos_line_string_class);
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_line_string, geos_line_string_class);
-
-  geos_linear_ring_class = rb_define_class_under(globals->geos_module, "LinearRingImpl", geos_line_string_class);
-  globals->geos_linear_ring = geos_linear_ring_class;
-  globals->feature_linear_ring = rb_const_get_at(globals->feature_module, rb_intern("LinearRing"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_linear_ring, geos_linear_ring_class);
-
-  geos_line_class = rb_define_class_under(globals->geos_module, "LineImpl", geos_line_string_class);
-  globals->geos_line = geos_line_class;
-  globals->feature_line = rb_const_get_at(globals->feature_module, rb_intern("Line"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_line, geos_line_class);
-
-  rb_define_module_function(geos_line_string_class, "create", cmethod_create_line_string, 2);
-  rb_define_module_function(geos_line_string_class, "_copy_from", cmethod_line_string_copy_from, 2);
-  rb_define_method(geos_line_string_class, "rep_equals?", method_line_string_eql, 1);
-  rb_define_method(geos_line_string_class, "eql?", method_line_string_eql, 1);
-  rb_define_method(geos_line_string_class, "geometry_type", method_line_string_geometry_type, 0);
-  rb_define_method(geos_line_string_class, "length", method_line_string_length, 0);
-  rb_define_method(geos_line_string_class, "num_points", method_line_string_num_points, 0);
-  rb_define_method(geos_line_string_class, "point_n", method_line_string_point_n, 1);
-  rb_define_method(geos_line_string_class, "points", method_line_string_points, 0);
-  rb_define_method(geos_line_string_class, "start_point", method_line_string_start_point, 0);
-  rb_define_method(geos_line_string_class, "end_point", method_line_string_end_point, 0);
-  rb_define_method(geos_line_string_class, "is_closed?", method_line_string_is_closed, 0);
-  rb_define_method(geos_line_string_class, "is_ring?", method_line_string_is_ring, 0);
-
-  rb_define_module_function(geos_linear_ring_class, "create", cmethod_create_linear_ring, 2);
-  rb_define_module_function(geos_linear_ring_class, "_copy_from", cmethod_linear_ring_copy_from, 2);
-  rb_define_method(geos_linear_ring_class, "geometry_type", method_linear_ring_geometry_type, 0);
-
-  rb_define_module_function(geos_line_class, "create", cmethod_create_line, 3);
-  rb_define_module_function(geos_line_class, "_copy_from", cmethod_line_copy_from, 2);
-  rb_define_method(geos_line_class, "geometry_type", method_line_geometry_type, 0);
+  VALUE geos_line_string_methods;
+  VALUE geos_linear_ring_methods;
+  VALUE geos_line_methods;
+
+  // Class methods for CAPILineStringImpl
+  rb_define_module_function(globals->geos_line_string, "create", cmethod_create_line_string, 2);
+  rb_define_module_function(globals->geos_line_string, "_copy_from", cmethod_line_string_copy_from, 2);
+
+  // Class methods for CAPILinearRingImpl
+  rb_define_module_function(globals->geos_linear_ring, "create", cmethod_create_linear_ring, 2);
+  rb_define_module_function(globals->geos_linear_ring, "_copy_from", cmethod_linear_ring_copy_from, 2);
+
+  // Class methods for CAPILineImpl
+  rb_define_module_function(globals->geos_line, "create", cmethod_create_line, 3);
+  rb_define_module_function(globals->geos_line, "_copy_from", cmethod_line_copy_from, 2);
+
+  // CAPILineStringMethods module
+  geos_line_string_methods = rb_define_module_under(globals->geos_module, "CAPILineStringMethods");
+  rb_define_method(geos_line_string_methods, "rep_equals?", method_line_string_eql, 1);
+  rb_define_method(geos_line_string_methods, "eql?", method_line_string_eql, 1);
+  rb_define_method(geos_line_string_methods, "hash", method_line_string_hash, 0);
+  rb_define_method(geos_line_string_methods, "geometry_type", method_line_string_geometry_type, 0);
+  rb_define_method(geos_line_string_methods, "length", method_line_string_length, 0);
+  rb_define_method(geos_line_string_methods, "num_points", method_line_string_num_points, 0);
+  rb_define_method(geos_line_string_methods, "point_n", method_line_string_point_n, 1);
+  rb_define_method(geos_line_string_methods, "points", method_line_string_points, 0);
+  rb_define_method(geos_line_string_methods, "start_point", method_line_string_start_point, 0);
+  rb_define_method(geos_line_string_methods, "end_point", method_line_string_end_point, 0);
+  rb_define_method(geos_line_string_methods, "is_closed?", method_line_string_is_closed, 0);
+  rb_define_method(geos_line_string_methods, "is_ring?", method_line_string_is_ring, 0);
+
+  // CAPILinearRingMethods module
+  geos_linear_ring_methods = rb_define_module_under(globals->geos_module, "CAPILinearRingMethods");
+  rb_define_method(geos_linear_ring_methods, "geometry_type", method_linear_ring_geometry_type, 0);
+  rb_define_method(geos_linear_ring_methods, "hash", method_linear_ring_hash, 0);
+
+  // CAPILineMethods module
+  geos_line_methods = rb_define_module_under(globals->geos_module, "CAPILineMethods");
+  rb_define_method(geos_line_methods, "geometry_type", method_line_geometry_type, 0);
+  rb_define_method(geos_line_methods, "hash", method_line_hash, 0);
 }
 
 

data/ext/geos_c_impl/point.c

@@ -166,6 +166,22 @@ static VALUE method_point_eql(VALUE self, VALUE rhs)
 }
 
 
+static VALUE method_point_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  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_point, hash);
+  hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
 static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE z)
 {
   return rgeo_create_geos_point(factory, rb_num2dbl(x), rb_num2dbl(y),
@@ -175,23 +191,21 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE
 
 void rgeo_init_geos_point(RGeo_Globals* globals)
 {
-  VALUE geos_point_class;
-
-  geos_point_class = rb_define_class_under(globals->geos_module, "PointImpl", globals->geos_geometry);
-  globals->geos_point = geos_point_class;
-  globals->feature_point = rb_const_get_at(globals->feature_module, rb_intern("Point"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_point, geos_point_class);
-
-  rb_define_module_function(geos_point_class, "create", cmethod_create, 4);
-
-  rb_define_method(geos_point_class, "rep_equals?", method_point_eql, 1);
-  rb_define_method(geos_point_class, "eql?", method_point_eql, 1);
-  rb_define_method(geos_point_class, "geometry_type", method_point_geometry_type, 0);
-  rb_define_method(geos_point_class, "x", method_point_x, 0);
-  rb_define_method(geos_point_class, "y", method_point_y, 0);
-  rb_define_method(geos_point_class, "z", method_point_z, 0);
-  rb_define_method(geos_point_class, "m", method_point_m, 0);
+  VALUE geos_point_methods;
+
+  // Class methods for CAPIPointImpl
+  rb_define_module_function(globals->geos_point, "create", cmethod_create, 4);
+
+  // CAPIPointMethods module
+  geos_point_methods = rb_define_module_under(globals->geos_module, "CAPIPointMethods");
+  rb_define_method(geos_point_methods, "rep_equals?", method_point_eql, 1);
+  rb_define_method(geos_point_methods, "eql?", method_point_eql, 1);
+  rb_define_method(geos_point_methods, "hash", method_point_hash, 0);
+  rb_define_method(geos_point_methods, "geometry_type", method_point_geometry_type, 0);
+  rb_define_method(geos_point_methods, "x", method_point_x, 0);
+  rb_define_method(geos_point_methods, "y", method_point_y, 0);
+  rb_define_method(geos_point_methods, "z", method_point_z, 0);
+  rb_define_method(geos_point_methods, "m", method_point_m, 0);
 }
 
 

data/ext/geos_c_impl/polygon.c

@@ -64,6 +64,22 @@ static VALUE method_polygon_eql(VALUE self, VALUE rhs)
 }
 
 
+static VALUE method_polygon_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  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_polygon, hash);
+  hash = rgeo_geos_polygon_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
 static VALUE method_polygon_geometry_type(VALUE self)
 {
   VALUE result;
@@ -272,28 +288,24 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
 
 void rgeo_init_geos_polygon(RGeo_Globals* globals)
 {
-  VALUE geos_polygon_class;
-
-  geos_polygon_class = rb_define_class_under(globals->geos_module, "PolygonImpl", globals->geos_geometry);
-  globals->geos_polygon = geos_polygon_class;
-  globals->feature_polygon = rb_const_get_at(globals->feature_module, rb_intern("Polygon"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    rb_const_get_at(globals->feature_module, rb_intern("Surface")), geos_polygon_class);
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_polygon, geos_polygon_class);
-
-  rb_define_module_function(geos_polygon_class, "create", cmethod_create, 3);
-
-  rb_define_method(geos_polygon_class, "rep_equals?", method_polygon_eql, 1);
-  rb_define_method(geos_polygon_class, "eql?", method_polygon_eql, 1);
-  rb_define_method(geos_polygon_class, "geometry_type", method_polygon_geometry_type, 0);
-  rb_define_method(geos_polygon_class, "area", method_polygon_area, 0);
-  rb_define_method(geos_polygon_class, "centroid", method_polygon_centroid, 0);
-  rb_define_method(geos_polygon_class, "point_on_surface", method_polygon_point_on_surface, 0);
-  rb_define_method(geos_polygon_class, "exterior_ring", method_polygon_exterior_ring, 0);
-  rb_define_method(geos_polygon_class, "num_interior_rings", method_polygon_num_interior_rings, 0);
-  rb_define_method(geos_polygon_class, "interior_ring_n", method_polygon_interior_ring_n, 1);
-  rb_define_method(geos_polygon_class, "interior_rings", method_polygon_interior_rings, 0);
+  VALUE geos_polygon_methods;
+
+  // Class methods for CAPIPolygonImpl
+  rb_define_module_function(globals->geos_polygon, "create", cmethod_create, 3);
+
+  // CAPIPolygonMethods module
+  geos_polygon_methods = rb_define_module_under(globals->geos_module, "CAPIPolygonMethods");
+  rb_define_method(geos_polygon_methods, "rep_equals?", method_polygon_eql, 1);
+  rb_define_method(geos_polygon_methods, "eql?", method_polygon_eql, 1);
+  rb_define_method(geos_polygon_methods, "hash", method_polygon_hash, 0);
+  rb_define_method(geos_polygon_methods, "geometry_type", method_polygon_geometry_type, 0);
+  rb_define_method(geos_polygon_methods, "area", method_polygon_area, 0);
+  rb_define_method(geos_polygon_methods, "centroid", method_polygon_centroid, 0);
+  rb_define_method(geos_polygon_methods, "point_on_surface", method_polygon_point_on_surface, 0);
+  rb_define_method(geos_polygon_methods, "exterior_ring", method_polygon_exterior_ring, 0);
+  rb_define_method(geos_polygon_methods, "num_interior_rings", method_polygon_num_interior_rings, 0);
+  rb_define_method(geos_polygon_methods, "interior_ring_n", method_polygon_interior_ring_n, 1);
+  rb_define_method(geos_polygon_methods, "interior_rings", method_polygon_interior_rings, 0);
 }
 
 
@@ -332,6 +344,22 @@ VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* ge
 }
 
 
+st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
+{
+  unsigned int len;
+  unsigned int i;
+
+  if (geom) {
+    hash = rgeo_geos_coordseq_hash(context, GEOSGetExteriorRing_r(context, geom), hash);
+    len = GEOSGetNumInteriorRings_r(context, geom);
+    for (i=0; i<len; ++i) {
+      hash = rgeo_geos_coordseq_hash(context, GEOSGetInteriorRingN_r(context, geom, i), hash);
+    }
+  }
+  return hash;
+}
+
+
 RGEO_END_C
 
 #endif

data/ext/geos_c_impl/polygon.h

@@ -60,6 +60,15 @@ void rgeo_init_geos_polygon(RGeo_Globals* globals);
 */
 VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
 
+/*
+  A tool for building up hash values.
+  You must pass in the context, a geos geometry, and a seed hash.
+  Returns an updated hash.
+  This call is useful in sequence, and should be bracketed by calls to
+  rb_hash_start and rb_hash_end.
+*/
+st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
+
 
 RGEO_END_C
 

data/ext/geos_c_impl/preface.h

@@ -50,6 +50,16 @@
 #ifdef HAVE_GEOSWKTWWRITER_SETOUTPUTDIMENSION_R
 #define RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
 #endif
+#ifdef HAVE_RB_MEMHASH
+#define RGEO_SUPPORTS_NEW_HASHING
+#endif
+
+#ifndef RGEO_SUPPORTS_NEW_HASHING
+#define st_index_t int
+#define rb_memhash(x,y) rgeo_internal_memhash(x,y)
+#define rb_hash_start(x) ((st_index_t)(x ^ 0xdeadbeef))
+#define rb_hash_end(x) ((st_index_t)(x ^ 0xbeefdead))
+#endif
 
 #ifdef __cplusplus
 #define RGEO_BEGIN_C extern "C" {

data/lib/rgeo/cartesian/factory.rb

@@ -114,11 +114,19 @@ module RGeo
       # Equivalence test.
 
       def eql?(rhs_)
-        rhs_.is_a?(self.class) && @srid == rhs_.srid && @has_z == rhs_.property(:has_z_coordinate) && @has_m == rhs_.property(:has_m_coordinate)
+        rhs_.is_a?(self.class) && @srid == rhs_.srid &&
+          @has_z == rhs_.property(:has_z_coordinate) &&
+          @has_m == rhs_.property(:has_m_coordinate) &&
+          @proj4.eql?(rhs_.proj4)
       end
       alias_method :==, :eql?
 
 
+      def hash
+        @hash ||= [@srid, @has_z, @has_m, @proj4].hash
+      end
+
+
       # Marshal support
 
       def marshal_dump  # :nodoc:

data/lib/rgeo/coord_sys/cs/entities.rb

@@ -192,6 +192,11 @@ module RGeo
         alias_method :==, :eql?
 
 
+        def hash
+          @hash ||= self.to_wkt.hash
+        end
+
+
         # Returns the default WKT representation.
 
         def to_s
@@ -206,7 +211,11 @@ module RGeo
         #   brackets. Default is false.
 
         def to_wkt(opts_={})
-          opts_[:standard_brackets] ? _to_wkt('(', ')') : _to_wkt('[', ']')
+          if opts_[:standard_brackets]
+            @standard_wkt ||= _to_wkt('(', ')')
+          else
+            @square_wkt ||= _to_wkt('[', ']')
+          end
         end
 
 

data/lib/rgeo/coord_sys/proj4.rb

@@ -64,7 +64,7 @@ module RGeo
 
 
       def hash  # :nodoc:
-        canonical_hash.hash
+        @hash ||= canonical_hash.hash
       end
 
 

data/lib/rgeo/feature/types.rb

@@ -47,20 +47,40 @@ module RGeo
     end
 
 
-    # These methods are available as module methods (not instance methods)
-    # of the various feature types.
+    # This module provides the API for geometry type objects. Technically
+    # these objects are modules (such as ::RGeo::Feature::Point), but as
+    # objects they respond to the methods documented here.
+    #
     # For example, you may determine whether a feature object is a
     # point by calling:
     #
     #   ::RGeo::Feature::Point.check_type(object)
     #
     # A corresponding === operator is provided so you can use the type
-    # modules in a case-when clause.
+    # modules in a case-when clause:
+    #
+    #   case object
+    #   when ::RGeo::Feature::Point
+    #     # do stuff here...
+    #
+    # However, a feature object may not actually include the point module
+    # itself; hence, the following will *not* work:
+    #
+    #   object.is_a?(::RGeo::Feature::Point)  # DON'T DO THIS-- DOES NOT WORK
+    #
+    # You may obtain the type of a feature object by calling its
+    # geometry_type method. You may then use the methods in this module to
+    # interrogate that type.
+    #
+    #   # supppose object is a Point
+    #   type = object.geometry_type  # ::RGeo::Feature::Point
+    #   type.type_name               # "Point"
+    #   type.supertype               # ::RGeo::Feature::Geometry
     #
     # You may also use the presence of this module to determine whether
     # a particular object is a feature type:
     #
-    #   object.kind_of?(::RGeo::Feature::Type)
+    #   ::RGeo::Feature::Type === object.geometry_type  # true
 
     module Type
 
@@ -74,6 +94,7 @@ module RGeo
       # this type or a subtype thereof.
       #
       # Note that feature objects need not actually include this module.
+      # Therefore, the is_a? method will generally not work.
 
       def check_type(rhs_)
         rhs_ = rhs_.geometry_type if rhs_.kind_of?(Feature::Instance)
@@ -105,11 +126,14 @@ module RGeo
       end
 
 
-      # Returns the OpenGIS type name of this type.
+      # Returns the OpenGIS type name of this type. For example:
+      #
+      #   ::RGeo::Feature::Point.type_name  # "Point"
 
       def type_name
         self.name.sub('RGeo::Feature::', '')
       end
+      alias_method :to_s, :type_name
 
 
       def _add_subtype(type_)  # :nodoc: