rgeo 0.3.13 → 0.3.14

data/lib/rgeo/geos/{ffi_classes.rb → ffi_feature_methods.rb}

@@ -39,12 +39,10 @@ module RGeo
   module Geos
 
 
-    class FFIGeometryImpl  # :nodoc:
+    module FFIGeometryMethods  # :nodoc:
 
       include Feature::Instance
 
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self)
-
 
       def initialize(factory_, fg_geom_, klasses_)
         @factory = factory_
@@ -143,7 +141,7 @@ module RGeo
         if fg_geom_.type_id == ::Geos::GeomTypes::GEOS_POINT && fg_geom_.empty?
           fg_geom_ = ::Geos::Utils.create_geometry_collection
         end
-        @factory.wrap_fg_geom(fg_geom_)
+        @factory._wrap_fg_geom(fg_geom_, nil)
       end
 
 
@@ -151,7 +149,7 @@ module RGeo
         if self.class == FFIGeometryCollectionImpl
           nil
         else
-          @factory.wrap_fg_geom(@fg_geom.boundary)
+          @factory._wrap_fg_geom(@fg_geom.boundary, nil)
         end
       end
 
@@ -286,18 +284,18 @@ module RGeo
 
 
       def buffer(distance_)
-        @factory.wrap_fg_geom(@fg_geom.buffer(distance_, @factory.buffer_resolution))
+        @factory._wrap_fg_geom(@fg_geom.buffer(distance_, @factory.buffer_resolution), nil)
       end
 
 
       def convex_hull
-        @factory.wrap_fg_geom(@fg_geom.convex_hull)
+        @factory._wrap_fg_geom(@fg_geom.convex_hull, nil)
       end
 
 
       def intersection(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
-        fg_ ? @factory.wrap_fg_geom(@fg_geom.intersection(fg_)) : nil
+        fg_ ? @factory._wrap_fg_geom(@fg_geom.intersection(fg_), nil) : nil
       end
 
       alias_method :*, :intersection
@@ -305,7 +303,7 @@ module RGeo
 
       def union(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
-        fg_ ? @factory.wrap_fg_geom(@fg_geom.union(fg_)) : nil
+        fg_ ? @factory._wrap_fg_geom(@fg_geom.union(fg_), nil) : nil
       end
 
       alias_method :+, :union
@@ -313,7 +311,7 @@ module RGeo
 
       def difference(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
-        fg_ ? @factory.wrap_fg_geom(@fg_geom.difference(fg_)) : nil
+        fg_ ? @factory._wrap_fg_geom(@fg_geom.difference(fg_), nil) : nil
       end
 
       alias_method :-, :difference
@@ -321,7 +319,7 @@ module RGeo
 
       def sym_difference(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
-        fg_ ? @factory.wrap_fg_geom(@fg_geom.sym_difference(fg_)) : nil
+        fg_ ? @factory._wrap_fg_geom(@fg_geom.sym_difference(fg_), nil) : nil
       end
 
 
@@ -355,9 +353,7 @@ module RGeo
     end
 
 
-    class FFIPointImpl < FFIGeometryImpl  # :nodoc:
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self)
+    module FFIPointMethods  # :nodoc:
 
 
       def x
@@ -399,14 +395,15 @@ module RGeo
       end
 
 
-    end
+      def hash
+        @hash ||= Utils.ffi_coord_seq_hash(@fg_geom.coord_seq, [@factory, geometry_type].hash)
+      end
 
 
-    class FFILineStringImpl < FFIGeometryImpl  # :nodoc:
+    end
 
 
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Curve).include_in_class(self)
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self)
+    module FFILineStringMethods  # :nodoc:
 
 
       def geometry_type
@@ -475,13 +472,15 @@ module RGeo
       end
 
 
-    end
+      def hash
+        @hash ||= Utils.ffi_coord_seq_hash(@fg_geom.coord_seq, [@factory, geometry_type].hash)
+      end
 
 
-    class FFILinearRingImpl < FFILineStringImpl  # :nodoc:
+    end
 
 
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self)
+    module FFILinearRingMethods  # :nodoc:
 
 
       def geometry_type
@@ -492,10 +491,7 @@ module RGeo
     end
 
 
-    class FFILineImpl < FFILineStringImpl  # :nodoc:
-
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self)
+    module FFILineMethods  # :nodoc:
 
 
       def geometry_type
@@ -506,11 +502,7 @@ module RGeo
     end
 
 
-    class FFIPolygonImpl < FFIGeometryImpl  # :nodoc:
-
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Surface).include_in_class(self)
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self)
+    module FFIPolygonMethods  # :nodoc:
 
 
       def geometry_type
@@ -524,17 +516,17 @@ module RGeo
 
 
       def centroid
-        @factory.wrap_fg_geom(@fg_geom.centroid, FFIPointImpl)
+        @factory._wrap_fg_geom(@fg_geom.centroid, FFIPointImpl)
       end
 
 
       def point_on_surface
-        @factory.wrap_fg_geom(@fg_geom.point_on_surface, FFIPointImpl)
+        @factory._wrap_fg_geom(@fg_geom.point_on_surface, FFIPointImpl)
       end
 
 
       def exterior_ring
-        @factory.wrap_fg_geom(@fg_geom.exterior_ring, FFILinearRingImpl)
+        @factory._wrap_fg_geom(@fg_geom.exterior_ring, FFILinearRingImpl)
       end
 
 
@@ -545,7 +537,7 @@ module RGeo
 
       def interior_ring_n(n_)
         if n_ >= 0 && n_ < @fg_geom.num_interior_rings
-          @factory.wrap_fg_geom(@fg_geom.interior_ring_n(n_), FFILinearRingImpl)
+          @factory._wrap_fg_geom(@fg_geom.interior_ring_n(n_), FFILinearRingImpl)
         else
           nil
         end
@@ -554,7 +546,7 @@ module RGeo
 
       def interior_rings
         ::Array.new(@fg_geom.num_interior_rings) do |n_|
-          @factory.wrap_fg_geom(@fg_geom.interior_ring_n(n_), FFILinearRingImpl)
+          @factory._wrap_fg_geom(@fg_geom.interior_ring_n(n_), FFILinearRingImpl)
         end
       end
 
@@ -576,13 +568,21 @@ module RGeo
       end
 
 
-    end
+      def hash
+        @hash ||= begin
+          hash_ = Utils.ffi_coord_seq_hash(@fg_geom.exterior_ring.coord_seq,
+            [@factory, geometry_type].hash)
+          @fg_geom.interior_rings.inject(hash_) do |h_, r_|
+            Utils.ffi_coord_seq_hash(r_.coord_seq, h_)
+          end
+        end
+      end
 
 
-    class FFIGeometryCollectionImpl < FFIGeometryImpl  # :nodoc:
+    end
 
 
-      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self)
+    module FFIGeometryCollectionMethods  # :nodoc:
 
 
       def geometry_type
@@ -612,7 +612,7 @@ module RGeo
 
       def geometry_n(n_)
         if n_ >= 0 && n_ < @fg_geom.num_geometries
-          @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n_),
+          @factory._wrap_fg_geom(@fg_geom.get_geometry_n(n_),
             @_klasses ? @_klasses[n_] : nil)
         else
           nil
@@ -623,7 +623,7 @@ module RGeo
       def [](n_)
         n_ += @fg_geom.num_geometries if n_ < 0
         if n_ >= 0 && n_ < @fg_geom.num_geometries
-          @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n_),
+          @factory._wrap_fg_geom(@fg_geom.get_geometry_n(n_),
             @_klasses ? @_klasses[n_] : nil)
         else
           nil
@@ -631,10 +631,20 @@ module RGeo
       end
 
 
+      def hash
+        @hash ||= begin
+          hash_ = [@factory, geometry_type].hash
+          (0...num_geometries).inject(hash_) do |h_, i_|
+            (1664525 * h_ + geometry_n(i_).hash).hash
+          end
+        end
+      end
+
+
       def each
         if block_given?
           @fg_geom.num_geometries.times do |n_|
-            yield @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n_),
+            yield @factory._wrap_fg_geom(@fg_geom.get_geometry_n(n_),
               @_klasses ? @_klasses[n_] : nil)
           end
           self
@@ -649,10 +659,7 @@ module RGeo
     end
 
 
-    class FFIMultiPointImpl < FFIGeometryCollectionImpl  # :nodoc:
-
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self)
+    module FFIMultiPointMethods  # :nodoc:
 
 
       def geometry_type
@@ -663,11 +670,7 @@ module RGeo
     end
 
 
-    class FFIMultiLineStringImpl < FFIGeometryCollectionImpl  # :nodoc:
-
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiCurve).include_in_class(self)
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self)
+    module FFIMultiLineStringMethods  # :nodoc:
 
 
       def geometry_type
@@ -692,11 +695,7 @@ module RGeo
     end
 
 
-    class FFIMultiPolygonImpl < FFIGeometryCollectionImpl  # :nodoc:
-
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiSurface).include_in_class(self)
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self)
+    module FFIMultiPolygonMethods  # :nodoc:
 
 
       def geometry_type
@@ -710,12 +709,12 @@ module RGeo
 
 
       def centroid
-        @factory.wrap_fg_geom(@fg_geom.centroid, FFIPointImpl)
+        @factory._wrap_fg_geom(@fg_geom.centroid, FFIPointImpl)
       end
 
 
       def point_on_surface
-        @factory.wrap_fg_geom(@fg_geom.point_on_surface, FFIPointImpl)
+        @factory._wrap_fg_geom(@fg_geom.point_on_surface, FFIPointImpl)
       end
 
 

data/lib/rgeo/geos/interface.rb

@@ -67,9 +67,9 @@ module RGeo
       # the given factory is a CAPI GEOS factory.
 
       def is_capi_geos?(object_)
-        Factory === object_ || GeometryImpl === object_ ||
-          ZMFactory === object_ && Factory === object_.z_factory ||
-          ZMGeometryImpl === object_ && GeometryImpl === object_.z_geometry
+        CAPIFactory === object_ || CAPIGeometryImpl === object_ ||
+          ZMFactory === object_ && CAPIFactory === object_.z_factory ||
+          ZMGeometryImpl === object_ && CAPIGeometryImpl === object_.z_geometry
       end
 
 
@@ -87,7 +87,7 @@ module RGeo
       # factory is a GEOS factory. Does not distinguish between CAPI and FFI.
 
       def is_geos?(object_)
-        Factory === object_ || GeometryImpl === object_ ||
+        CAPIFactory === object_ || CAPIGeometryImpl === object_ ||
           FFIFactory === object_ || FFIGeometryImpl === object_ ||
           ZMFactory === object_ || ZMGeometryImpl === object_
       end
@@ -204,7 +204,7 @@ module RGeo
           elsif native_interface_ == :ffi
             FFIFactory.new(opts_)
           else
-            Factory.create(opts_)
+            CAPIFactory.create(opts_)
           end
         else
           nil

data/lib/rgeo/geos/utils.rb

@@ -85,6 +85,13 @@ module RGeo
         end
 
 
+        def ffi_coord_seq_hash(cs_, hash_=0)
+          (0...cs_.length).inject(hash_) do |h_, i_|
+            [hash_, cs_.get_x(i_), cs_.get_y(i_), cs_.get_z(i_)].hash
+          end
+        end
+
+
         def _init
           if FFI_SUPPORTED
             @ffi_supports_prepared_level_1 = ::Geos::FFIGeos.respond_to?(:GEOSPreparedContains_r)

data/lib/rgeo/geos/zm_factory.rb

@@ -46,6 +46,23 @@ module RGeo
       include Feature::Factory::Instance
 
 
+      # :stopdoc:
+
+      TYPE_KLASSES = {
+        Feature::Point => ZMPointImpl,
+        Feature::LineString => ZMLineStringImpl,
+        Feature::Line => ZMLineImpl,
+        Feature::LinearRing => ZMLinearRingImpl,
+        Feature::Polygon => ZMPolygonImpl,
+        Feature::GeometryCollection => ZMGeometryCollectionImpl,
+        Feature::MultiPoint => ZMMultiPointImpl,
+        Feature::MultiLineString => ZMMultiLineStringImpl,
+        Feature::MultiPolygon => ZMMultiPolygonImpl,
+      }.freeze
+
+      # :startdoc:
+
+
       class << self
 
 
@@ -86,8 +103,8 @@ module RGeo
           @zfactory = FFIFactory.new(config_.merge(:has_z_coordinate => true))
           @mfactory = FFIFactory.new(config_.merge(:has_m_coordinate => true))
         else
-          @zfactory = Factory.create(config_.merge(:has_z_coordinate => true))
-          @mfactory = Factory.create(config_.merge(:has_m_coordinate => true))
+          @zfactory = CAPIFactory.create(config_.merge(:has_z_coordinate => true))
+          @mfactory = CAPIFactory.create(config_.merge(:has_m_coordinate => true))
         end
 
         wkt_generator_ = opts_[:wkt_generator]
@@ -270,6 +287,11 @@ module RGeo
       alias_method :==, :eql?
 
 
+      def hash
+        @hash ||= [@zfactory, @mfactory].hash
+      end
+
+
       # See ::RGeo::Feature::Factory#property
 
       def property(name_)
@@ -299,63 +321,63 @@ module RGeo
       # See ::RGeo::Feature::Factory#point
 
       def point(x_, y_, z_=0, m_=0)
-        ZMPointImpl.create(self, @zfactory.point(x_, y_, z_), @mfactory.point(x_, y_, m_))
+        _create_feature(ZMPointImpl, @zfactory.point(x_, y_, z_), @mfactory.point(x_, y_, m_))
       end
 
 
       # See ::RGeo::Feature::Factory#line_string
 
       def line_string(points_)
-        ZMLineStringImpl.create(self, @zfactory.line_string(points_), @mfactory.line_string(points_))
+        _create_feature(ZMLineStringImpl, @zfactory.line_string(points_), @mfactory.line_string(points_))
       end
 
 
       # See ::RGeo::Feature::Factory#line
 
       def line(start_, end_)
-        ZMLineStringImpl.create(self, @zfactory.line(start_, end_), @mfactory.line(start_, end_))
+        _create_feature(ZMLineImpl, @zfactory.line(start_, end_), @mfactory.line(start_, end_))
       end
 
 
       # See ::RGeo::Feature::Factory#linear_ring
 
       def linear_ring(points_)
-        ZMLineStringImpl.create(self, @zfactory.linear_ring(points_), @mfactory.linear_ring(points_))
+        _create_feature(ZMLinearRingImpl, @zfactory.linear_ring(points_), @mfactory.linear_ring(points_))
       end
 
 
       # See ::RGeo::Feature::Factory#polygon
 
       def polygon(outer_ring_, inner_rings_=nil)
-        ZMPolygonImpl.create(self, @zfactory.polygon(outer_ring_, inner_rings_), @mfactory.polygon(outer_ring_, inner_rings_))
+        _create_feature(ZMPolygonImpl, @zfactory.polygon(outer_ring_, inner_rings_), @mfactory.polygon(outer_ring_, inner_rings_))
       end
 
 
       # See ::RGeo::Feature::Factory#collection
 
       def collection(elems_)
-        ZMGeometryCollectionImpl.create(self, @zfactory.collection(elems_), @mfactory.collection(elems_))
+        _create_feature(ZMGeometryCollectionImpl, @zfactory.collection(elems_), @mfactory.collection(elems_))
       end
 
 
       # See ::RGeo::Feature::Factory#multi_point
 
       def multi_point(elems_)
-        ZMGeometryCollectionImpl.create(self, @zfactory.multi_point(elems_), @mfactory.multi_point(elems_))
+        _create_feature(ZMMultiPointImpl, @zfactory.multi_point(elems_), @mfactory.multi_point(elems_))
       end
 
 
       # See ::RGeo::Feature::Factory#multi_line_string
 
       def multi_line_string(elems_)
-        ZMMultiLineStringImpl.create(self, @zfactory.multi_line_string(elems_), @mfactory.multi_line_string(elems_))
+        _create_feature(ZMMultiLineStringImpl, @zfactory.multi_line_string(elems_), @mfactory.multi_line_string(elems_))
       end
 
 
       # See ::RGeo::Feature::Factory#multi_polygon
 
       def multi_polygon(elems_)
-        ZMMultiPolygonImpl.create(self, @zfactory.multi_polygon(elems_), @mfactory.multi_polygon(elems_))
+        _create_feature(ZMMultiPolygonImpl, @zfactory.multi_polygon(elems_), @mfactory.multi_polygon(elems_))
       end
 
 
@@ -383,7 +405,7 @@ module RGeo
         type_ = original_.geometry_type
         ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
         case original_
-        when ZMGeometryImpl
+        when ZMGeometryMethods
           # Optimization if we're just changing factories, but to
           # another ZM factory.
           if original_.factory != self && ntype_ == type_ &&
@@ -410,6 +432,12 @@ module RGeo
       end
 
 
+      def _create_feature(klass_, zgeometry_, mgeometry_)  # :nodoc:
+        klass_ ||= TYPE_KLASSES[zgeometry_.geometry_type] || ZMGeometryImpl
+        zgeometry_ && mgeometry_ ? klass_.new(self, zgeometry_, mgeometry_) : nil
+      end
+
+
       def _marshal_wkb_generator  # :nodoc:
         unless defined?(@marshal_wkb_generator)
           @marshal_wkb_generator = ::RGeo::WKRep::WKBGenerator.new(