ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/ogr/feature_definition.rb

@@ -1,120 +1,163 @@
 require_relative '../ffi/ogr'
 require_relative 'feature_definition_extensions'
-require_relative 'field'
+require_relative 'field_definition'
+require_relative 'geometry_field_definition'
 
 module OGR
   class FeatureDefinition
     include FeatureDefinitionExtensions
 
-    # @param name [String]
-    def self.create(name)
-      feature_defn_pointer = FFI::GDAL.OGR_FD_Create(name)
-      return nil if feature_defn_pointer.null?
-
-      new(feature_defn_pointer)
-    end
-
-    # @param feature_definition [String]
-    def initialize(feature_definition)
-      @feature_definition_pointer = GDAL._pointer(OGR::FeatureDefinition,
-        feature_definition)
-
-      close_me = -> { FFI::GDAL.OGR_FD_Destroy(@feature_definition_pointer) }
+    # @return [FFI::Pointer] C pointer of the C FeatureDefn.
+    attr_reader :c_pointer
+
+    # @param name_or_pointer [String, FFI::Pointer] When given a String, it will
+    #   create a new FeatureDefinition with that name. When given an
+    #   FFI::Pointer, the new object will simply wrap the C FeatureDefinition
+    #   at that address.
+    def initialize(name_or_pointer)
+      @c_pointer = if name_or_pointer.is_a? String
+                     FFI::OGR::API.OGR_FD_Create(name_or_pointer)
+                   else
+                     name_or_pointer
+                   end
+
+      if !@c_pointer.is_a?(FFI::Pointer) || @c_pointer.null?
+        fail OGR::InvalidFeatureDefinition, "Unable to create #{self.class.name} from #{name_or_pointer}"
+      end
+
+      close_me = -> { FFI::OGR::API.OGR_FD_Destroy(@c_pointer) }
       ObjectSpace.define_finalizer self, close_me
     end
 
-    def c_pointer
-      @feature_definition_pointer
+    def release!
+      FFI::OGR::API.OGR_FD_Release(@c_pointer)
     end
 
     # @return [String]
     def name
-      FFI::GDAL.OGR_FD_GetName(@feature_definition_pointer)
+      FFI::OGR::API.OGR_FD_GetName(@c_pointer)
     end
 
     # @return [Fixnum]
     def field_count
-      FFI::GDAL.OGR_FD_GetFieldCount(@feature_definition_pointer)
+      FFI::OGR::API.OGR_FD_GetFieldCount(@c_pointer)
     end
 
     # @param index [Fixnum]
-    # @return [OGR::Field]
-    def field(index)
-      field_ptr = FFI::GDAL.OGR_FD_GetFieldDefn(@feature_definition_pointer, index)
-      return nil if field_ptr.null?
+    # @return [OGR::FieldDefinition]
+    def field_definition(index)
+      field_definition_ptr =
+        FFI::OGR::API.OGR_FD_GetFieldDefn(@c_pointer, index)
+      return nil if field_definition_ptr.null?
 
-      OGR::Field.new(field_ptr)
+      OGR::FieldDefinition.new(field_definition_ptr, nil)
+    end
+
+    # @param field_definition [OGR::FieldDefinition, FFI::Pointer]
+    def add_field_definition(field_definition)
+      field_definition_ptr = GDAL._pointer(OGR::FieldDefinition, field_definition)
+
+      if field_definition_ptr.nil?
+        fail OGR::InvalidFieldDefinition, "Unable to add OGR::FieldDefinition: '#{field_definition}'"
+      end
+
+      FFI::OGR::API.OGR_FD_AddFieldDefn(@c_pointer, field_definition_ptr)
+    end
+
+    # @param index [Fixnum] Index of the field definition to delete.
+    # @return [Boolean]
+    def delete_field_definition(index)
+      ogr_err = FFI::OGR::API.OGR_FD_DeleteFieldDefn(
+        @c_pointer,
+        index)
+
+      ogr_err.handle_result "Unable to delete field definition at index #{index}"
     end
 
     # @param name [String]
-    # @return [Fixnum] -1 if no match found
+    # @return [Fixnum] nil if no match found
     def field_index(name)
-      FFI::GDAL.OGR_FD_GetFieldIndex(@feature_definition_pointer, name)
+      result = FFI::OGR::API.OGR_FD_GetFieldIndex(@c_pointer, name)
+
+      result < 0 ? nil : result
     end
 
-    # @return [FFI::GDAL::OGRwkbGeometryType]
+    # @return [FFI::OGR::API::WKBGeometryType]
     def geometry_type
-      FFI::GDAL.OGR_FD_GetGeomType(@feature_definition_pointer)
+      FFI::OGR::API.OGR_FD_GetGeomType(@c_pointer)
     end
 
-    # @param new_type [FFI::GDAL::OGRwkbGeometryType]
+    # @param new_type [FFI::OGR::API::WKBGeometryType]
     def geometry_type=(new_type)
-      FFI::GDAL.OGR_FD_SetGeomType(@feature_definition_pointer, new_type)
+      FFI::OGR::API.OGR_FD_SetGeomType(@c_pointer, new_type)
     end
 
     # @return [Boolean]
     def geometry_ignored?
-      FFI::GDAL.OGR_FD_IsGeometryIgnored(@feature_definition_pointer)
+      FFI::OGR::API.OGR_FD_IsGeometryIgnored(@c_pointer)
     end
 
     # @param ignore [Boolean]
-    def ignore_geometry!(ignore)
-      FFI::GDAL.OGR_FD_SetGeometryIgnored(@feature_definition_pointer, ignore)
+    def ignore_geometry!(ignore = true)
+      FFI::OGR::API.OGR_FD_SetGeometryIgnored(@c_pointer, ignore)
     end
 
     # @return [Boolean]
     def style_ignored?
-      FFI::GDAL.OGR_FD_IsStyleIgnored(@feature_definition_pointer)
+      FFI::OGR::API.OGR_FD_IsStyleIgnored(@c_pointer)
     end
 
     # @param ignore [Boolean]
-    def ignore_style!(ignore)
-      FFI::GDAL.OGR_FD_SetStyleIgnored(@feature_definition_pointer, ignore)
+    def ignore_style!(ignore = true)
+      FFI::OGR::API.OGR_FD_SetStyleIgnored(@c_pointer, ignore)
     end
 
     # @return [Fixnum]
     def geometry_field_count
-      FFI::GDAL.OGR_FD_GetGeomFieldCount(@feature_definition_pointer)
+      FFI::OGR::API.OGR_FD_GetGeomFieldCount(@c_pointer)
     end
 
     # @param index [Fixnum]
-    # @return [OGR::Field]
+    # @return [OGR::GeometryFieldDefinition]
     def geometry_field_definition(index)
-      field_ptr = FFI::GDAL.OGR_FD_GetGeomFieldDefn(@feature_definition_pointer, index)
-      return nil if field_ptr.null?
+      geometry_field_definition_ptr =
+        FFI::OGR::API.OGR_FD_GetGeomFieldDefn(@c_pointer, index)
+      return nil if geometry_field_definition_ptr.null?
 
-      OGR::Field.new(field_ptr)
+      OGR::GeometryFieldDefinition.new(geometry_field_definition_ptr)
     end
 
     # @param name [String]
     # @return [Fixnum]
     def geometry_field_index(name)
-      FFI::GDAL.OGR_FD_GetGeomFieldIndex(@feature_definition_pointer, name)
+      result = FFI::OGR::API.OGR_FD_GetGeomFieldIndex(@c_pointer, name)
+
+      result < 0 ? nil : result
     end
 
-    # @param name [String]
-    # @return [OGR::Field]
-    def geometry_field_by_name(name)
-      geometry_field_definition(geometry_field_index(name))
+    # @param geometry_field_definition [OGR::GeometryFieldDefinition, FFI::Pointer]
+    def add_geometry_field_definition(geometry_field_definition)
+      geometry_field_definition_ptr = GDAL._pointer(OGR::GeometryFieldDefinition,
+        geometry_field_definition)
+      FFI::OGR::API.OGR_FD_AddGeomFieldDefn(@c_pointer,
+        geometry_field_definition_ptr)
+    end
+
+    # @param index [Fixnum]
+    # @return [Boolean]
+    def delete_geometry_field_definition(index)
+      ogr_err = FFI::OGR::API.OGR_FD_DeleteGeomFieldDefn(@c_pointer,
+        index)
+
+      ogr_err.handle_result "Unable to delete geometry field definition at index #{index}"
     end
 
-    # @param other_feature_defintion [OGR::Feature, FFI::Pointer]
+    # @param other_feature_definition [OGR::Feature, FFI::Pointer]
     # @return [Boolean]
-    def same?(other_feature_defintion)
-      fd_ptr = GDAL._pointer(OGR::FeatureDefinition, other_feature_defintion)
+    def same?(other_feature_definition)
+      fd_ptr = GDAL._pointer(OGR::FeatureDefinition, other_feature_definition)
 
-      FFI::GDAL.OGR_FD_IsSame(@feature_definition_pointer, fd_ptr)
+      FFI::OGR::API.OGR_FD_IsSame(@c_pointer, fd_ptr)
     end
-    alias_method :==, :same?
   end
 end

data/lib/ogr/feature_definition_extensions.rb

@@ -2,35 +2,58 @@ require 'json'
 
 module OGR
   module FeatureDefinitionExtensions
+    # @return [Array<OGR::FieldDefinition>]
+    def field_definitions
+      return [] if field_count.zero?
 
-    # @return [Array<OGR::Field>]
-    def fields
-      0.upto(field_count - 1).map do |i|
-        field(i)
+      field_count.times.map do |i|
+        field_definition(i)
+      end
+    end
+
+    # @return [Array<OGR::GeometryFieldDefinition>]
+    def geometry_field_definitions
+      return [] if geometry_field_count.zero?
+
+      geometry_field_count.times.map do |i|
+        geometry_field_definition(i)
       end
     end
 
     # @param name [String]
-    # @return [OGR::Field]
-    def field_by_name(name)
-      field(field_index(name))
+    # @return [OGR::FieldDefinition]
+    def field_definition_by_name(name)
+      i = field_index(name)
+      return unless i
+
+      field_definition(i)
+    end
+
+    # @param name [String]
+    # @return [OGR::GeometryFieldDefinition]
+    def geometry_field_definition_by_name(name)
+      g = geometry_field_index(name)
+      return unless g
+
+      geometry_field_definition(g)
     end
 
     # @return [Hash]
-    def as_json
+    def as_json(_options = nil)
       {
         field_count: field_count,
-        fields: fields.map(&:as_json),
+        field_definitions: field_definitions.map(&:as_json),
         geometry_field_count: geometry_field_count,
         geometry_type: geometry_type,
-        name: name,
-        is_style_ignored: style_ignored?
+        is_geometry_ignored: geometry_ignored?,
+        is_style_ignored: style_ignored?,
+        name: name
       }
     end
 
     # @return [String]
-    def to_json
-      as_json.to_json
+    def to_json(options = nil)
+      as_json(options).to_json
     end
   end
 end

data/lib/ogr/feature_extensions.rb

@@ -2,30 +2,81 @@ require 'json'
 
 module OGR
   module FeatureExtensions
-
-    # @return [Array<OGR::Field>]
+    # @return [Array] Uses each FieldDefinition to determine the field type at
+    #   each index and returns maps the field as that value type.
     def fields
-      0.upto(field_count - 1).map do |i|
-        field(i)
+      field_count.times.map do |i|
+        case field_definition(i).type
+        when :OFTInteger        then field_as_integer(i)
+        when :OFTIntegerList    then field_as_integer_list(i)
+        when :OFTReal           then field_as_double(i)
+        when :OFTRealList       then field_as_double_list(i)
+        when :OFTString         then field_as_string(i)
+        when :OFTStringList     then field_as_string_list(i)
+        when :OFTWideString     then field_as_string(i)
+        when :OFTWideStringList then field_as_string_list(i)
+        when :OFTBinary         then field_as_binary(i)
+        when :OFTDate, :OFTTime, :OFTDateTime then field_as_date_time(i)
+        when :OFTInteger64      then field_as_integer(i)
+        when :OFTInteger64List  then field_as_integer_lsit(i)
+        when :OFTMaxType        then field_as_date_time(i)
+        else fail "not sure about field type: #{fd.type}"
+        end
+      end
+    end
+
+    # @return [Array<OGR::Geometry>]
+    def geometry_fields
+      geometry_field_count.times.map do |i|
+        geometry_field(i)
+      end
+    end
+
+    # TODO: this seems really wonky...
+    def valid_raw_field?(index, raw_field)
+      field_def = field_definition(index)
+
+      case field_def.type
+      when :OFTInteger then !raw_field[:integer].nil?
+      when :OFTIntegerList then !raw_field[:integer_list].nil?
+      when :OFTInteger64 then !raw_field[:integer64].nil?
+      when :OFTInteger64List then !raw_field[:integer64_list].nil?
+      when :OFTReal then !raw_field[:real].nil?
+      when :OFTRealList then !raw_field[:real_list].nil?
+      when :OFTString then !raw_field[:string].nil?
+      when :OFTStringList then !raw_field[:string_list].nil?
+      when :OFTBinary then !raw_field[:binary].nil?
+      when :OFTDate then !raw_field[:date].nil?
+      else
+        fail OGR::Failure, "Not sure how to set raw type: #{field_def.type}"
       end
     end
 
     # @return [Hash]
-    def as_json
+    def as_json(options = nil)
+      fields_with_nested_json = fields.map do |f|
+        {
+          field_definition: f[:field_definition].as_json(options),
+          value_as_string: f[:value_as_string]
+        }
+      end
+
       {
-        definition: definition,
+        definition: definition.as_json(options),
         fid: fid,
         field_count: field_count,
-        fields: fields.map(&:as_json),
-        geometry: geometry.as_json,
+        fields: fields_with_nested_json,
+        geometry: geometry ? geometry.as_json(options) : nil,
         geometry_field_count: geometry_field_count,
-        style_string: style_string
+        geometry_field_definitions: geometry_field_definitions.map(&:as_json),
+        style_string: style_string,
+        style_table: style_table ? style_table.as_json(options) : nil
       }
     end
 
     # @return [String]
-    def to_json
-      as_json.to_json
+    def to_json(options = nil)
+      as_json(options).to_json
     end
   end
 end

data/lib/ogr/field.rb

@@ -1,91 +1,212 @@
-require_relative '../ffi/ogr'
-require_relative 'field_extensions'
+require 'date'
 
 module OGR
   class Field
-    include FieldExtensions
-    
-    # @param name [String]
-    # @param type [FFI::GDAL::OGRFieldType]
-    # @return [OGR::Field]
-    def self.create(name, type)
-      field_ptr = FFI::GDAL.OGR_Fld_Create(name, type)
-      return nil if field_ptr.null?
+    # @return [FFI::OGR::Point]
+    attr_reader :c_struct
 
-      new(field_ptr)
+    # @param ogr_field_struct [FFI::OGR::Point, FFI::Pointer]
+    def initialize(ogr_field_struct = nil)
+      @c_struct = ogr_field_struct || ::FFI::OGR::Field.new
     end
 
-    # @param field [OGR::Field, FFI::Pointer]
-    def initialize(field)
-      @field_pointer = GDAL._pointer(OGR::Field, field)
+    # @return [FFI::Pointer]
+    def c_pointer
+      @c_struct.to_ptr
     end
 
-    def c_pointer
-      @field_pointer
+    # @return [Fixnum]
+    def integer
+      @c_struct[:integer]
     end
+    alias_method :to_i, :integer
 
-    def destroy!
-      FFI::GDAL.OGR_Fld_Destroy(@field_pointer)
+    # @param new_int [Fixnum]
+    def integer=(new_int)
+      @c_struct[:integer] = new_int
     end
 
-    # @return [String]
-    def name
-      FFI::GDAL.OGR_Fld_GetNameRef(@field_pointer)
+    # @return [Bignum]
+    def integer64
+      @c_struct[:integer64]
     end
 
-    # @param new_value [String]
-    def name=(new_value)
-      FFI::GDAL.OGR_Fld_SetName(@field_pointer, new_value)
+    # @param new_int64 [Bignum]
+    def integer64=(new_int64)
+      @c_struct[:integer64] = new_int64
     end
 
-    # @return [FFI::GDAL::OGRJustification]
-    def justification
-      FFI::GDAL.OGR_Fld_GetJustify(@field_pointer)
+    # @return [Float]
+    def real
+      @c_struct[:real]
     end
+    alias_method :to_f, :real
 
-    # @param new_value [FFI::GDAL::OGRJustification]
-    def justification=(new_value)
-      FFI::GDAL.OGR_Fld_SetJustify(@field_pointer, new_value)
+    # @param new_real [Float]
+    def real=(new_real)
+      @c_struct[:real] = new_real
     end
 
-    # @return [Fixnum]
-    def precision
-      FFI::GDAL.OGR_Fld_GetPrecision(@field_pointer)
+    # TODO: This blows up when another value type has been set.
+    def string
+      return '' if @c_struct[:string] && @c_struct[:string].null?
+
+      @c_struct[:string].read_string
     end
 
-    # @param new_value [Fixnum]
-    def precision=(new_value)
-      FFI::GDAL.OGR_Fld_SetPrecision(@field_pointer, new_value)
+    def string=(new_string)
+      @c_struct[:string] = FFI::MemoryPointer.from_string(new_string)
     end
 
-    # @return [FFI::GDAL::OGRFieldType]
-    def type
-      FFI::GDAL.OGR_Fld_GetType(@field_pointer)
+    # @return [Array<Fixnum>]
+    def integer_list
+      il = @c_struct[:integer_list]
+      return [] if il[:count].zero?
+
+      il[:list].read_array_of_int(il[:count])
     end
 
-    # @param new_value [FFI::GDAL::OGRFieldType]
-    def type=(new_value)
-      FFI::GDAL.OGR_Fld_SetType(@field_pointer, new_value)
+    # @param new_integer_list [Array<Fixnum>]
+    def integer_list=(new_integer_list)
+      list_ptr = FFI::MemoryPointer.new(:int, new_integer_list.size)
+      list_ptr.write_array_of_int(new_integer_list)
+
+      il = FFI::OGR::FieldTypes::IntegerList.new
+      il[:count] = new_integer_list.size
+      il[:list] = list_ptr
+
+      @c_struct[:integer_list] = il
     end
 
-    # @return [Fixnum]
-    def width
-      FFI::GDAL.OGR_Fld_GetWidth(@field_pointer)
+    # @return [Array<Bignum>]
+    def integer64_list
+      il = @c_struct[:integer_list]
+      return [] if il[:count].zero?
+
+      il[:list].read_array_of_int64(il[:count])
+    end
+    alias_method :to_bignum, :integer64_list
+
+    # @param new_integer64_list [Array<Bignum>]
+    def integer64_list=(new_integer64_list)
+      list_ptr = FFI::MemoryPointer.new(:int64, new_integer64_list.size)
+      list_ptr.write_array_of_int64(new_integer64_list)
+
+      il = FFI::OGR::FieldTypes::Integer64List.new
+      il[:count] = new_integer64_list.size
+      il[:list] = list_ptr
+
+      @c_struct[:integer64_list] = il
+    end
+    alias_method :bignum_list=, :integer64_list=
+
+    # @return [Array<Float>]
+    def real_list
+      rl = @c_struct[:real_list]
+      return [] if rl[:count].zero?
+
+      rl[:list].read_array_of_double(rl[:count])
+    end
+    alias_method :float_list, :real_list
+
+    # @param new_real_list [Array<Float>]
+    def real_list=(new_real_list)
+      list_ptr = FFI::MemoryPointer.new(:double, new_real_list.size)
+      list_ptr.write_array_of_double(new_real_list)
+
+      rl = FFI::OGR::FieldTypes::RealList.new
+      rl[:count] = new_real_list.size
+      rl[:list] = list_ptr
+
+      @c_struct[:real_list] = rl
     end
+    alias_method :float_list=, :real_list=
 
-    # @param new_value [Fixnum]
-    def width=(new_value)
-      FFI::GDAL.OGR_Fld_SetWidth(@field_pointer, new_value)
+    # @return [Array<String>]
+    def string_list
+      sl = @c_struct[:string_list]
+      return [] if sl[:count].zero?
+
+      sl[:list].read_array_of_pointer(sl[:count]).map(&:read_string)
+    end
+
+    # @param new_string_list [Array<String>]
+    def string_list=(new_string_list)
+      list_ptr = GDAL._string_array_to_pointer(new_string_list)
+
+      sl = FFI::OGR::FieldTypes::StringList.new
+      sl[:count] = new_string_list.size
+      sl[:list] = list_ptr
+
+      @c_struct[:string_list] = sl
     end
 
-    # @return [Boolean]
-    def ignored?
-      FFI::GDAL.OGR_Fld_IsIgnored(@field_pointer)
+    # @return [String] 8-bit, unsigned data (uchar). Unpack with
+    #   String#unpack('C*').
+    def binary
+      b = @c_struct[:binary]
+
+      b[:count] > 0 ? b[:data].read_bytes(b[:count]) : ''
     end
 
-    # @param new_value [Boolean]
-    def ignore=(new_value)
-      FFI::GDAL.OGR_Fld_SetIgnored(@field_pointer, new_value)
+    # @param new_binary [String] Binary string of 8-bit, unsigned data (uchar).
+    #   Pack with Array#pack('C*').
+    def binary=(new_binary)
+      data = FFI::MemoryPointer.new(:uchar, new_binary.length)
+      data.put_bytes(0, new_binary)
+
+      b = FFI::OGR::FieldTypes::Binary.new
+      b[:data] = data
+      b[:count] = new_binary.length
+
+      @c_struct[:binary] = b
+    end
+
+    # @return [Hash]
+    def set
+      { marker1: @c_struct[:set][:marker1], marker2: @c_struct[:set][:marker2] }
+    end
+
+    # @param new_set [Hash{marker1 => Fixnum, marker2 => Fixnum}]
+    def set=(new_set)
+      set = FFI::OGR::FieldTypes::Set.new
+      set[:marker1] = new_set[:marker1]
+      set[:marker2] = new_set[:marker2]
+
+      @c_struct[:set] = set
+    end
+
+    # @return [DateTime]
+    def date
+      c_date = @c_struct[:date]
+      return if c_date[:year].zero? || c_date[:month].zero? || c_date[:day].zero?
+
+      formatted_tz = OGR._format_time_zone_for_ruby(c_date[:tz_flag].to_i)
+
+      DateTime.new(c_date[:year],
+        c_date[:month],
+        c_date[:day],
+        c_date[:hour],
+        c_date[:minute],
+        c_date[:second],
+        formatted_tz)
+    end
+
+    # @param new_date [Date, Time, DateTime]
+    def date=(new_date)
+      time = new_date.to_time
+      zone = OGR._format_time_zone_for_ogr(time.zone)
+
+      date = FFI::OGR::FieldTypes::Date.new
+      date[:year] = time.year
+      date[:month] = time.month
+      date[:day] = time.day
+      date[:hour] = time.hour
+      date[:minute] = time.min
+      date[:second] = time.sec
+      date[:tz_flag] = zone
+
+      @c_struct[:date] = date
     end
   end
 end