module OGR::LayerMixins::OGRFieldMethods

Public Instance Methods

alter_field_definition(field_index, new_field_definition, flags) click to toggle source

@param field_index [Integer] @param new_field_definition [OGR::FieldDefinition] The definition for

which to base the Field at +field_index+ off of.

@param flags [Integer] ALTER_NAME_FLAG, ALTER_TYPE_FLAG,

ALTER_WIDTH_PRECISION_FLAG, or ALTER_ALL_FLAG.

@raise [OGR::Failure]

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 82
def alter_field_definition(field_index, new_field_definition, flags)
  unless test_capability("AlterFieldDefn")
    raise OGR::UnsupportedOperation, "This layer does not support field definition altering."
  end

  new_field_definition_ptr = GDAL._pointer(OGR::FieldDefinition, new_field_definition)

  OGR::ErrorHandling.handle_ogr_err("Unable to alter field definition at field index #{field_index}") do
    FFI::OGR::API.OGR_L_AlterFieldDefn(
      @c_pointer,
      field_index,
      new_field_definition_ptr,
      flags
    )
  end
end
create_field(field_definition, approx_ok: false) click to toggle source

Creates and writes a new field to the layer. This adds the field to the internal FeatureDefinition; C API says not to update the FeatureDefinition directly.

@param field_definition [OGR::FieldDefinition] @param approx_ok [Boolean] If true the field may be created in a slightly

different form, depending on the limitations of the format driver.

@raise [OGR::Failure]

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 14
def create_field(field_definition, approx_ok: false)
  unless test_capability("CreateField")
    raise OGR::UnsupportedOperation,
          "This layer does not support field creation."
  end

  field_definition_ptr = GDAL._pointer(OGR::FieldDefinition, field_definition)

  OGR::ErrorHandling.handle_ogr_err("Unable to create field") do
    FFI::OGR::API.OGR_L_CreateField(@c_pointer, field_definition_ptr, approx_ok)
  end
end
create_geometry_field(geometry_field_def, approx_ok: false) click to toggle source

Creates and writes a new geometry to the layer. Note: not all drivers support this.

@param geometry_field_def [OGR::GeometryFieldDefinition] The definition

to use for creating the new field.

@param approx_ok [Boolean] @raise [OGR::Failure]

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 118
def create_geometry_field(geometry_field_def, approx_ok: false)
  unless test_capability("CreateGeomField")
    raise OGR::UnsupportedOperation, "This layer does not support geometry field creation"
  end

  geometry_field_definition_ptr = GDAL._pointer(OGR::GeometryFieldDefinition, geometry_field_def)

  OGR::ErrorHandling.handle_ogr_err("Unable to create geometry field") do
    FFI::OGR::API.OGR_L_CreateGeomField(
      @c_pointer,
      geometry_field_definition_ptr,
      approx_ok
    )
  end
end
delete_field(field_id) click to toggle source

Deletes the field definition from the layer.

@raise [OGR::Failure]

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 30
def delete_field(field_id)
  unless test_capability("DeleteField")
    raise OGR::UnsupportedOperation,
          "This driver does not support field deletion."
  end

  OGR::ErrorHandling.handle_ogr_err("Unable to delete field") do
    FFI::OGR::API.OGR_L_DeleteField(@c_pointer, field_id)
  end
end
find_field_index(field_name, exact_match: true) click to toggle source

Finds the index of a field in this Layer.

@param field_name [String] @param exact_match [Boolean] If false and the field doesn’t exist in the

given form, the driver will try to make changes to make a match.

@return [Integer] Index of the field or nil if the field doesn’t exist.

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 105
def find_field_index(field_name, exact_match: true)
  result = FFI::OGR::API.OGR_L_FindFieldIndex(@c_pointer, field_name, exact_match)

  result.negative? ? nil : result
end
reorder_field(old_position, new_position) click to toggle source

Puts the field whose index is old_position into index at new_position and shuffles the other indexes accordingly.

@param old_position [Integer] @param new_position [Integer] @raise [OGR::Failure]

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 65
def reorder_field(old_position, new_position)
  unless test_capability("ReorderFields")
    raise OGR::UnsupportedOperation,
          "This driver does not support field reordering."
  end

  OGR::ErrorHandling.handle_ogr_err("Unable to reorder field: #{old_position} to #{new_position}") do
    FFI::OGR::API.OGR_L_ReorderField(@c_pointer, old_position, new_position)
  end
end
reorder_fields(*new_order) click to toggle source

@param new_order [Array<Integer>] An array that orders field indexes by

which they should be reordered.  I.e. [0, 2, 3, 1, 4].

@raise [OGR::Failure]

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 44
def reorder_fields(*new_order)
  unless test_capability("ReorderFields")
    raise OGR::UnsupportedOperation,
          "This driver does not support field reordering."
  end

  return false if new_order.empty? || new_order.any? { |i| i > feature_definition.field_count }

  map_array_ptr = FFI::MemoryPointer.new(:int, new_order.size).write_array_of_int(new_order)

  OGR::ErrorHandling.handle_ogr_err("Unable to reorder fields using order: #{new_order}") do
    FFI::OGR::API.OGR_L_ReorderFields(@c_pointer, map_array_ptr)
  end
end
set_ignored_fields(*field_names) click to toggle source

If the driver supports this functionality, it will not fetch the specified fields in subsequent calls to feature / next_feature and thus save some processing time and/or bandwidth.

@param field_names [Array<String>] @raise [OGR::Failure]

# File lib/ogr/layer_mixins/ogr_field_methods.rb, line 140
def set_ignored_fields(*field_names)
  return false if field_names.empty?

  fields_ptr = GDAL._string_array_to_pointer(field_names)

  OGR::ErrorHandling.handle_ogr_err("Unable to ignore fields with names: #{field_names}") do
    FFI::OGR::API.OGR_L_SetIgnoredFields(@c_pointer, fields_ptr)
  end
end