class OGR::DataSource

Attributes

c_pointer[R]

@return [FFI::Pointer]

Public Class Methods

new(path_or_pointer, access_flag) click to toggle source

@param path_or_pointer [String, FFI::Pointer] Path/URL to the file to

open or the Pointer to an already existing data soruce.

@param access_flag [String] ‘r’ for read, ‘w’, for write.

# File lib/ogr/data_source.rb, line 52
def initialize(path_or_pointer, access_flag)
  @c_pointer =
    if path_or_pointer.is_a?(String)
      FFI::OGR::API.OGROpen(path_or_pointer, OGR._boolean_access_flag(access_flag), nil)
    else
      path_or_pointer
    end

  if @c_pointer.null?
    error_msg, ptr = FFI::CPL::Error.CPLGetLastErrorMsg
    ptr.autorelease = false

    error_type = FFI::CPL::Error.CPLGetLastErrorType
    FFI::CPL::Error.CPLErrorReset

    raise OGR::OpenFailure, "#{error_type}: #{error_msg} (#{path_or_pointer})"
  end

  @layers = []
end
open(path, access_flag = "r") { |ds| ... } click to toggle source

Same as .new.

@param path [String] @param access_flag [String] ‘r’ for read, ‘w’, for write. @return [OGR::DataSource]

# File lib/ogr/data_source.rb, line 17
def self.open(path, access_flag = "r")
  ds = new(path, access_flag)

  if block_given?
    result = yield ds
    ds.close
    result
  else
    ds
  end
end
release(pointer) click to toggle source

@param pointer [FFI::Pointer]

# File lib/ogr/data_source.rb, line 30
def self.release(pointer)
  return unless pointer && !pointer.null?

  FFI::OGR::API.OGR_DS_Destroy(pointer)
end
release_result_set(data_source_pointer, layer_pointer) click to toggle source

Use to release the resulting data pointer from execute_sql.

@param data_source_pointer [FFI::Pointer] @param layer_pointer [FFI::Pointer]

# File lib/ogr/data_source.rb, line 40
def self.release_result_set(data_source_pointer, layer_pointer)
  return unless data_source_pointer && !data_source_pointer.null? && layer_pointer && !layer_pointer.null?

  FFI::OGR::API.OGR_DS_ReleaseResultSet(data_source_pointer, layer_pointer)
end

Public Instance Methods

close()
Alias for: destroy!
copy_layer(source_layer, new_name, **options) click to toggle source

@param source_layer [OGR::Layer, FFI::Pointer] @param new_name [String] @param options [Hash] @return [OGR::Layer, nil]

# File lib/ogr/data_source.rb, line 163
def copy_layer(source_layer, new_name, **options)
  source_layer_ptr = GDAL._pointer(OGR::Layer, source_layer)
  options_ptr = GDAL::Options.pointer(options)

  layer_ptr = FFI::OGR::API.OGR_DS_CopyLayer(@c_pointer, source_layer_ptr,
                                             new_name, options_ptr)
  return nil if layer_ptr.null?

  OGR::Layer.new(layer_ptr)
end
create_layer(name, geometry_type: :wkbUnknown, spatial_reference: nil, **options) click to toggle source

@param name [String] The name for the new layer. @param geometry_type [FFI::OGR::API::WKBGeometryType] Constrain to this

geometry type.

@param spatial_reference [FFI::Pointer, OGR::SpatialReference] The coordinate system @param options [Hash] Driver-specific options. @return [OGR::Layer]

# File lib/ogr/data_source.rb, line 140
def create_layer(name, geometry_type: :wkbUnknown, spatial_reference: nil, **options)
  unless test_capability("CreateLayer")
    raise OGR::UnsupportedOperation,
          "This data source does not support creating layers."
  end

  spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, spatial_reference, autorelease: false) if spatial_reference
  options_obj = GDAL::Options.pointer(options)

  layer_ptr =
    FFI::OGR::API.OGR_DS_CreateLayer(@c_pointer, name, spatial_ref_ptr, geometry_type, options_obj)

  raise OGR::InvalidLayer, "Unable to create layer '#{name}'." unless layer_ptr

  @layers << OGR::Layer.new(layer_ptr)

  @layers.last
end
delete_layer(index) click to toggle source

@param index [Integer] @raise [OGR::Failure]

# File lib/ogr/data_source.rb, line 176
def delete_layer(index)
  unless test_capability("DeleteLayer")
    raise OGR::UnsupportedOperation,
          "This data source does not support deleting layers."
  end

  OGR::ErrorHandling.handle_ogr_err("Unable to delete layer at index #{index}") do
    FFI::OGR::API.OGR_DS_DeleteLayer(@c_pointer, index)
  end
end
destroy!() click to toggle source

Closes opened data source and releases allocated resources.

# File lib/ogr/data_source.rb, line 74
def destroy!
  DataSource.release(@c_pointer)

  @c_pointer = nil
end
Also aliased as: close
driver() click to toggle source

@return [OGR::Driver]

# File lib/ogr/data_source.rb, line 93
def driver
  driver_ptr = FFI::OGR::API.OGR_DS_GetDriver(@c_pointer)
  return nil if driver_ptr.nil?

  OGR::Driver.new(driver_ptr)
end
execute_sql(command, spatial_filter = nil, dialect = nil) click to toggle source

@param command [String] The SQL to execute. @param spatial_filter [OGR::Geometry, FFI::Pointer] @param dialect [String] Can pass in ‘SQLITE’ to use that instead of the

default OGRSQL dialect.

@return [OGR::Layer, nil] @see www.gdal.org/ogr_sql.html

# File lib/ogr/data_source.rb, line 193
def execute_sql(command, spatial_filter = nil, dialect = nil)
  geometry_ptr = GDAL._pointer(OGR::Geometry, spatial_filter) if spatial_filter

  layer_ptr = FFI::OGR::API.OGR_DS_ExecuteSQL(@c_pointer, command, geometry_ptr, dialect)
  layer_ptr.autorelease = false

  return nil if layer_ptr.null?

  OGR::Layer.new(FFI::AutoPointer.new(layer_ptr, lambda { |ptr|
    DataSource.release_result_set(@c_pointer, ptr)
  }))
end
layer(index) click to toggle source

@param index [Integer] 0-offset index of the layer to retrieve. @return [OGR::Layer]

# File lib/ogr/data_source.rb, line 107
def layer(index)
  @layers.fetch(index) do
    # The returned layer remains owned by the OGRDataSource and should not be deleted by the application.
    layer_pointer = FFI::OGR::API.OGR_DS_GetLayer(@c_pointer, index)
    layer_pointer.autorelease = false

    return nil if layer_pointer.null?

    l = OGR::Layer.new(layer_pointer)
    @layers.insert(index, l)

    l
  end
end
layer_by_name(name) click to toggle source

@param name [String] @return [OGR::Layer]

# File lib/ogr/data_source.rb, line 124
def layer_by_name(name)
  # The returned layer remains owned by the OGRDataSource and should not be deleted by the application.
  layer_pointer = FFI::OGR::API.OGR_DS_GetLayerByName(@c_pointer, name)
  layer_pointer.autorelease = false

  return nil if layer_pointer.null?

  OGR::Layer.new(layer_pointer)
end
layer_count() click to toggle source

@return [Integer]

# File lib/ogr/data_source.rb, line 101
def layer_count
  FFI::OGR::API.OGR_DS_GetLayerCount(@c_pointer)
end
name() click to toggle source

Name of the file represented by this object.

@return [String]

# File lib/ogr/data_source.rb, line 84
def name
  # This is an internal string and should not be modified or freed.
  name_ptr = FFI::OGR::API.OGR_DS_GetName(@c_pointer)
  name_ptr.autorelease = false

  name_ptr.read_string_to_null
end
style_table() click to toggle source

@return [OGR::StyleTable, nil]

# File lib/ogr/data_source.rb, line 207
def style_table
  style_table_ptr = FFI::OGR::API.OGR_DS_GetStyleTable(@c_pointer)
  style_table_ptr.autorelease = false

  return nil if style_table_ptr.null?

  OGR::StyleTable.new(style_table_ptr)
end
style_table=(new_style_table) click to toggle source

@param new_style_table [OGR::StyleTable, FFI::Pointer]

# File lib/ogr/data_source.rb, line 217
def style_table=(new_style_table)
  new_style_table_ptr = GDAL._pointer(OGR::StyleTable, new_style_table)

  FFI::OGR::API.OGR_DS_SetStyleTable(@c_pointer, new_style_table_ptr)

  if new_style_table.instance_of? OGR::StyleTable
    new_style_table
  else
    OGR::StyleTable.new(new_style_table_ptr)
  end
end
sync_to_disk() click to toggle source

@raise [OGR::Failure]

# File lib/ogr/data_source.rb, line 238
def sync_to_disk
  OGR::ErrorHandling.handle_ogr_err("Unable to syn datasource to disk") do
    FFI::OGR::API.OGR_DS_SyncToDisk(@c_pointer)
  end
end
test_capability(capability) click to toggle source

@param capability [String] Must be one of: ODsCCreateLayer,

ODsCDeleteLayer, ODsCCreateGeomFieldAfterCreateLayer,
ODsCCurveGeometries.

@return [Boolean]

# File lib/ogr/data_source.rb, line 233
def test_capability(capability)
  FFI::OGR::API.OGR_DS_TestCapability(@c_pointer, capability)
end