ffi-gdal 1.0.0.beta16 → 1.0.0

data/lib/ogr/spatial_reference_mixins/exporters.rb

@@ -10,8 +10,9 @@ module OGR
         datum_name = FFI::MemoryPointer.new(:string, 32)
         units = FFI::MemoryPointer.new(:string, 32)
 
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToERM(@c_pointer, projection_name, datum_name, units)
-        ogr_err.handle_result 'Required parameters (name, datum name, units) are not defined'
+        OGR::ErrorHandling.handle_ogr_err('Required parameters (name, datum name, units) are not defined') do
+          FFI::OGR::SRSAPI.OSRExportToERM(@c_pointer, projection_name, datum_name, units)
+        end
 
         {
           projection_name: projection_name.read_string,
@@ -21,85 +22,120 @@ module OGR
       end
 
       # @return [Array<String>]
+      # @raise [OGR::Failure]
       def to_mapinfo
-        return_ptr_ptr = GDAL._pointer_pointer(:string)
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToMICoordSys(@c_pointer, return_ptr_ptr)
-        ogr_err.handle_result
-
-        return_ptr_ptr.get_array_of_string(0)
+        GDAL._cpl_read_and_free_string do |return_ptr_ptr|
+          OGR::ErrorHandling.handle_ogr_err('Unable to export to MapInfo') do
+            FFI::OGR::SRSAPI.OSRExportToMICoordSys(@c_pointer, return_ptr_ptr)
+          end
+        end
       end
 
       # @return [Hash]
+      # @raise [OGR::Failure]
       def to_pci
-        proj_ptr = GDAL._pointer_pointer(:string)
-        units_ptr = GDAL._pointer_pointer(:string)
-        prj_params_ptr = GDAL._pointer_pointer(:double)
+        proj_ptr_ptr = GDAL._pointer_pointer(:string)
+        proj_ptr_ptr.autorelease = false
+        units_ptr_ptr = GDAL._pointer_pointer(:string)
+        units_ptr_ptr.autorelease = false
+        prj_params_ptr_ptr = GDAL._pointer_pointer(:double)
+        prj_params_ptr_ptr.autorelease = false
+
+        OGR::ErrorHandling.handle_ogr_err('Unable to export to PCI') do
+          FFI::OGR::SRSAPI.OSRExportToPCI(@c_pointer, proj_ptr_ptr, units_ptr_ptr, prj_params_ptr_ptr)
+        end
+
+        projection = proj_ptr_ptr.read_pointer.read_string
+        units = units_ptr_ptr.read_pointer.read_string
+        projection_parameters = prj_params_ptr_ptr.read_array_of_double(0)
+
+        result = {
+          projection: projection,
+          units: units,
+          projection_parameters: projection_parameters
+        }
 
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToPCI(@c_pointer, proj_ptr, units_ptr, prj_params_ptr)
-        ogr_err.handle_result
+        FFI::CPL::VSI.VSIFree(proj_ptr_ptr)
+        FFI::CPL::VSI.VSIFree(units_ptr_ptr)
+        FFI::CPL::VSI.VSIFree(prj_params_ptr_ptr)
 
-        {
-          projection: proj_ptr.read_pointer.read_string,
-          units: units_ptr.read_pointer.read_string,
-          projection_parameters: prj_params_ptr.read_array_of_double(0)
-        }
+        result
       end
 
       # @return [String]
       # @raise [GDAL::UnsupportedOperation] If empty definition.
       def to_proj4
-        proj4_ptr = GDAL._pointer_pointer(:string)
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToProj4(@c_pointer, proj4_ptr)
-        ogr_err.handle_result
-
-        GDAL._read_pointer_pointer_safely(proj4_ptr, :string)
+        GDAL._cpl_read_and_free_string do |proj4_ptr_ptr|
+          OGR::ErrorHandling.handle_ogr_err('Unable to export to PROJ.4') do
+            FFI::OGR::SRSAPI.OSRExportToProj4(@c_pointer, proj4_ptr_ptr)
+          end
+        end
       end
 
       # @return [Hash]
+      # @raise [OGR::Failure]
       def to_usgs
-        proj_sys = FFI::MemoryPointer.new(:long)
-        zone = FFI::MemoryPointer.new(:long)
-        datum = FFI::MemoryPointer.new(:long)
-        prj_params_ptr = GDAL._pointer_pointer(:double)
+        proj_sys_ptr = FFI::MemoryPointer.new(:long)
+        zone_ptr = FFI::MemoryPointer.new(:long)
+        datum_ptr = FFI::MemoryPointer.new(:long)
+        prj_params_ptr_ptr = GDAL._pointer_pointer(:double)
+        prj_params_ptr_ptr.autorelease = false
+
+        OGR::ErrorHandling.handle_ogr_err('Unable to export to USGS GCTP') do
+          FFI::OGR::SRSAPI.OSRExportToUSGS(@c_pointer, proj_sys_ptr, zone_ptr, prj_params_ptr_ptr, datum_ptr)
+        end
+
+        projection_system_code = proj_sy_ptrs.read_long
+        zone = zon_ptre.read_long
+        projection_parameters = prj_params_pt_ptrr.read_array_of_double(0)
+        datum = datu_ptrm.read_long
+
+        result = {
+          projection_system_code: projection_system_code,
+          zone: zone,
+          projection_parameters: projection_parameters,
+          datum: datum
+        }
 
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToUSGS(@c_pointer, proj_sys, zone, prj_params_ptr, datum)
-        ogr_err.handle_result
+        FFI::CPL::VSI.VSIFree(prj_params_ptr_ptr)
 
-        {
-          projection_system_code: proj_sys.read_long,
-          zone: zone.read_long,
-          projection_parameters: prj_params_ptr.read_array_of_double(0),
-          datum: datum.read_long
-        }
+        result
       end
 
       # @return [String]
+      # @raise [OGR::Failure]
       def to_wkt
-        wkt_ptr_ptr = GDAL._pointer_pointer(:string)
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToWkt(@c_pointer, wkt_ptr_ptr)
-        ogr_err.handle_result
-
-        GDAL._read_pointer_pointer_safely(wkt_ptr_ptr, :string)
+        GDAL._cpl_read_and_free_string do |wkt_ptr_ptr|
+          OGR::ErrorHandling.handle_ogr_err('Unable to export to WKT') do
+            FFI::OGR::SRSAPI.OSRExportToWkt(@c_pointer, wkt_ptr_ptr)
+          end
+        end
       end
 
       # @param simplify [Boolean] +true+ strips off +AXIS+, +AUTHORITY+ and
       #   +EXTENSION+ nodes.
-      def to_pretty_wkt(simplify = false)
-        wkt_ptr_ptr = GDAL._pointer_pointer(:string)
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToPrettyWkt(@c_pointer, wkt_ptr_ptr, simplify)
-        ogr_err.handle_result
-
-        GDAL._read_pointer_pointer_safely(wkt_ptr_ptr, :string)
+      # @raise [OGR::Failure]
+      # @return [String]
+      def to_pretty_wkt(simplify: false)
+        return +'' if @c_pointer.null?
+
+        GDAL._cpl_read_and_free_string do |wkt_ptr_ptr|
+          OGR::ErrorHandling.handle_ogr_err('Unable to export to pretty WKT') do
+            FFI::OGR::SRSAPI.OSRExportToPrettyWkt(@c_pointer, wkt_ptr_ptr, simplify)
+          end
+        end
       end
 
       # @return [String]
-      def to_xml(dialect = nil)
-        xml_ptr_ptr = GDAL._pointer_pointer(:string)
-        ogr_err = FFI::OGR::SRSAPI.OSRExportToXML(@c_pointer, xml_ptr_ptr, dialect)
-        ogr_err.handle_result
-
-        xml_ptr_ptr.get_array_of_string(0).join
+      # @raise [OGR::Failure]
+      def to_xml
+        GDAL._cpl_read_and_free_string do |xml_ptr_ptr|
+          OGR::ErrorHandling.handle_ogr_err('Unable to export to XML (GML)') do
+            FFI::OGR::SRSAPI.OSRExportToXML(@c_pointer, xml_ptr_ptr, nil)
+          end
+        end
       end
+      alias to_gml to_xml
     end
   end
 end

data/lib/ogr/spatial_reference_mixins/importers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../error_handling'
+
 module OGR
   module SpatialReferenceMixins
     module Importers
@@ -8,7 +10,7 @@ module OGR
       end
 
       module ClassMethods
-        # @param code [Fixnum]
+        # @param code [Integer]
         # @return [OGR::SpatialReference]
         def new_from_epsg(code)
           srs = new
@@ -17,11 +19,11 @@ module OGR
           srs
         end
 
-        # @param code [Fixnum]
+        # @param code [Integer]
         # @return [OGR::SpatialReference]
         def new_from_epsga(code)
           srs = new
-          srs.import_from_epsg(code)
+          srs.import_from_epsga(code)
 
           srs
         end
@@ -117,59 +119,81 @@ module OGR
         end
 
         # @return [OGR::SpatialReference]
+        # @raise [OGR::Failure]
         def build_spatial_ref(spatial_reference_or_wkt = nil)
           object = new(spatial_reference_or_wkt)
           ogr_err = yield object.c_pointer
-          ogr_err.handle_result
+
+          OGR::ErrorHandling.handle_ogr_err('Unable to build SpatialReference') do
+            ogr_err
+          end
 
           object
         end
       end
 
-      # @param code [Fixnum]
+      # @param code [Integer]
+      # @return [OGR::SpatialReference] `self`, but updated with the EPSG code.
       # @raise [GDAL::UnsupportedOperation] On unknown EPSG code.
       def import_from_epsg(code)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromEPSG(@c_pointer, code)
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from EPSG: #{code}") do
+          FFI::OGR::SRSAPI.OSRImportFromEPSG(@c_pointer, code)
+        end
 
-        ogr_err.handle_result
+        self
       end
 
-      # @param code [Fixnum]
+      # @param code [Integer]
+      # @raise [OGR::Failure]
       def import_from_epsga(code)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromEPSGA(@c_pointer, code)
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from EPSGA: #{code}") do
+          FFI::OGR::SRSAPI.OSRImportFromEPSGA(@c_pointer, code)
+        end
 
-        ogr_err.handle_result
+        self
       end
 
       # @param wkt [String]
+      # @raise [OGR::Failure]
       def import_from_wkt(wkt)
         wkt_ptr = FFI::MemoryPointer.from_string(wkt)
         wkt_ptr_ptr = FFI::MemoryPointer.new(:pointer)
         wkt_ptr_ptr.write_pointer(wkt_ptr)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromWkt(@c_pointer, wkt_ptr_ptr)
 
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from WKT: #{wkt}") do
+          FFI::OGR::SRSAPI.OSRImportFromWkt(@c_pointer, wkt_ptr_ptr)
+        end
+
+        self
       end
 
       # @param proj4 [String]
+      # @raise [OGR::Failure]
       def import_from_proj4(proj4)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromProj4(@c_pointer, proj4)
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from PROJ.4: #{proj4}") do
+          FFI::OGR::SRSAPI.OSRImportFromProj4(@c_pointer, proj4)
+        end
 
-        ogr_err.handle_result
+        self
       end
 
       # @param esri_text [Array<String>]
+      # @raise [OGR::Failure]
       def import_from_esri(esri_text)
         text_array = esri_text.split("\n")
         esri_ptr_ptr = GDAL._string_array_to_pointer(text_array)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromESRI(@c_pointer, esri_ptr_ptr)
 
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from ESRI: #{esri_text}") do
+          FFI::OGR::SRSAPI.OSRImportFromESRI(@c_pointer, esri_ptr_ptr)
+        end
+
+        self
       end
 
       # @param proj [String]
       # @param units [String]
       # @param proj_params [Array<String>]
+      # @raise [OGR::Failure]
       def import_from_pci(proj, units, *proj_params)
         if proj_params.empty?
           proj_ptr = nil
@@ -178,15 +202,18 @@ module OGR
           proj_ptr.write_array_of_double(proj_params)
         end
 
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromPCI(@c_pointer, proj, units, proj_ptr)
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from PCI: #{proj}") do
+          FFI::OGR::SRSAPI.OSRImportFromPCI(@c_pointer, proj, units, proj_ptr)
+        end
 
-        ogr_err.handle_result
+        self
       end
 
-      # @param projection_system_code [Fixnum]
-      # @param zone [Fixnum]
-      # @param datum [Fixnum]
+      # @param projection_system_code [Integer]
+      # @param zone [Integer]
+      # @param datum [Integer]
       # @param proj_params [Array<Float>]
+      # @raise [OGR::Failure]
       def import_from_usgs(projection_system_code, zone, datum, *proj_params)
         if proj_params.empty?
           proj_ptr = nil
@@ -195,52 +222,70 @@ module OGR
           proj_ptr.write_array_of_double(proj_params)
         end
 
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromUSGS(
-          @c_pointer,
-          projection_system_code,
-          zone,
-          proj_ptr,
-          datum
-        )
+        msg = "Unable to import from USGS: #{projection_system_code}, #{zone}, #{datum}, #{proj_params}"
 
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err(msg) do
+          FFI::OGR::SRSAPI.OSRImportFromUSGS(
+            @c_pointer,
+            projection_system_code,
+            zone,
+            proj_ptr,
+            datum
+          )
+        end
+
+        self
       end
 
       # Use for importing a GML coordinate system.
       #
       # @param xml [String]
+      # @raise [OGR::Failure]
       def import_from_xml(xml)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromXML(@c_pointer, xml)
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from XML: #{xml}") do
+          FFI::OGR::SRSAPI.OSRImportFromXML(@c_pointer, xml)
+        end
 
-        ogr_err.handle_result
+        self
       end
 
       # @param coord_sys [String] The Mapinfo style CoordSys definition string.
+      # @raise [OGR::Failure]
       def import_from_mapinfo(coord_sys)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromMICoordSys(@c_pointer, coord_sys)
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from MapInfo: #{coord_sys}") do
+          FFI::OGR::SRSAPI.OSRImportFromMICoordSys(@c_pointer, coord_sys)
+        end
 
-        ogr_err.handle_result
+        self
       end
 
       # @param projection_name [String] I.e. "NUTM11" or "GEOGRAPHIC".
       # @param datum_name [String] I.e. "NAD83".
       # @param linear_unit_name [String] Plural form of linear units, i.e. "FEET".
+      # @raise [OGR::Failure]
       def import_from_erm(projection_name, datum_name, linear_unit_name)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromERM(
-          @c_pointer,
-          projection_name,
-          datum_name,
-          linear_unit_name
-        )
-
-        ogr_err.handle_result
+        msg = "Unable to import from ERMapper: #{projection_name}, #{datum_name}, #{linear_unit_name}"
+
+        OGR::ErrorHandling.handle_ogr_err(msg) do
+          FFI::OGR::SRSAPI.OSRImportFromERM(
+            @c_pointer,
+            projection_name,
+            datum_name,
+            linear_unit_name
+          )
+        end
+
+        self
       end
 
       # @param url [String] URL to fetch the spatial reference from.
+      # @raise [OGR::Failure]
       def import_from_url(url)
-        ogr_err = FFI::OGR::SRSAPI.OSRImportFromUrl(@c_pointer, url)
+        OGR::ErrorHandling.handle_ogr_err("Unable to import from URL: #{url}") do
+          FFI::OGR::SRSAPI.OSRImportFromUrl(@c_pointer, url)
+        end
 
-        ogr_err.handle_result
+        self
       end
     end
   end

data/lib/ogr/spatial_reference_mixins/morphers.rb

@@ -5,22 +5,26 @@ module OGR
     module Morphers
       # Converts, in place, to ESRI WKT format.
       #
-      # @return [OGR::SpatialReference, false] If successful, returns self.
+      # @return [OGR::SpatialReference] If successful, returns self.
+      # @raise [OGR::Failure]
       def morph_to_esri!
-        ogr_err = FFI::OGR::SRSAPI.OSRMorphToESRI(@c_pointer)
-        result = ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err('Unable to morph self to ESRI') do
+          FFI::OGR::SRSAPI.OSRMorphToESRI(@c_pointer)
+        end
 
-        result ? self : result
+        self
       end
 
       # Converts, in place, from ESRI WKT format.
       #
-      # @return [OGR::SpatialReference, false] If successful, returns self.
+      # @return [OGR::SpatialReference] If successful, returns self.
+      # @raise [OGR::Failure]
       def morph_from_esri!
-        ogr_err = FFI::OGR::SRSAPI.OSRMorphFromESRI(@c_pointer)
-        result = ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err('Unable to morph self from ESRI') do
+          FFI::OGR::SRSAPI.OSRMorphFromESRI(@c_pointer)
+        end
 
-        result ? self : result
+        self
       end
     end
   end

data/lib/ogr/spatial_reference_mixins/parameter_getter_setters.rb

@@ -4,7 +4,7 @@ module OGR
   module SpatialReferenceMixins
     module ParameterGetterSetters
       # @param name [String] The case-insensitive tree node to look for.
-      # @param child [Fixnum] The child of the node to fetch.
+      # @param child [Integer] The child of the node to fetch.
       # @return [String, nil]
       def attribute_value(name, child = 0)
         FFI::OGR::SRSAPI.OSRGetAttrValue(@c_pointer, name, child)
@@ -14,10 +14,11 @@ module OGR
       #   pipe symbol to denote nesting.  i.e. 'GEOCCS|UNIT'.
       # @param value [String] The new value for the node/path.  Should be a String,
       #   but if not, will be converted for you.
+      # @raise [OGR::Failure]
       def set_attribute_value(path, value)
-        ogr_err = FFI::OGR::SRSAPI.OSRSetAttrValue(@c_pointer, path, value.to_s)
-
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err("Unable to set attribute (#{path}) to value #{value}") do
+          FFI::OGR::SRSAPI.OSRSetAttrValue(@c_pointer, path, value.to_s)
+        end
       end
 
       # @return [Hash{unit_name: String, value: Float}]  +unit_name+ is the name
@@ -33,10 +34,13 @@ module OGR
       # @param unit_label [String]
       # @param transform_to_radians [Float] The value to multiply an angle to
       #   transform the value to radians.
+      # @raise [OGR::Failure]
       def set_angular_units(unit_label, transform_to_radians)
-        ogr_err = FFI::OGR::SRSAPI.OSRSetAngularUnits(@c_pointer, unit_label, transform_to_radians.to_f)
+        msg = "Unable to set angular units to #{unit_label} (transform to radians? #{transform_to_radians})"
 
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err(msg) do
+          FFI::OGR::SRSAPI.OSRSetAngularUnits(@c_pointer, unit_label, transform_to_radians.to_f)
+        end
       end
 
       # @return [Hash{unit_name: String, value: Float}]  +unit_name+ is the name
@@ -52,10 +56,13 @@ module OGR
       # @param unit_label [String]
       # @param transform_to_meters [Float] The value to multiply a length to
       #   transform the value to meters.
+      # @raise [OGR::Failure]
       def set_linear_units(unit_label, transform_to_meters)
-        ogr_err = FFI::OGR::SRSAPI.OSRSetLinearUnits(@c_pointer, unit_label, transform_to_meters.to_f)
+        msg = "Unable to set linear units to #{unit_label} (transform to meters? #{transform_to_meters})"
 
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err(msg) do
+          FFI::OGR::SRSAPI.OSRSetLinearUnits(@c_pointer, unit_label, transform_to_meters.to_f)
+        end
       end
 
       # Does the same as #set_linear_units, but also converts parameters to use
@@ -64,11 +71,14 @@ module OGR
       # @param unit_label [String]
       # @param transform_to_meters [Float] The value to multiply a length to
       #   transform the value to meters.
+      # @raise [OGR::Failure]
       def set_linear_units_and_update_parameters(unit_label, transform_to_meters)
-        ogr_err = FFI::OGR::SRSAPI.OSRSetLinearUnitsAndUpdateParameters(@c_pointer, unit_label,
-          transform_to_meters.to_f)
+        msg = "Unable to set linear units to #{unit_label} (transform to meters? #{transform_to_meters}) and update" \
+              'parameters'
 
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err(msg) do
+          FFI::OGR::SRSAPI.OSRSetLinearUnitsAndUpdateParameters(@c_pointer, unit_label, transform_to_meters.to_f)
+        end
       end
 
       # The linear units for the projection.
@@ -87,10 +97,14 @@ module OGR
       # @param unit_label [String] Name of the units to be used.
       # @param transform_to_meters [Float] The value to multiple a length to
       #   transform the value to meters.
+      # @raise [OGR::Failure]
       def set_target_linear_units(target_key, unit_label, transform_to_meters)
-        ogr_err = FFI::OGR::SRSAPI.OSRSetTargetLinearUnits(@c_pointer, target_key, unit_label, transform_to_meters)
+        msg = "Unable to set target (#{target_key}) linear units to #{unit_label} " \
+              "(transform to meters? #{transform_to_meters})"
 
-        ogr_err.handle_result
+        OGR::ErrorHandling.handle_ogr_err(msg) do
+          FFI::OGR::SRSAPI.OSRSetTargetLinearUnits(@c_pointer, target_key, unit_label, transform_to_meters)
+        end
       end
 
       # @return [Hash]

data/lib/ogr/style_table.rb

@@ -1,26 +1,36 @@
 # frozen_string_literal: true
 
+require_relative '../gdal'
 require_relative '../ogr'
-require_relative 'style_table_extensions'
 
 module OGR
   class StyleTable
-    include StyleTableExtensions
+    # @param pointer [FFI::Pointer]
+    def self.release(pointer)
+      return unless pointer && !pointer.null?
+
+      FFI::OGR::API.OGR_STBL_Destroy(pointer)
+    end
 
     # @return [FFI::Pointer] C pointer to the C style table.
     attr_reader :c_pointer
 
     # @param [FFI::Pointer] c_pointer
     def initialize(c_pointer = nil)
-      @c_pointer = c_pointer ? c_pointer : FFI::OGR::API.OGR_STBL_Create
+      @c_pointer = if c_pointer
+                     c_pointer
+                   else
+                     pointer = FFI::OGR::API.OGR_STBL_Create
+                     pointer.autorelease = false
+                     FFI::AutoPointer.new(pointer, StyleTable.method(:release))
+                   end
 
       raise 'Unable to create StyleTable' if @c_pointer.null?
     end
 
     def destroy!
-      return unless @c_pointer
+      StyleTable.release(@c_pointer)
 
-      FFI::OGR::API.OGR_STBL_Destroy(@c_pointer)
       @c_pointer = nil
     end