ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/ogr/layer.rb

@@ -1,226 +1,105 @@
 require_relative '../ffi/ogr'
-require_relative 'layer_extensions'
+require_relative '../gdal/major_object'
 require_relative 'envelope'
-require_relative 'geometry'
-require_relative 'feature'
-require_relative 'feature_definition'
-require_relative 'spatial_reference'
-require_relative 'style_table'
+require_relative 'layer_mixins/extensions'
+require_relative 'layer_mixins/capability_methods'
+require_relative 'layer_mixins/ogr_feature_methods'
+require_relative 'layer_mixins/ogr_field_methods'
+require_relative 'layer_mixins/ogr_layer_method_methods'
+require_relative 'layer_mixins/ogr_query_filter_methods'
+require_relative 'layer_mixins/ogr_sql_methods'
 
 module OGR
   class Layer
     include GDAL::MajorObject
-    include LayerExtensions
-
-    def initialize(layer)
-      @ogr_layer_pointer = GDAL._pointer(OGR::Layer, layer)
+    include LayerMixins::Extensions
+    include LayerMixins::CapabilityMethods
+    include LayerMixins::OGRFeatureMethods
+    include LayerMixins::OGRFieldMethods
+    include LayerMixins::OGRLayerMethodMethods
+    include LayerMixins::OGRQueryFilterMethods
+    include LayerMixins::OGRSQLMethods
+
+    class_eval FFI::OGR::Core::OGR_ALTER.to_ruby
+
+    # @return [FFI::Pointer] C pointer to the C Layer.
+    attr_reader :c_pointer
+
+    # @param layer_ptr [FFI::Pointer]
+    def initialize(layer_ptr)
+      @c_pointer = layer_ptr
       @features = []
     end
 
-    def c_pointer
-      @ogr_layer_pointer
-    end
-
     # @return [String]
     def name
-      FFI::GDAL.OGR_L_GetName(@ogr_layer_pointer)
-    end
-
-    # @return [Symbol] One of OGRwkbGeometryType.
-    def geometry_type
-      FFI::GDAL.OGR_L_GetGeomType(@ogr_layer_pointer)
-    end
-
-    # TODO: per the gdal docs: "The returned pointer is to an internally owned
-    # object, and should not be altered or deleted by the caller."
-    #
-    # @return [OGR::Geometry]
-    def spatial_filter
-      return @spatial_filter if @spatial_filter
-
-      filter_pointer = FFI::GDAL.OGR_L_GetSpatialFilter(@ogr_layer_pointer)
-      return nil if filter_pointer.null?
-
-      @spatial_filter = OGR::Geometry.new(filter_pointer)
-    end
-
-    # The number of features in this layer.  If +force+ is false and it would be
-    # expensive to determine the feature count, -1 may be returned.
-    #
-    # @param force [Boolean] Force the calculation even if it's
-    #   expensive.
-    # @return [Fixnum]
-    def feature_count(force=true)
-      FFI::GDAL.OGR_L_GetFeatureCount(@ogr_layer_pointer, force)
-    end
-
-    # @param index [Fixnum] The 0-based index of the feature to get.  It should
-    #   be <= +feature_count+, but not checking is done to ensure.
-    # @return [OGR::Feature, nil]
-    def feature(index)
-      @features.fetch(index) do
-        feature_pointer = FFI::GDAL.OGR_L_GetFeature(@ogr_layer_pointer, index)
-        return nil if feature_pointer.null?
-
-        feature = OGR::Feature.new(feature_pointer)
-        @features.insert(index, feature)
-
-        feature
-      end
-    end
-
-    # The next available feature in this layer.  Only features matching the
-    # current spatial filter will be returned.  Use +reset_reading+ to start at
-    # the beginning again.
-    #
-    # @return [OGR::Feature, nil]
-    def next_feature
-      feature_pointer = FFI::GDAL.OGR_L_GetNextFeature(@ogr_layer_pointer)
-      return nil if feature_pointer.null?
-
-      OGR::Feature.new(feature_pointer)
-    end
-
-    # @return [Fixnum]
-    def features_read
-      FFI::GDAL.OGR_L_GetFeaturesRead(@ogr_layer_pointer)
-    end
-
-    # Uses the already-defined FeatureDefinition to create then write a new feature
-    # to the layer.
-    #
-    # @return [OGR::Feature]
-    def create_feature
-      feature_def = feature_definition
-      feature = OGR::Feature.create(feature_def)
-      ogr_err = FFI::GDAL.OGR_L_CreateFeature(@ogr_layer_pointer, feature.c_pointer)
-      ogr_err.to_ruby
-
-      feature
-    end
-
-    # Deletes the feature from the layer.
-    #
-    # TODO: Use OGR_L_TestCapability before trying to delete.
-    # @return +true+ if successful, otherwise raises an OGR exception.
-    def delete_feature(feature_id)
-      ogr_err = FFI::GDAL.OGR_L_DeleteFeature(@ogr_layer_pointer, feature_id)
-
-      ogr_err.to_ruby
-    end
-
-    # Creates and writes a new field to the layer.
-    #
-    # @param name [String]
-    # @param type [FFI::GDAL::OGRFieldType]
-    # @param approx_ok [Boolean] If +true+ the field may be created in a slightly
-    #   different form, depending on the limitations of the format driver.
-    # @return [OGR::Field]
-    def create_field(name, type, approx_ok=false)
-      field = OGR::Field.create(name, type)
-      ogr_err = FFI::GDAL.OGR_L_CreateField(@ogr_layer_pointer, field.c_pointer, approx_ok)
-      ogr_err.to_ruby
-
-      field
+      FFI::OGR::API.OGR_L_GetName(@c_pointer)
     end
 
-    # @param field [OGR::Field, FFI::Pointer]
-    # @param approx_ok [Boolean] If +true+ the field may be created in a slightly
-    #   different form, depending on the limitations of the format driver.
-    # @return +true+ if successful, otherwise raises an OGR exception.
-    def add_field(field, approx_ok=false)
-      field_ptr = GDAL._pointer(OGR::Field, field)
-      ogr_err = FFI::GDAL.OGR_L_CreateField(@ogr_layer_pointer, field_ptr, approx_ok)
+    # @return [Boolean]
+    # TODO: This seems to occasionally lead to: 28352 illegal hardware
+    #   instruction, and sometimes full crashes.
+    def sync_to_disk
+      ogr_err = FFI::OGR::API.OGR_L_SyncToDisk(@c_pointer)
 
-      ogr_err.to_ruby
+      ogr_err.handle_result
     end
 
-    # Deletes the field definition from the layer.
+    # Tests if this layer supports the given capability.  Must be in the list
+    # of available capabilities.  See http://www.gdal.org/ogr__api_8h.html#a480adc8b839b04597f49583371d366fd.
     #
-    # TODO: Use OGR_L_TestCapability before trying to delete.
-    # @return +true+ if successful, otherwise raises an OGR exception.
-    def delete_field(field_id)
-      ogr_err = FFI::GDAL.OGR_L_DeleteField(@ogr_layer_pointer, field_id)
-
-      ogr_err.to_ruby
-    end
-
-    # # Creates and writes a new geometry to the layer.
-    # #
-    # # @return [OGR::GeometryField]
-    # def create_geometry_field(approx_ok=false)
-    #   geometry_field_definition_ptr = FFI::MemoryPointer.new(:OGRGeomFieldDefnH)
-    #   ogr_err = OGR_L_CreateGeomField(@ogr_layer_pointer, geometry_field_definition_ptr)
-    #
-    #   OGR::GeometryFieldDefinition.new(geometry_field_definition_ptr)
-    # end
-
-    # Resets the sequential reading of features for this layer.
-    def reset_reading
-      FFI::GDAL.OGR_L_ResetReading(@ogr_layer_pointer)
-    end
-
-    # The schema information for this layer.
-    #
-    # @return [OGR::FeatureDefinition,nil]
-    def feature_definition
-      return @feature_definition if @feature_definition
-
-      feature_defn_pointer = FFI::GDAL.OGR_L_GetLayerDefn(@ogr_layer_pointer)
-      return nil if feature_defn_pointer.null?
-
-      @feature_definition = OGR::FeatureDefinition.new(feature_defn_pointer)
+    # @param capability [String]
+    # @return [Boolean]
+    # @see http://www.gdal.org/ogr__api_8h.html#a480adc8b839b04597f49583371d366fd
+    def test_capability(capability)
+      FFI::OGR::API.OGR_L_TestCapability(@c_pointer, capability.to_s)
     end
 
     # @return [OGR::SpatialReference]
     def spatial_reference
-      return @spatial_reference if @spatial_reference
-
-      spatial_ref_pointer = FFI::GDAL.OGR_L_GetSpatialRef(@ogr_layer_pointer)
+      spatial_ref_pointer = FFI::OGR::API.OGR_L_GetSpatialRef(@c_pointer)
       return nil if spatial_ref_pointer.null?
 
-      @spatial_reference = OGR::SpatialReference.new(spatial_ref_pointer)
+      OGR::SpatialReference.new(spatial_ref_pointer)
     end
 
     # @return [OGR::Envelope]
-    def extent(force=true)
-      return @envelope if @envelope
-
-      envelope = FFI::GDAL::OGREnvelope.new
-      FFI::GDAL.OGR_L_GetExtent(@ogr_layer_pointer, envelope, force)
+    def extent(force = true)
+      envelope = FFI::OGR::Envelope.new
+      FFI::OGR::API.OGR_L_GetExtent(@c_pointer, envelope, force)
       return nil if envelope.null?
 
-      @envelope = OGR::Envelope.new(envelope)
+      OGR::Envelope.new(envelope)
     end
 
     # @return [OGR::Envelope]
-    def extent_by_geometry(geometry_field_index, force=true)
-      envelope = FFI::GDAL::OGREnvelope.new
-      FFI::GDAL.OGR_L_GetExtentEx(@ogr_layer_pointer, geometry_field_index, envelope, force)
+    def extent_by_geometry(geometry_field_index, force = true)
+      envelope = FFI::OGR::Envelope.new
+      FFI::OGR::API.OGR_L_GetExtentEx(@c_pointer, geometry_field_index, envelope, force)
       return nil if envelope.null?
 
       OGR::Envelope.new(envelope)
     end
 
-    # The name of the underlying database column.  '' if not supported.
-    # @return [String]
-    def fid_column
-      FFI::GDAL.OGR_L_GetFIDColumn(@ogr_layer_pointer)
-    end
-
-    # @return [String]
-    def geometry_column
-      FFI::GDAL.OGR_L_GetGeometryColumn(@ogr_layer_pointer)
+    # @return [Symbol] One of OGRwkbGeometryType.
+    def geometry_type
+      FFI::OGR::API.OGR_L_GetGeomType(@c_pointer)
     end
 
     # @return [OGR::StyleTable, nil]
     def style_table
-      return @style_table if @style_table
-
-      style_table_pointer = FFI::GDAL.OGR_L_GetStyleTable(@ogr_layer_pointer)
+      style_table_pointer = FFI::OGR::API.OGR_L_GetStyleTable(@c_pointer)
       return nil if style_table_pointer.null?
 
-      @style_table = OGR::StyleTable.new(style_table_pointer)
+      OGR::StyleTable.new(style_table_pointer)
+    end
+
+    # @param new_style_table [OGR::StyleTable, FFI::pointer]
+    def style_table=(new_style_table)
+      style_table_ptr = GDAL._pointer(OGR::StyleTable, new_style_table)
+      fail OGR::Failure if style_table_ptr.nil? || style_table_ptr.null?
+
+      FFI::OGR::API.OGR_L_SetStyleTable(@c_pointer, style_table_ptr)
     end
   end
 end

data/lib/ogr/layer_mixins/capability_methods.rb

@@ -0,0 +1,102 @@
+module OGR
+  module LayerMixins
+    # Helper methods for checking what the Layer is capable of.
+    module CapabilityMethods
+      # @return [Boolean] +true+ if #feature() is implemented in an optimized
+      #   manner for this layer (as opposed to using #next_feature and
+      #   #reset_reading).
+      def can_random_read?
+        test_capability('RandomRead')
+      end
+
+      # @return [Boolean] +true+ if #create_feature is allowed on this layer.
+      def can_sequential_write?
+        test_capability('SequentialWrite')
+      end
+
+      # @return [Boolean] +true+ if #feature= is allowed on this layer.
+      def can_random_write?
+        test_capability('RandomWrite')
+      end
+
+      # @return [Boolean] +true+ if this layer implements spatial filtering
+      #   efficiently. This can be used as a clue by the application whether
+      #   it should build and maintain its own spatial index for features in
+      #   this layer.
+      def can_fast_spatial_filter?
+        test_capability('FastSpatialFilter')
+      end
+
+      # @return [Boolean] +true+ if this layer can return a feature count
+      #   efficiently (i.e. without counting all of the features).
+      def can_fast_feature_count?
+        test_capability('FastFeatureCount')
+      end
+
+      # @return [Boolean] +true+ if this Layer can return its extent
+      #   efficiently (i.e. without scanning all of the features.).
+      def can_fast_get_extent?
+        test_capability('FastGetExtent')
+      end
+
+      # @return [Boolean] +true+ if this layer can perform the
+      #   #next_feature_index= call efficiently.
+      def can_fast_set_next_by_index?
+        test_capability('FastSetNextByIndex')
+      end
+
+      # @return [Boolean] +true+ if new Fields can be created on this Layer.
+      def can_create_field?
+        test_capability('CreateField')
+      end
+
+      # @return [Boolean] +true+ if the Layer supports creating new geometry
+      #   fields on the current layer.
+      def can_create_geometry_field?
+        test_capability('CreateGeomField')
+      end
+
+      # @return [Boolean] +true+ if the Layer supports deleting existing fields
+      #   on the current layer.
+      def can_delete_field?
+        test_capability('DeleteField')
+      end
+
+      # @return [Boolean] +true+ if the Layer supports reording fields on the
+      #   current layer.
+      def can_reorder_fields?
+        test_capability('ReorderFields')
+      end
+
+      # @return [Boolean] +true+ if the Layer supports altering the defintition
+      #   of an existing field on the current layer.
+      def can_alter_field_definition?
+        test_capability('AlterFieldDefn')
+      end
+
+      # @return [Boolean] +true+ if the Layer supports deleting Features.
+      def can_delete_feature?
+        test_capability('DeleteFeature')
+      end
+
+      # @return [Boolean] +true+ if :OFTString fields are guaranteed to be in
+      #   UTF-8.
+      def strings_are_utf_8?
+        test_capability('StringsAsUTF8')
+      end
+
+      # @return [Boolean] +true+ if this Layer supports transactions. If not,
+      #   #start_transaction, #commit_transaction, and #rollback_transaction
+      #   will not work in a meaningful manner.
+      def supports_transactions?
+        test_capability('Transactions')
+      end
+
+      # @return [Boolean] +true+ if this Layer supports reading or writing
+      #   curve geometries.
+      def supports_curve_geometries?
+        test_capability('CurveGeometries')
+      end
+    end
+  end
+end

data/lib/ogr/layer_mixins/extensions.rb

@@ -0,0 +1,59 @@
+require 'json'
+
+module OGR
+  module LayerMixins
+    # Methods not part of the C Layer API.
+    module Extensions
+      # @return [Array<OGR::Feature>]
+      def features
+        return [] if feature_count.zero?
+
+        feature_list = feature_count.times.map do |i|
+          feature(i)
+        end
+
+        @features = feature_list
+      end
+
+      # @return [OGR::Geometry] A convex hull geometry derived from a LineString
+      #   that connects the 4 bounding box points (from the extent).
+      def geometry_from_extent
+        sr = spatial_reference
+        geometry = OGR::Geometry.create(:wkbLineString)
+        geometry.spatial_reference = sr
+
+        geometry.add_point(extent.x_min, extent.y_min)
+        geometry.add_point(extent.x_min, extent.y_max)
+        geometry.add_point(extent.x_max, extent.y_max)
+        geometry.add_point(extent.x_max, extent.y_min)
+        geometry.add_point(extent.x_min, extent.y_min)
+
+        geometry.convex_hull
+      end
+
+      # @return [Hash]
+      def as_json(options = nil)
+        {
+          layer: {
+            extent: extent.as_json(options),
+            feature_count: feature_count,
+            feature_definition: feature_definition.as_json(options),
+            features: features.map(&:as_json),
+            fid_column: fid_column,
+            geometry_column: geometry_column,
+            geometry_type: geometry_type,
+            name: name,
+            spatial_reference: spatial_reference ? spatial_reference.as_json(options) : nil,
+            style_table: style_table ? style_table.as_json(options) : nil
+          },
+          metadata: nil # all_metadata
+        }
+      end
+
+      # @return [String]
+      def to_json(options = nil)
+        as_json(options).to_json
+      end
+    end
+  end
+end

data/lib/ogr/layer_mixins/ogr_feature_methods.rb

@@ -0,0 +1,127 @@
+require_relative '../feature'
+require_relative '../feature_definition'
+
+module OGR
+  module LayerMixins
+    module OGRFeatureMethods
+      # The schema information for this layer.
+      #
+      # @return [OGR::FeatureDefinition,nil]
+      def definition
+        feature_defn_pointer = FFI::OGR::API.OGR_L_GetLayerDefn(@c_pointer)
+        return nil if feature_defn_pointer.null?
+
+        # This object should not be modified.
+        OGR::FeatureDefinition.new(feature_defn_pointer)
+      end
+      alias_method :feature_definition, :definition
+
+      # Adds the new OGR::Feature to the Layer. The feature should have been
+      # created using the Layer's FeatureDefintion.
+      #
+      #   feature = OGR::Feature.new(layer.feature_definition)
+      #   feature.set_field_integer(123)
+      #   layer.create_feature(feature)
+      #
+      # @param feature [OGR::Feature] [description]
+      # @return [Boolean]
+      def create_feature(feature)
+        unless can_sequential_write?
+          fail OGR::UnsupportedOperation, 'This layer does not support feature creation.'
+        end
+
+        ogr_err = FFI::OGR::API.OGR_L_CreateFeature(@c_pointer, feature.c_pointer)
+
+        ogr_err.handle_result
+      end
+
+      # Deletes the feature from the layer.
+      #
+      # @param feature_id [Fixnum] ID of the Feature to delete.
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      # @raise [OGR::Failure] When trying to delete a feature with an ID that
+      #   does not exist.
+      def delete_feature(feature_id)
+        unless can_delete_feature?
+          fail OGR::UnsupportedOperation, 'This layer does not support feature deletion.'
+        end
+
+        ogr_err = FFI::OGR::API.OGR_L_DeleteFeature(@c_pointer, feature_id)
+
+        ogr_err.handle_result "Unable to delete feature with ID '#{feature_id}'"
+      end
+
+      # The number of features in this layer.  If +force+ is false and it would be
+      # expensive to determine the feature count, -1 may be returned.
+      #
+      # @param force [Boolean] Force the calculation even if it's expensive.
+      # @return [Fixnum]
+      def feature_count(force = true)
+        FFI::OGR::API.OGR_L_GetFeatureCount(@c_pointer, force)
+      end
+
+      # Rewrites an existing feature using the ID within the given Feature.
+      #
+      # @param new_feature [OGR::Feature, FFI::Pointer]
+      def feature=(new_feature)
+        unless can_random_write?
+          fail OGR::UnsupportedOperation, '#feature= not supported by this Layer'
+        end
+
+        new_feature_ptr = GDAL._pointer(OGR::Feature, new_feature)
+        fail OGR::InvalidFeature if new_feature_ptr.nil? || new_feature_ptr.null?
+
+        ogr_err = FFI::OGR::API.OGR_L_SetFeature(@c_pointer, new_feature_ptr)
+
+        ogr_err.handle_result
+      end
+
+      # @param index [Fixnum] The 0-based index of the feature to get.  It should
+      #   be <= +feature_count+, but no checking is done to ensure.
+      # @return [OGR::Feature, nil]
+      def feature(index)
+        unless can_random_read?
+          fail OGR::UnsupportedOperation, '#feature(index) not supported by this Layer'
+        end
+
+        feature_pointer = FFI::OGR::API.OGR_L_GetFeature(@c_pointer, index)
+        return nil if feature_pointer.null?
+
+        OGR::Feature.new(feature_pointer)
+      end
+
+      # The next available feature in this layer.  Only features matching the
+      # current spatial filter will be returned.  Use +reset_reading+ to start at
+      # the beginning again.
+      #
+      # @return [OGR::Feature, nil]
+      def next_feature
+        feature_pointer = FFI::OGR::API.OGR_L_GetNextFeature(@c_pointer)
+        return nil if feature_pointer.null?
+
+        OGR::Feature.new(feature_pointer)
+      end
+
+      # Sets the index for #next_feature.
+      #
+      # @param feature_index [Fixnum]
+      # @return [Boolean]
+      def next_feature_index=(feature_index)
+        ogr_err = FFI::OGR::API.OGR_L_SetNextByIndex(@c_pointer, feature_index)
+
+        ogr_err.handle_result "Unable to set next feature index to #{feature_index}"
+      end
+      alias_method :set_next_by_index, :next_feature_index=
+
+      # @return [Fixnum]
+      def features_read
+        FFI::OGR::API.OGR_L_GetFeaturesRead(@c_pointer)
+      end
+
+      # Resets the sequential reading of features for this layer.
+      def reset_reading
+        FFI::OGR::API.OGR_L_ResetReading(@c_pointer)
+      end
+    end
+  end
+end