rgeo 0.3.13 → 0.3.14

data/lib/rgeo/geos/{impl_additions.rb → capi_feature_classes.rb}

@@ -38,10 +38,12 @@ module RGeo
   module Geos
 
 
-    class GeometryImpl  # :nodoc:
+    module CAPIGeometryMethods  # :nodoc:
+
 
       include Feature::Instance
 
+
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
@@ -87,23 +89,132 @@ module RGeo
     end
 
 
-    class Factory
+    module CAPIGeometryCollectionMethods  # :nodoc:
 
+      include ::Enumerable
 
-      # :stopdoc:
-      if defined?(::RGeo::Geos::PointImpl)
-        IMPL_CLASSES = {
-          Feature::Point => PointImpl,
-          Feature::LineString => LineStringImpl,
-          Feature::LinearRing => LinearRingImpl,
-          Feature::Line => LineImpl,
-          Feature::GeometryCollection => GeometryCollectionImpl,
-          Feature::MultiPoint => MultiPointImpl,
-          Feature::MultiLineString => MultiLineStringImpl,
-          Feature::MultiPolygon => MultiPolygonImpl,
-        }.freeze
-      end
-      # :startdoc:
+    end
+
+
+    class CAPIGeometryImpl
+
+
+      include CAPIGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPIPointImpl
+
+
+      include CAPIGeometryMethods
+      include CAPIPointMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPILineStringImpl
+
+
+      include CAPIGeometryMethods
+      include CAPILineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPILinearRingImpl
+
+
+      include CAPIGeometryMethods
+      include CAPILineStringMethods
+      include CAPILinearRingMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPILineImpl
+
+
+      include CAPIGeometryMethods
+      include CAPILineStringMethods
+      include CAPILineMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPIPolygonImpl
+
+
+      include CAPIGeometryMethods
+      include CAPIPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPIGeometryCollectionImpl
+
+
+      include CAPIGeometryMethods
+      include CAPIGeometryCollectionMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPIMultiPointImpl
+
+
+      include CAPIGeometryMethods
+      include CAPIGeometryCollectionMethods
+      include CAPIMultiPointMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPIMultiLineStringImpl
+
+
+      include CAPIGeometryMethods
+      include CAPIGeometryCollectionMethods
+      include CAPIMultiLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
+
+
+    end
+
+
+    class CAPIMultiPolygonImpl
+
+
+      include CAPIGeometryMethods
+      include CAPIGeometryCollectionMethods
+      include CAPIMultiPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
 
 
     end

data/lib/rgeo/geos/ffi_factory.rb

@@ -154,11 +154,18 @@ module RGeo
       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)
+          @has_m == rhs_.property(:has_m_coordinate) &&
+          @buffer_resolution == rhs_.property(:buffer_resolution) &&
+          @proj4.eql?(rhs_.proj4)
       end
       alias_method :==, :eql?
 
 
+      def hash
+        @hash ||= [@srid, @has_z, @has_m, @buffer_resolution, @proj4].hash
+      end
+
+
       # Marshal support
 
       def marshal_dump  # :nodoc:
@@ -304,11 +311,18 @@ module RGeo
       end
 
 
+      # Create a feature that wraps the given ffi-geos geometry object
+
+      def wrap_fg_geom(fg_geom_)
+        _wrap_fg_geom(fg_geom_, nil)
+      end
+
+
       # See ::RGeo::Feature::Factory#parse_wkt
 
       def parse_wkt(str_)
         if @wkt_reader
-          wrap_fg_geom(@wkt_reader.read(str_))
+          _wrap_fg_geom(@wkt_reader.read(str_), nil)
         else
           @wkt_parser.parse(str_)
         end
@@ -319,50 +333,13 @@ module RGeo
 
       def parse_wkb(str_)
         if @wkb_reader
-          wrap_fg_geom(@wkb_reader.read(str_))
+          _wrap_fg_geom(@wkb_reader.read(str_), nil)
         else
           @wkb_parser.parse(str_)
         end
       end
 
 
-      def wrap_fg_geom(fg_geom_, klass_=nil)  # :nodoc:
-        klasses_ = nil
-        unless klass_.kind_of?(::Class)
-          is_collection_ = false
-          case fg_geom_.type_id
-          when ::Geos::GeomTypes::GEOS_POINT
-            inferred_klass_ = FFIPointImpl
-          when ::Geos::GeomTypes::GEOS_MULTIPOINT
-            inferred_klass_ = FFIMultiPointImpl
-            is_collection_ = true
-          when ::Geos::GeomTypes::GEOS_LINESTRING
-            inferred_klass_ = FFILineStringImpl
-          when ::Geos::GeomTypes::GEOS_LINEARRING
-            inferred_klass_ = FFILinearRingImpl
-          when ::Geos::GeomTypes::GEOS_MULTILINESTRING
-            inferred_klass_ = FFIMultiLineStringImpl
-            is_collection_ = true
-          when ::Geos::GeomTypes::GEOS_POLYGON
-            inferred_klass_ = FFIPolygonImpl
-          when ::Geos::GeomTypes::GEOS_MULTIPOLYGON
-            inferred_klass_ = FFIMultiPolygonImpl
-            is_collection_ = true
-          when ::Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION
-            inferred_klass_ = FFIGeometryCollectionImpl
-            is_collection_ = true
-          else
-            inferred_klass_ = FFIGeometryImpl
-          end
-          if is_collection_ && klass_.is_a?(::Array)
-            klasses_ = klass_
-          end
-          klass_ = inferred_klass_
-        end
-        klass_.new(self, fg_geom_, klasses_)
-      end
-
-
       # See ::RGeo::Feature::Factory#point
 
       def point(x_, y_, z_=0)
@@ -448,7 +425,7 @@ module RGeo
         klasses_ = []
         fg_geoms_ = []
         elems_.each do |elem_|
-          k_ = elem_._klasses if elem_.is_a?(FFIGeometryImpl)
+          k_ = elem_._klasses if elem_.factory.is_a?(FFIFactory)
           elem_ = ::RGeo::Feature.cast(elem_, self, :force_new, :keep_subtype)
           if elem_
             klasses_ << (k_ || elem_.class)
@@ -549,6 +526,43 @@ module RGeo
       attr_reader :_auto_prepare  # :nodoc:
 
 
+      def _wrap_fg_geom(fg_geom_, klass_)  # :nodoc:
+        klasses_ = nil
+        unless klass_.kind_of?(::Class)
+          is_collection_ = false
+          case fg_geom_.type_id
+          when ::Geos::GeomTypes::GEOS_POINT
+            inferred_klass_ = FFIPointImpl
+          when ::Geos::GeomTypes::GEOS_MULTIPOINT
+            inferred_klass_ = FFIMultiPointImpl
+            is_collection_ = true
+          when ::Geos::GeomTypes::GEOS_LINESTRING
+            inferred_klass_ = FFILineStringImpl
+          when ::Geos::GeomTypes::GEOS_LINEARRING
+            inferred_klass_ = FFILinearRingImpl
+          when ::Geos::GeomTypes::GEOS_MULTILINESTRING
+            inferred_klass_ = FFIMultiLineStringImpl
+            is_collection_ = true
+          when ::Geos::GeomTypes::GEOS_POLYGON
+            inferred_klass_ = FFIPolygonImpl
+          when ::Geos::GeomTypes::GEOS_MULTIPOLYGON
+            inferred_klass_ = FFIMultiPolygonImpl
+            is_collection_ = true
+          when ::Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION
+            inferred_klass_ = FFIGeometryCollectionImpl
+            is_collection_ = true
+          else
+            inferred_klass_ = FFIGeometryImpl
+          end
+          if is_collection_ && klass_.is_a?(::Array)
+            klasses_ = klass_
+          end
+          klass_ = inferred_klass_
+        end
+        klass_.new(self, fg_geom_, klasses_)
+      end
+
+
       def _convert_to_fg_geometry(obj_, type_=nil)  # :nodoc:
         if type_.nil? && obj_.factory == self
           obj_

data/lib/rgeo/geos/ffi_feature_classes.rb

@@ -0,0 +1,168 @@
+# -----------------------------------------------------------------------------
+#
+# FFI-GEOS geometry implementation
+#
+# -----------------------------------------------------------------------------
+# 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 FFIGeometryImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self, true)
+
+
+    end
+
+
+    class FFIPointImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFIPointMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
+
+
+    end
+
+
+    class FFILineStringImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFILineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
+
+
+    end
+
+
+    class FFILinearRingImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFILineStringMethods
+      include FFILinearRingMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
+
+
+    end
+
+
+    class FFILineImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFILineStringMethods
+      include FFILineMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
+
+
+    end
+
+
+    class FFIPolygonImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFIPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
+
+
+    end
+
+
+    class FFIGeometryCollectionImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFIGeometryCollectionMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
+
+
+    end
+
+
+    class FFIMultiPointImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFIGeometryCollectionMethods
+      include FFIMultiPointMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
+
+
+    end
+
+
+    class FFIMultiLineStringImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFIGeometryCollectionMethods
+      include FFIMultiLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
+
+
+    end
+
+
+    class FFIMultiPolygonImpl  # :nodoc:
+
+
+      include FFIGeometryMethods
+      include FFIGeometryCollectionMethods
+      include FFIMultiPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
+
+
+    end
+
+
+  end
+
+end