rgeo 2.4.0 → 3.1.0

data/ext/geos_c_impl/factory.h

@@ -5,19 +5,19 @@
 #ifndef RGEO_GEOS_FACTORY_INCLUDED
 #define RGEO_GEOS_FACTORY_INCLUDED
 
-#include <ruby.h>
 #include <geos_c.h>
+#include <ruby.h>
 
 RGEO_BEGIN_C
 
 /*
   Wrapped structure for Factory objects.
-  A factory encapsulates the GEOS context, and GEOS serializer settings.
+  A factory encapsulates GEOS serializer settings.
   It also stores the SRID for all geometries created by this factory,
   and the resolution for buffers created for this factory's geometries.
 */
-typedef struct {
-  GEOSContextHandle_t geos_context;
+typedef struct
+{
   GEOSWKTReader* wkt_reader;
   GEOSWKBReader* wkb_reader;
   GEOSWKTWriter* wkt_writer;
@@ -30,19 +30,46 @@ typedef struct {
   GEOSWKBReader* marshal_wkb_reader;
   GEOSWKTWriter* psych_wkt_writer;
   GEOSWKBWriter* marshal_wkb_writer;
-  VALUE proj4_obj;
   VALUE coord_sys_obj;
   int flags;
   int srid;
   int buffer_resolution;
 } RGeo_FactoryData;
 
-#define RGEO_FACTORYFLAGS_LENIENT_MULTIPOLYGON 1
-#define RGEO_FACTORYFLAGS_SUPPORTS_Z 2
-#define RGEO_FACTORYFLAGS_SUPPORTS_M 4
-#define RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M 6
-#define RGEO_FACTORYFLAGS_PREPARE_HEURISTIC 8
-
+/*
+  Flags that are used to pass options when creating a factory.
+  They are available in ruby under RGeo::Geos::CAPIFactory::FLAG_name
+  where name is the name below without the RGEO_FACTORYFLAGS_ prefix.
+ */
+#define RGEO_FACTORYFLAGS_SUPPORTS_Z 0b0010
+#define RGEO_FACTORYFLAGS_SUPPORTS_M 0b0100
+#define RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M                                      \
+  (RGEO_FACTORYFLAGS_SUPPORTS_Z | RGEO_FACTORYFLAGS_SUPPORTS_M)
+#define RGEO_FACTORYFLAGS_PREPARE_HEURISTIC 0b1000
+
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.supports_z? -> true or false
+ */
+VALUE
+method_factory_supports_z_p(VALUE self);
+
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.supports_m? -> true or false
+ */
+VALUE
+method_factory_supports_m_p(VALUE self);
+
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.supports_z_or_m? -> true or false
+ */
+VALUE
+method_factory_supports_z_or_m_p(VALUE self);
+
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.prepare_heuristic? -> true or false
+ */
+VALUE
+method_factory_prepare_heuristic_p(VALUE self);
 
 /*
   Wrapped structure for Geometry objects.
@@ -57,47 +84,44 @@ typedef struct {
   in Line objects, which have no GEOS type). Any array element, or the
   array itself, could be Qnil, indicating fall back to the default
   inferred from the GEOS type.
-
-  The GEOS context handle is also included here. Ideally, it would be
-  available by following the factory reference and getting it from the
-  factory data. However, one use case is in the destroy_geometry_func
-  in factory.c, and Rubinius 1.1.1 seems to crash when you try to
-  evaluate a DATA_PTR from that function, so we copy the context handle
-  here so the destroy_geometry_func can get to it.
 */
-typedef struct {
-  GEOSContextHandle_t geos_context;
+typedef struct
+{
   GEOSGeometry* geom;
   const GEOSPreparedGeometry* prep;
   VALUE factory;
   VALUE klasses;
 } RGeo_GeometryData;
 
-
 // Data types which indicate how RGeo types should be managed by Ruby.
 extern const rb_data_type_t rgeo_factory_type;
 
 extern const rb_data_type_t rgeo_geometry_type;
 
-
 // Convenient macros for checking the type of data from Ruby
-#define RGEO_FACTORY_TYPEDDATA_P(object) (_RGEO_TYPEDDATA_P(object, &rgeo_factory_type))
-#define RGEO_GEOMETRY_TYPEDDATA_P(object) (_RGEO_TYPEDDATA_P(object, &rgeo_geometry_type))
+#define RGEO_FACTORY_TYPEDDATA_P(object)                                       \
+  (_RGEO_TYPEDDATA_P(object, &rgeo_factory_type))
+#define RGEO_GEOMETRY_TYPEDDATA_P(object)                                      \
+  (_RGEO_TYPEDDATA_P(object, &rgeo_geometry_type))
 
-#define _RGEO_TYPEDDATA_P(object, data_type) (TYPE(object) == T_DATA && RTYPEDDATA(object)->typed_flag == 1 && RTYPEDDATA(object)->type == data_type)
+#define _RGEO_TYPEDDATA_P(object, data_type)                                   \
+  (RB_TYPE_P(object, T_DATA) && RTYPEDDATA_P(object) &&                        \
+   RTYPEDDATA_TYPE(object) == data_type)
 
 // Returns the RGeo_FactoryData* given a ruby Factory object
-#define RGEO_FACTORY_DATA_PTR(factory) ((RGeo_FactoryData*)RTYPEDDATA_DATA(factory))
+#define RGEO_FACTORY_DATA_PTR(factory)                                         \
+  ((RGeo_FactoryData*)RTYPEDDATA_DATA(factory))
 
 // Returns the RGeo_GeometryData* given a ruby Geometry object
-#define RGEO_GEOMETRY_DATA_PTR(geometry) ((RGeo_GeometryData*)RTYPEDDATA_DATA(geometry))
-
+#define RGEO_GEOMETRY_DATA_PTR(geometry)                                       \
+  ((RGeo_GeometryData*)RTYPEDDATA_DATA(geometry))
 
 /*
   Initializes the factory module. This should be called first in the
   initialization process.
 */
-void rgeo_init_geos_factory();
+void
+rgeo_init_geos_factory();
 
 /*
   Given a GEOS geometry handle, wraps it in a ruby Geometry object of the
@@ -111,13 +135,17 @@ void rgeo_init_geos_factory();
   classes for the elements of the collection.
   Returns Qnil if the wrapping failed for any reason.
 */
-VALUE rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass);
+VALUE
+rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass);
 
 /*
   Same as rgeo_wrap_geos_geometry except that it wraps a clone of the
   given geom, so the original geom doesn't change ownership.
 */
-VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VALUE klass);
+VALUE
+rgeo_wrap_geos_geometry_clone(VALUE factory,
+                              const GEOSGeometry* geom,
+                              VALUE klass);
 
 /*
   Gets the GEOS geometry for a given ruby Geometry object. If the given
@@ -126,8 +154,18 @@ VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VAL
   specified by an appropriate feature module. Passing Qnil for the type
   disables this auto-cast. The returned GEOS geometry is owned by rgeo,
   and you should not dispose it or take ownership of it yourself.
+
+  The state parameter is given to follow `rb_protect*` ruby methods: this
+  method calls `#cast`, and this call may raise. if it does raise, state
+  will be set to a non-zero value, and you'll have access to the error
+  in `rb_errinfo()`. IT IS THE CALLER'S RESPONSIBILITY TO PROPAGATE THE
+  ERROR. You could also discard the error with `rb_set_errinfo(Qnil)`,
+  this will just ignore the error altogether. The error can be raised
+  with `rb_jump_tag(state)` which is helpful if you need to free data
+  before you raise the error.
 */
-const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type);
+const GEOSGeometry*
+rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type, int* state);
 
 /*
   Gets a GEOS geometry for a given ruby Geometry object. You must provide
@@ -144,50 +182,60 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALU
   result of this function to build a GEOS-backed clone of the original
   geometry, or to include the given geometry in a collection while keeping
   the klasses intact.
+
+  The state parameter is given to follow `rb_protect*` ruby methods: this
+  method calls `#cast`, and this call may raise. if it does raise, state
+  will be set to a non-zero value, and you'll have access to the error
+  in `rb_errinfo()`. IT IS THE CALLER'S RESPONSIBILITY TO PROPAGATE THE
+  ERROR. You could also discard the error with `rb_set_errinfo(Qnil)`,
+  this will just ignore the error altogether. The error can be raised
+  with `rb_jump_tag(state)` which is helpful if you need to free data
+  before you raise the error.
 */
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses);
+GEOSGeometry*
+rgeo_convert_to_detached_geos_geometry(VALUE obj,
+                                       VALUE factory,
+                                       VALUE type,
+                                       VALUE* klasses,
+                                       int* state);
 
 /*
   Returns 1 if the given ruby object is a GEOS Geometry implementation,
   or 0 if not.
 */
-char rgeo_is_geos_object(VALUE obj);
+char
+rgeo_is_geos_object(VALUE obj);
 
 /*
   Raises a rgeo error if the object is not a GEOS Geometry implementation.
 */
-void rgeo_check_geos_object(VALUE obj);
+void
+rgeo_check_geos_object(VALUE obj);
 
 /*
   Gets the underlying GEOS geometry for a given ruby object. Returns NULL
   if the given ruby object is not a GEOS geometry wrapper.
 */
-const GEOSGeometry* rgeo_get_geos_geometry_safe(VALUE obj);
-
-/*
-  Compares the coordinate sequences for two given GEOS geometries.
-  The two given geometries MUST be of types backed directly by
-  coordinate sequences-- i.e. points or line strings.
-  Returns Qtrue if the two coordinate sequences are equal, Qfalse
-  if they are inequal, or Qnil if an error occurs.
-*/
-VALUE rgeo_geos_coordseqs_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
+const GEOSGeometry*
+rgeo_get_geos_geometry_safe(VALUE obj);
 
 /*
   Compares the ruby classes and geometry factories of the two given ruby
   objects. Returns Qtrue if everything is equal (that is, the two objects
   are of the same type and factory), or Qfalse otherwise.
 */
-VALUE rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2);
+VALUE
+rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2);
 
 /*
   A tool for building up hash values.
-  You must pass in the context, a geos geometry, and a seed hash.
+  You must pass a geos geometry and a seed hash.
   Returns an updated hash.
   This call is useful in sequence, and should be bracketed by calls to
   rb_hash_start and rb_hash_end.
 */
-st_index_t rgeo_geos_coordseq_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
+st_index_t
+rgeo_geos_coordseq_hash(const GEOSGeometry* geom, st_index_t hash);
 
 /*
   A tool for building up hash values.
@@ -196,13 +244,8 @@ st_index_t rgeo_geos_coordseq_hash(GEOSContextHandle_t context, const GEOSGeomet
   This call is useful in sequence, and should be bracketed by calls to
   rb_hash_start and rb_hash_end.
 */
-st_index_t rgeo_geos_objbase_hash(VALUE factory, VALUE type_module, st_index_t hash);
-
-/*
-  Internal tool for creating simple (FNV-1A 32 bit) hashes.
-*/
-st_index_t rgeo_internal_memhash(const void* ptr, long len);
-
+st_index_t
+rgeo_geos_objbase_hash(VALUE factory, VALUE type_module, st_index_t hash);
 
 RGEO_END_C