ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/ogr/layer_mixins/extensions.rb

@@ -4,31 +4,229 @@ module OGR
   module LayerMixins
     # Methods not part of the C Layer API.
     module Extensions
+      # Enumerates through all associated features. Beware: it calls
+      # {#reset_reading} both before and after it's called. If you're using
+      # {OGR::Layer#next_feature} for iterating through features somewhere in
+      # your code, this will reset that reading.
+      #
+      # @return [Enumerator]
+      # @yieldparam [OGR::Feature]
+      def each_feature
+        return enum_for(:each_feature) unless block_given?
+
+        FFI::OGR::API.OGR_L_ResetReading(@c_pointer)
+
+        loop do
+          feature = next_feature
+          break unless feature
+
+          begin
+            yield feature
+          rescue
+            feature.destroy!
+            raise
+          end
+
+          feature.destroy!
+        end
+
+        FFI::OGR::API.OGR_L_ResetReading(@c_pointer)
+      end
+
+      # @return [Enumerator]
+      # @yieldparam [FFI::Pointer] A pointer to each feature in the layer.
+      def each_feature_pointer
+        return enum_for(:each_feature_pointer) unless block_given?
+
+        FFI::OGR::API.OGR_L_ResetReading(@c_pointer)
+
+        loop do
+          feature_ptr = FFI::OGR::API.OGR_L_GetNextFeature(@c_pointer)
+
+          if feature_ptr.null?
+            FFI::OGR::API.OGR_F_Destroy(feature_ptr)
+            break
+          end
+
+          begin
+            yield feature_ptr
+          rescue
+            FFI::OGR::API.OGR_F_Destroy(feature_ptr)
+            raise
+          end
+
+          FFI::OGR::API.OGR_F_Destroy(feature_ptr)
+        end
+
+        FFI::OGR::API.OGR_L_ResetReading(@c_pointer)
+      end
+
+      # Returns all features as an Array. Note that if you just want to iterate
+      # through features, {{#each_feature}} will perform better.
+      #
       # @return [Array<OGR::Feature>]
       def features
-        return [] if feature_count.zero?
+        each_feature.map { |f| f.clone }
+      end
+
+      # @return [OGR::Polygon] A polygon derived from a LinearRing that connects
+      #   the 4 bounding box points (from the extent).
+      def geometry_from_extent
+        ring = OGR::LinearRing.new
+
+        ring.point_count = 5
+        ring.set_point(0, extent.x_min, extent.y_min)
+        ring.set_point(1, extent.x_min, extent.y_max)
+        ring.set_point(2, extent.x_max, extent.y_max)
+        ring.set_point(3, extent.x_max, extent.y_min)
+        ring.set_point(4, extent.x_min, extent.y_min)
+
+        polygon = OGR::Polygon.new spatial_reference: spatial_reference.dup
+        polygon.add_geometry(ring)
+
+        polygon
+      end
+
+      # Iterates through all geometries in the Layer and extracts the point
+      # values to an Array. The result will be an Array of Arrays where the
+      # inner Array is the point values. If +with_attributes+ is given, it will
+      # extract the field values for each given field names.
+      #
+      # @example Not passing +with_attributes+
+      #   points = layer.point_values
+      #   # => [[100, 100], [100, 120], [110, 110], [110, 100], [100, 100]]
+      #
+      # @example With +with_attributes+
+      #   points = layer.point_values('Moisture' => :double, 'Color' => :string)
+      #   # => [[100, 100, 74.2, 'Red'],
+      #         [100, 120, 19.0, 'Blue'],
+      #         [110, 110, 21.1, 'Red'],
+      #         [110, 100, 54.99, 'Green'],
+      #         [100, 100, 3.3, 'Red']]
+      #
+      # @param with_attributes [String, Array<String>]
+      # @return [Array<Array>]
+      # @raise [OGR::UnsupportedGeometryType] if a geometry of some type is
+      #   encountered that the method doesn't know how to extract point values
+      #   from.
+      def point_values(with_attributes = {})
+        return [[]] if feature_count.zero?
+
+        field_indices = with_attributes.keys.map { |field_name| find_field_index(field_name) }
+        values = Array.new(feature_count) { Array.new(2 + with_attributes.size) }
+        start = Time.now
+        i = 0
+
+        # Initing these once and only once in the case the geom type is _not_
+        # wkbPoint.
+        x_ptr = FFI::MemoryPointer.new(:double)
+        y_ptr = FFI::MemoryPointer.new(:double)
 
-        feature_list = feature_count.times.map do |i|
-          feature(i)
+        each_feature_pointer do |feature_ptr|
+          field_values = field_indices.map.with_index do |j, attribute_index|
+            FFI::OGR::API.send("OGR_F_GetFieldAs#{with_attributes.values[attribute_index].capitalize}", feature_ptr, j)
+          end
+
+          geom_ptr = FFI::OGR::API.OGR_F_GetGeometryRef(feature_ptr)
+          geom_ptr.autorelease = false
+          FFI::OGR::API.OGR_G_FlattenTo2D(geom_ptr)
+          geom_type = FFI::OGR::API.OGR_G_GetGeometryType(geom_ptr)
+
+          case geom_type
+          when :wkbPoint
+            values[i] = collect_point_values(geom_ptr, field_values)
+            i += 1
+          when :wkbLineString, :wkbLinearRing
+            extract_ring_points(geom_ptr, x_ptr, y_ptr) do |points|
+              values[i] = points.push(*field_values)
+              i += 1
+            end
+          when :wkbPolygon
+            exterior_ring_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(geom_ptr, 0)
+
+            extract_ring_points(exterior_ring_ptr, x_ptr, y_ptr) do |points|
+              values[i] = points.push(*field_values)
+              i += 1
+            end
+
+            count = FFI::OGR::API.OGR_G_GetGeometryCount(geom_ptr)
+            next if count > 1
+
+            count.times do |ring_num|
+              next if ring_num.zero?
+              ring_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(geom_ptr, ring_num)
+
+              extract_ring_points(ring_ptr, x_ptr, y_ptr) do |points|
+                values[i] = points.push(*field_values)
+                i += 1
+              end
+            end
+          when :wkbMultiPoint, :wkbMultiLineString
+            count = FFI::OGR::API.OGR_G_GetGeometryCount(geom_ptr)
+
+            count.times do |geom_num|
+              ring_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(geom_ptr, geom_num)
+
+              extract_ring_points(ring_ptr, x_ptr, y_ptr) do |points|
+                values[i] = points.push(*field_values)
+                i += 1
+              end
+            end
+          when :wkbMultiPolygon
+            polygon_count = FFI::OGR::API.OGR_G_GetGeometryCount(geom_ptr)
+
+            polygon_count.times do |polygon_num|
+              polygon_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(geom_ptr, polygon_num)
+              polygon_ptr.autorelease = false
+              exterior_ring_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(polygon_ptr, 0)
+              exterior_ring_ptr.autorelease = false
+
+              extract_ring_points(exterior_ring_ptr, x_ptr, y_ptr) do |points|
+                values[i] = points.push(*field_values)
+                i += 1
+              end
+
+              count = FFI::OGR::API.OGR_G_GetGeometryCount(polygon_ptr)
+              next if count > 1
+
+              count.times do |ring_num|
+                next if ring_num.zero?
+                ring_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(polygon_ptr, ring_num)
+                ring_ptr.autorelease = false
+
+                extract_ring_points(ring_ptr, x_ptr, y_ptr) do |points|
+                  values[i] = points.push(*field_values)
+                  i += 1
+                end
+              end
+            end
+          else raise OGR::UnsupportedGeometryType,
+            "Not sure how to extract point_values for a #{geom_type}"
+          end
         end
 
-        @features = feature_list
+        log "#point_values took #{Time.now - start}s"
+
+        values
       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
+      # Iterates through features to see if any of them are 3d.
+      #
+      # @return [Boolean]
+      def any_geometries_with_z?
+        found_z_geom = false
+
+        each_feature_pointer do |feature_ptr|
+          break if found_z_geom
+          geom_ptr = FFI::OGR::API.OGR_F_GetGeometryRef(feature_ptr)
+          geom_ptr.autorelease = false
+          coordinate_dimension = FFI::OGR::API.OGR_G_GetCoordinateDimension(geom_ptr)
+          found_z_geom = coordinate_dimension == 3
+        end
 
-        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)
+        feature.destroy! if feature.c_pointer
 
-        geometry.convex_hull
+        found_z_geom
       end
 
       # @return [Hash]
@@ -38,7 +236,7 @@ module OGR
             extent: extent.as_json(options),
             feature_count: feature_count,
             feature_definition: feature_definition.as_json(options),
-            features: features.map(&:as_json),
+            features: each_feature.map { |f| f.as_json(options) },
             fid_column: fid_column,
             geometry_column: geometry_column,
             geometry_type: geometry_type,
@@ -54,6 +252,33 @@ module OGR
       def to_json(options = nil)
         as_json(options).to_json
       end
+
+      private
+
+      # @param geometry_ptr [FFI::Pointer]
+      # @param field_values [Array]
+      # @return [Array]
+      def collect_point_values(geometry_ptr, field_values)
+        [FFI::OGR::API.OGR_G_GetX(geometry_ptr, 0), FFI::OGR::API.OGR_G_GetY(geometry_ptr, 0), *field_values]
+      end
+
+      # @param ring_ptr [FFI::Pointer] Pointer to the LineString/LinearRing to
+      #   extract points from.
+      # @param x_ptr [FFI::Pointer] Pointer to use for writing the x value to.
+      # @param y_ptr [FFI::Pointer] Pointer to use for writing the y value to.
+      # @yieldparam [Array<Float>] (x, y)
+      def extract_ring_points(ring_ptr, x_ptr, y_ptr)
+        point_count = FFI::OGR::API.OGR_G_GetPointCount(ring_ptr)
+
+        point_count.times do |point_num|
+          FFI::OGR::API.OGR_G_GetPoint(ring_ptr, point_num, x_ptr, y_ptr, nil)
+
+          yield [x_ptr.read_double, y_ptr.read_double]
+
+          x_ptr.clear
+          y_ptr.clear
+        end
+      end
     end
   end
 end

data/lib/ogr/layer_mixins/ogr_feature_methods.rb

@@ -1,6 +1,3 @@
-require_relative '../feature'
-require_relative '../feature_definition'
-
 module OGR
   module LayerMixins
     module OGRFeatureMethods
@@ -14,7 +11,7 @@ module OGR
         # This object should not be modified.
         OGR::FeatureDefinition.new(feature_defn_pointer)
       end
-      alias_method :feature_definition, :definition
+      alias feature_definition definition
 
       # Adds the new OGR::Feature to the Layer. The feature should have been
       # created using the Layer's FeatureDefintion.
@@ -27,7 +24,7 @@ module OGR
       # @return [Boolean]
       def create_feature(feature)
         unless can_sequential_write?
-          fail OGR::UnsupportedOperation, 'This layer does not support feature creation.'
+          raise OGR::UnsupportedOperation, 'This layer does not support feature creation.'
         end
 
         ogr_err = FFI::OGR::API.OGR_L_CreateFeature(@c_pointer, feature.c_pointer)
@@ -43,7 +40,7 @@ module OGR
       #   does not exist.
       def delete_feature(feature_id)
         unless can_delete_feature?
-          fail OGR::UnsupportedOperation, 'This layer does not support feature deletion.'
+          raise OGR::UnsupportedOperation, 'This layer does not support feature deletion.'
         end
 
         ogr_err = FFI::OGR::API.OGR_L_DeleteFeature(@c_pointer, feature_id)
@@ -65,11 +62,11 @@ module OGR
       # @param new_feature [OGR::Feature, FFI::Pointer]
       def feature=(new_feature)
         unless can_random_write?
-          fail OGR::UnsupportedOperation, '#feature= not supported by this Layer'
+          raise 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?
+        raise OGR::InvalidFeature if new_feature_ptr.nil? || new_feature_ptr.null?
 
         ogr_err = FFI::OGR::API.OGR_L_SetFeature(@c_pointer, new_feature_ptr)
 
@@ -81,7 +78,7 @@ module OGR
       # @return [OGR::Feature, nil]
       def feature(index)
         unless can_random_read?
-          fail OGR::UnsupportedOperation, '#feature(index) not supported by this Layer'
+          raise OGR::UnsupportedOperation, '#feature(index) not supported by this Layer'
         end
 
         feature_pointer = FFI::OGR::API.OGR_L_GetFeature(@c_pointer, index)
@@ -94,10 +91,13 @@ module OGR
       # current spatial filter will be returned.  Use +reset_reading+ to start at
       # the beginning again.
       #
+      # NOTE: You *must* call {{OGR::Feature#destroy!}} on the returned feature,
+      # otherwise expect segfaults.
+      #
       # @return [OGR::Feature, nil]
       def next_feature
         feature_pointer = FFI::OGR::API.OGR_L_GetNextFeature(@c_pointer)
-        return nil if feature_pointer.null?
+        return if feature_pointer.null?
 
         OGR::Feature.new(feature_pointer)
       end
@@ -111,7 +111,7 @@ module OGR
 
         ogr_err.handle_result "Unable to set next feature index to #{feature_index}"
       end
-      alias_method :set_next_by_index, :next_feature_index=
+      alias set_next_by_index next_feature_index=
 
       # @return [Fixnum]
       def features_read

data/lib/ogr/layer_mixins/ogr_field_methods.rb

@@ -1,8 +1,3 @@
-require_relative '../field_definition'
-require_relative '../field'
-require_relative '../geometry_field_definition'
-require_relative '../../ffi/ogr/api'
-
 module OGR
   module LayerMixins
     module OGRFieldMethods
@@ -16,7 +11,7 @@ module OGR
       # @return [Boolean]
       def create_field(field_definition, approx_ok = false)
         unless can_create_field?
-          fail OGR::UnsupportedOperation, 'This layer does not support field creation.'
+          raise OGR::UnsupportedOperation, 'This layer does not support field creation.'
         end
 
         field_definition_ptr = GDAL._pointer(OGR::FieldDefinition, field_definition)
@@ -30,7 +25,7 @@ module OGR
       # @return +true+ if successful, otherwise raises an OGR exception.
       def delete_field(field_id)
         unless can_delete_field?
-          fail OGR::UnsupportedOperation, 'This driver does not support field deletion.'
+          raise OGR::UnsupportedOperation, 'This driver does not support field deletion.'
         end
 
         ogr_err = FFI::OGR::API.OGR_L_DeleteField(@c_pointer, field_id)
@@ -43,7 +38,7 @@ module OGR
       # @return [Boolean]
       def reorder_fields(*new_order)
         unless can_reorder_fields?
-          fail OGR::UnsupportedOperation, 'This driver does not support field reordering.'
+          raise OGR::UnsupportedOperation, 'This driver does not support field reordering.'
         end
 
         return false if new_order.empty?
@@ -62,7 +57,7 @@ module OGR
       # @param new_position [Fixnum]
       def reorder_field(old_position, new_position)
         unless can_reorder_fields?
-          fail OGR::UnsupportedOperation, 'This driver does not support field reordering.'
+          raise OGR::UnsupportedOperation, 'This driver does not support field reordering.'
         end
 
         ogr_err = FFI::OGR::API.OGR_L_ReorderField(@c_pointer, old_position, new_position)
@@ -77,7 +72,7 @@ module OGR
       #   ALTER_WIDTH_PRECISION_FLAG, or ALTER_ALL_FLAG.
       def alter_field_definition(field_index, new_field_definition, flags)
         unless can_alter_field_definition?
-          fail OGR::UnsupportedOperation, 'This layer does not support field definition altering.'
+          raise OGR::UnsupportedOperation, 'This layer does not support field definition altering.'
         end
 
         new_field_definition_ptr = GDAL._pointer(OGR::FieldDefinition, new_field_definition)
@@ -112,7 +107,7 @@ module OGR
       # @return [Boolean]
       def create_geometry_field(geometry_field_def, approx_ok = false)
         unless can_create_geometry_field?
-          fail OGR::UnsupportedOperation, 'This layer does not support geometry field creation'
+          raise OGR::UnsupportedOperation, 'This layer does not support geometry field creation'
         end
 
         geometry_field_definition_ptr = GDAL._pointer(OGR::GeometryFieldDefinition, geometry_field_def)

data/lib/ogr/layer_mixins/ogr_layer_method_methods.rb

@@ -20,8 +20,8 @@ module OGR
       #   that will be created from the fields of the input Layer.
       # @option options [String] method_prefix Set a prefix for the field names
       #   that will be created from the fields of the method Layer.
-      def clip(method_layer, **options, &progress)
-        run_layer_method(:OGR_L_Clip, method_layer, **options, &progress)
+      def clip(method_layer, output_layer, **options, &progress)
+        run_layer_method(:OGR_L_Clip, method_layer, output_layer, **options, &progress)
       end
 
       # Remove areas in this layer that are covered by the method layer.
@@ -40,8 +40,8 @@ module OGR
       #   that will be created from the fields of the input Layer.
       # @option options [String] method_prefix Set a prefix for the field names
       #   that will be created from the fields of the method Layer.
-      def erase(method_layer, **options, &progress)
-        run_layer_method(:OGR_L_Erase, method_layer, **options, &progress)
+      def erase(method_layer, output_layer, **options, &progress)
+        run_layer_method(:OGR_L_Erase, method_layer, output_layer, **options, &progress)
       end
 
       # The result layer contains features whose geometries represent areas that
@@ -58,8 +58,8 @@ module OGR
       #   that will be created from the fields of the input Layer.
       # @option options [String] method_prefix Set a prefix for the field names
       #   that will be created from the fields of the method Layer.
-      def identity(method_layer, **options, &progress)
-        run_layer_method(:OGR_L_Identity, method_layer, **options, &progress)
+      def identity(method_layer, output_layer, **options, &progress)
+        run_layer_method(:OGR_L_Identity, method_layer, output_layer, **options, &progress)
       end
 
       # Intersection of this layer and +method_layer+.
@@ -74,8 +74,8 @@ module OGR
       #   that will be created from the fields of the input Layer.
       # @option options [String] method_prefix Set a prefix for the field names
       #   that will be created from the fields of the method Layer.
-      def intersection(method_layer, **options, &progress)
-        run_layer_method(:OGR_L_Intersection, method_layer, **options, &progress)
+      def intersection(method_layer, output_layer, **options, &progress)
+        run_layer_method(:OGR_L_Intersection, method_layer, output_layer, **options, &progress)
       end
 
       # The result layer contains features whose geometries represent areas that
@@ -95,8 +95,8 @@ module OGR
       #   that will be created from the fields of the input Layer.
       # @option options [String] method_prefix Set a prefix for the field names
       #   that will be created from the fields of the method Layer.
-      def symmetrical_difference(method_layer, **options, &progress)
-        run_layer_method(:OGR_L_SymDifference, method_layer, **options, &progress)
+      def symmetrical_difference(method_layer, output_layer, **options, &progress)
+        run_layer_method(:OGR_L_SymDifference, method_layer, output_layer, **options, &progress)
       end
 
       # The result layer contains features whose geometries represent areas that
@@ -115,8 +115,8 @@ module OGR
       #   that will be created from the fields of the input Layer.
       # @option options [String] method_prefix Set a prefix for the field names
       #   that will be created from the fields of the method Layer.
-      def union(method_layer, **options, &progress)
-        run_layer_method(:OGR_L_Union, method_layer, **options, &progress)
+      def union(method_layer, output_layer, **options, &progress)
+        run_layer_method(:OGR_L_Union, method_layer, output_layer, **options, &progress)
       end
 
       # Update this layer with features from the update layer. The result layer
@@ -136,18 +136,18 @@ module OGR
       #   that will be created from the fields of the input Layer.
       # @option options [String] method_prefix Set a prefix for the field names
       #   that will be created from the fields of the method Layer.
-      def update(method_layer, **options, &progress)
-        run_layer_method(:OGR_L_Update, method_layer, **options, &progress)
+      def update(method_layer, output_layer, **options, &progress)
+        run_layer_method(:OGR_L_Update, method_layer, output_layer, **options, &progress)
       end
 
       private
 
-      def run_layer_method(method_name, method_layer, **options, &progress)
+      def run_layer_method(method_name, method_layer, output_layer, **options, &progress)
         method_layer_ptr = GDAL._pointer(OGR::Layer, method_layer)
         options_ptr = GDAL::Options.pointer(options)
-        result_layer_ptr = FFI::MemoryPointer.new(:OGRLayerH)
+        result_layer_ptr = output_layer.c_pointer
 
-        ogr_err = FFI::GDAL.send(method_name,
+        ogr_err = FFI::OGR::API.send(method_name,
           @c_pointer,
           method_layer_ptr,
           result_layer_ptr,
@@ -156,7 +156,7 @@ module OGR
           nil)
         ogr_err.handle_result
 
-        OGR::Layer.new(result_layer_ptr)
+        output_layer
       end
     end
   end

data/lib/ogr/layer_mixins/ogr_query_filter_methods.rb

@@ -1,5 +1,3 @@
-require_relative '../geometry'
-
 module OGR
   module LayerMixins
     module OGRQueryFilterMethods

data/lib/ogr/layer_mixins/ogr_sql_methods.rb

@@ -36,7 +36,7 @@ module OGR
       # @return [Boolean]
       def transact
         unless supports_transactions?
-          fail OGR::UnsupportedOperation, 'This layer does not support transactions.'
+          raise OGR::UnsupportedOperation, 'This layer does not support transactions.'
         end
 
         ogr_err = yield

data/lib/ogr/spatial_reference.rb

@@ -1,5 +1,5 @@
-require_relative '../ffi/ogr'
-require_relative '../gdal/logger'
+require_relative '../ogr'
+require_relative '../gdal'
 require_relative 'spatial_reference_extensions'
 require_relative 'spatial_reference_mixins/coordinate_system_getter_setters'
 require_relative 'spatial_reference_mixins/exporters'
@@ -36,31 +36,21 @@ module OGR
       pointer_array = methods_ptr_ptr.get_array_of_pointer(0, count)
 
       list = pointer_array.map(&:read_string).sort
-      list.map! { |l| l.gsub(/_/, ' ') } if strip_underscores
 
-      list
+      strip_underscores ? list.map! { |l| l.tr('_', ' ') } : list
     end
 
     # @param projection_method [String] One of
     #   OGR::SpatialReference.projection_methods.
     # @return [Hash{parameter => Array<String>, user_visible_name => String}]
     def self.parameter_list(projection_method)
-      name_ptr = FFI::MemoryPointer.new(:string)
-      name_ptr_ptr = FFI::MemoryPointer.new(:pointer)
-      name_ptr_ptr.write_pointer(name_ptr)
-
-      params_ptr_ptr = FFI::OGR::SRSAPI.OPTGetParameterList(projection_method,
-        name_ptr_ptr)
+      name_ptr_ptr = GDAL._pointer_pointer(:string)
+      params_ptr_ptr = FFI::OGR::SRSAPI.OPTGetParameterList(projection_method, name_ptr_ptr)
       count = FFI::CPL::String.CSLCount(params_ptr_ptr)
 
       # For some reason #get_array_of_string leaves off the first 6.
       pointer_array = params_ptr_ptr.get_array_of_pointer(0, count)
-
-      name = if name_ptr_ptr.read_pointer.null?
-               nil
-             else
-               name_ptr_ptr.read_pointer.read_string
-             end
+      name = GDAL._read_pointer_pointer_safely(name_ptr_ptr, :string)
 
       {
         parameters: pointer_array.map(&:read_string).sort,
@@ -73,14 +63,8 @@ module OGR
     # @param projection_method [String]
     # @param parameter_name [String]
     def self.parameter_info(projection_method, parameter_name)
-      name_ptr = FFI::MemoryPointer.new(:string)
-      name_ptr_ptr = FFI::MemoryPointer.new(:pointer)
-      name_ptr_ptr.write_pointer(name_ptr)
-
-      type_ptr = FFI::MemoryPointer.new(:string)
-      type_ptr_ptr = FFI::MemoryPointer.new(:pointer)
-      type_ptr_ptr.write_pointer(type_ptr)
-
+      name_ptr_ptr = GDAL._pointer_pointer(:string)
+      type_ptr_ptr = GDAL._pointer_pointer(:string)
       default_value_ptr = FFI::MemoryPointer.new(:double)
 
       result = FFI::OGR::SRSAPI.OPTGetParameterInfo(projection_method, parameter_name,
@@ -88,17 +72,8 @@ module OGR
 
       return {} unless result
 
-      name = if name_ptr_ptr.read_pointer.null?
-               nil
-             else
-               name_ptr_ptr.read_pointer.read_string
-             end
-
-      type = if type_ptr_ptr.read_pointer.null?
-               nil
-             else
-               type_ptr_ptr.read_pointer.read_string
-             end
+      name = GDAL._read_pointer_pointer_safely(name_ptr_ptr, :string)
+      type = GDAL._read_pointer_pointer_safely(name_ptr_ptr, :string)
 
       {
         type: type,
@@ -144,7 +119,7 @@ module OGR
 
       return if @c_pointer && !@c_pointer.null?
 
-      fail OGR::CreateFailure, 'Unable to create SpatialReference.'
+      raise OGR::CreateFailure, 'Unable to create SpatialReference.'
     end
 
     def destroy!
@@ -177,7 +152,7 @@ module OGR
     # @return [Boolean]
     def copy_geog_cs_from(other_spatial_ref)
       other_spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, other_spatial_ref)
-      fail OGR::InvalidSpatialReference if other_spatial_ref_ptr.nil? || other_spatial_ref_ptr.null?
+      raise OGR::InvalidSpatialReference if other_spatial_ref_ptr.nil? || other_spatial_ref_ptr.null?
 
       ogr_err = FFI::OGR::SRSAPI.OSRCopyGeogCSFrom(@c_pointer, other_spatial_ref_ptr)