rgeo 0.3.13 → 0.3.14

data/lib/rgeo/geos/zm_feature_classes.rb

@@ -0,0 +1,165 @@
+# -----------------------------------------------------------------------------
+#
+# GEOS implementation additions written in Ruby
+#
+# -----------------------------------------------------------------------------
+# Copyright 2010-2012 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module RGeo
+
+  module Geos
+
+
+    class ZMPointImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMPointMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMLineStringImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMLinearRingImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMLineImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMPolygonImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMGeometryCollectionImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMGeometryCollectionMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMMultiPointImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMGeometryCollectionMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMMultiLineStringImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMGeometryCollectionMethods
+      include ZMMultiLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMMultiPolygonImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+      include ZMGeometryCollectionMethods
+      include ZMMultiPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
+
+
+    end
+
+
+    class ZMGeometryImpl  # :nodoc:
+
+
+      include ZMGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self, true)
+
+
+    end
+
+
+  end
+
+end

data/lib/rgeo/geos/{zm_impl.rb → zm_feature_methods.rb}

@@ -39,7 +39,7 @@ module RGeo
   module Geos
 
 
-    class ZMGeometryImpl  # :nodoc:
+    module ZMGeometryMethods  # :nodoc:
 
       include Feature::Instance
 
@@ -60,6 +60,11 @@ module RGeo
       end
 
 
+      def hash
+        @factory.hash ^ @zgeometry.hash ^ @mgeometry.hash
+      end
+
+
       def factory
         @factory
       end
@@ -91,7 +96,7 @@ module RGeo
 
 
       def envelope
-        ZMGeometryImpl.create(@factory, @zgeometry.envelope, @mgeometry.envelope)
+        @factory._create_feature(nil, @zgeometry.envelope, @mgeometry.envelope)
       end
 
 
@@ -116,7 +121,7 @@ module RGeo
 
 
       def boundary
-        ZMGeometryImpl.create(@factory, @zgeometry.boundary, @mgeometry.boundary)
+        @factory._create_feature(nil, @zgeometry.boundary, @mgeometry.boundary)
       end
 
 
@@ -172,36 +177,36 @@ module RGeo
 
 
       def buffer(distance_)
-        ZMGeometryImpl.create(@factory, @zgeometry.buffer(distance_), @mgeometry.buffer(distance_))
+        @factory._create_feature(nil, @zgeometry.buffer(distance_), @mgeometry.buffer(distance_))
       end
 
 
       def convex_hull
-        ZMGeometryImpl.create(@factory, @zgeometry.convex_hull, @mgeometry.convex_hull)
+        @factory._create_feature(nil, @zgeometry.convex_hull, @mgeometry.convex_hull)
       end
 
 
       def intersection(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
-        ZMGeometryImpl.create(@factory, @zgeometry.intersection(rhs_.z_geometry), @mgeometry.intersection(rhs_.m_geometry))
+        @factory._create_feature(nil, @zgeometry.intersection(rhs_.z_geometry), @mgeometry.intersection(rhs_.m_geometry))
       end
 
 
       def union(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
-        ZMGeometryImpl.create(@factory, @zgeometry.union(rhs_.z_geometry), @mgeometry.union(rhs_.m_geometry))
+        @factory._create_feature(nil, @zgeometry.union(rhs_.z_geometry), @mgeometry.union(rhs_.m_geometry))
       end
 
 
       def difference(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
-        ZMGeometryImpl.create(@factory, @zgeometry.difference(rhs_.z_geometry), @mgeometry.difference(rhs_.m_geometry))
+        @factory._create_feature(nil, @zgeometry.difference(rhs_.z_geometry), @mgeometry.difference(rhs_.m_geometry))
       end
 
 
       def sym_difference(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
-        ZMGeometryImpl.create(@factory, @zgeometry.sym_difference(rhs_.z_geometry), @mgeometry.sym_difference(rhs_.m_geometry))
+        @factory._create_feature(nil, @zgeometry.sym_difference(rhs_.z_geometry), @mgeometry.sym_difference(rhs_.m_geometry))
       end
 
 
@@ -247,7 +252,7 @@ module RGeo
     end
 
 
-    class ZMPointImpl < ZMGeometryImpl  # :nodoc:
+    module ZMPointMethods  # :nodoc:
 
 
       def x
@@ -273,7 +278,7 @@ module RGeo
     end
 
 
-    class ZMLineStringImpl < ZMGeometryImpl  # :nodoc:
+    module ZMLineStringMethods  # :nodoc:
 
 
       def length
@@ -307,7 +312,7 @@ module RGeo
 
 
       def point_n(n_)
-        ZMPointImpl.create(@factory, @zgeometry.point_n(n_), @mgeometry.point_n(n_))
+        @factory._create_feature(ZMPointImpl, @zgeometry.point_n(n_), @mgeometry.point_n(n_))
       end
 
 
@@ -316,7 +321,7 @@ module RGeo
         zpoints_ = @zgeometry.points
         mpoints_ = @mgeometry.points
         zpoints_.size.times do |i_|
-          result_ << ZMPointImpl.create(@factory, zpoints_[i_], mpoints_[i_])
+          result_ << @factory._create_feature(ZMPointImpl, zpoints_[i_], mpoints_[i_])
         end
         result_
       end
@@ -325,7 +330,7 @@ module RGeo
     end
 
 
-    class ZMPolygonImpl < ZMGeometryImpl  # :nodoc:
+    module ZMPolygonMethods  # :nodoc:
 
 
       def area
@@ -334,17 +339,17 @@ module RGeo
 
 
       def centroid
-        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
+        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
 
       def point_on_surface
-        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
+        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
 
       def exterior_ring
-        ZMLineStringImpl.create(@factory, @zgeometry.exterior_ring, @mgeometry.exterior_ring)
+        @factory._create_feature(ZMLineStringImpl, @zgeometry.exterior_ring, @mgeometry.exterior_ring)
       end
 
 
@@ -354,7 +359,7 @@ module RGeo
 
 
       def interior_ring_n(n_)
-        ZMLineStringImpl.create(@factory, @zgeometry.interior_ring_n(n_), @mgeometry.interior_ring_n(n_))
+        @factory._create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(n_), @mgeometry.interior_ring_n(n_))
       end
 
 
@@ -363,7 +368,7 @@ module RGeo
         zrings_ = @zgeometry.interior_rings
         mrings_ = @mgeometry.interior_rings
         zrings_.size.times do |i_|
-          result_ << ZMLineStringImpl.create(@factory, zrings_[i_], mrings_[i_])
+          result_ << @factory._create_feature(ZMLineStringImpl, zrings_[i_], mrings_[i_])
         end
         result_
       end
@@ -372,10 +377,7 @@ module RGeo
     end
 
 
-    class ZMGeometryCollectionImpl < ZMGeometryImpl  # :nodoc:
-
-
-      include ::Enumerable
+    module ZMGeometryCollectionMethods  # :nodoc:
 
 
       def num_geometries
@@ -385,7 +387,7 @@ module RGeo
 
 
       def geometry_n(n_)
-        ZMGeometryImpl.create(@factory, @zgeometry.geometry_n(n_), @mgeometry.geometry_n(n_))
+        @factory._create_feature(nil, @zgeometry.geometry_n(n_), @mgeometry.geometry_n(n_))
       end
       alias_method :[], :geometry_n
 
@@ -397,10 +399,13 @@ module RGeo
       end
 
 
+      include ::Enumerable
+
+
     end
 
 
-    class ZMMultiLineStringImpl < ZMGeometryCollectionImpl  # :nodoc:
+    module ZMMultiLineStringMethods  # :nodoc:
 
 
       def length
@@ -416,7 +421,7 @@ module RGeo
     end
 
 
-    class ZMMultiPolygonImpl < ZMGeometryCollectionImpl  # :nodoc:
+    module ZMMultiPolygonMethods  # :nodoc:
 
 
       def area
@@ -425,36 +430,12 @@ module RGeo
 
 
       def centroid
-        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
+        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
 
       def point_on_surface
-        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
-      end
-
-
-    end
-
-
-    class ZMGeometryImpl  # :nodoc:
-
-      TYPE_KLASSES = {
-        Feature::Point => ZMPointImpl,
-        Feature::LineString => ZMLineStringImpl,
-        Feature::Line => ZMLineStringImpl,
-        Feature::LinearRing => ZMLineStringImpl,
-        Feature::Polygon => ZMPolygonImpl,
-        Feature::GeometryCollection => ZMGeometryCollectionImpl,
-        Feature::MultiPoint => ZMGeometryCollectionImpl,
-        Feature::MultiLineString => ZMMultiLineStringImpl,
-        Feature::MultiPolygon => ZMMultiPolygonImpl,
-      }.freeze
-
-
-      def self.create(factory_, zgeometry_, mgeometry_)
-        klass_ = self == ZMGeometryImpl ? TYPE_KLASSES[zgeometry_.geometry_type] : self
-        klass_ && zgeometry_ && mgeometry_ ? klass_.new(factory_, zgeometry_, mgeometry_) : nil
+        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
 

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -106,6 +106,14 @@ module RGeo
       end
 
 
+      def hash
+        @hash ||= begin
+          hash_ = [factory, geometry_type].hash
+          @elements.inject(hash_){ |h_, g_| (1664525 * h_ + g_.hash).hash }
+        end
+      end
+
+
       def _copy_state_from(obj_)  # :nodoc:
         super
         @elements = obj_._elements

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -133,6 +133,14 @@ module RGeo
       end
 
 
+      def hash
+        @hash ||= begin
+          hash_ = [factory, geometry_type].hash
+          @points.inject(hash_){ |h_, p_| (1664525 * h_ + p_.hash).hash }
+        end
+      end
+
+
       def _copy_state_from(obj_)  # :nodoc:
         super
         @points = obj_.points

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -130,6 +130,11 @@ module RGeo
       end
 
 
+      def hash
+        @hash ||= [factory, geometry_type, @x, @y, @z, @m].hash
+      end
+
+
       def _copy_state_from(obj_)  # :nodoc:
         super
         @x = obj_.x