filegdb 0.0.2 → 0.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDQ3ODRmZTVmYmQ1NjI1Mjc5OGJlZWQwNDkzNjg2ZWIwYmU0NzNlYw==
+    MzM1MjMzMTkwNDc3MjEyNzU1Y2U5ZmY2ODk0NGZhZTk4Y2VhY2E3NQ==
   data.tar.gz: !binary |-
-    YTA1Y2FiMjIzMTBhYWNiYTI5NTllOWZhNTQ2OWNhYzkzYzc1NjdmNw==
+    NzRmMDRjY2U3MzZlZTA5NDVmYzdiNjA4MTUyMDc5ZjViMGUyMWNkZQ==
 SHA512:
   metadata.gz: !binary |-
-    OTUxMjlkMjM0MjNiYTkxZjkyNTVlZGZhNThhZjhhN2IwZTFjMTc5MzdlN2Zj
-    Yjc4N2EwN2IxMmQ3NDJhMWFiOWQxMzIwNzY2Nzk0YTc4ZWE2NDMyNjA4ZmFi
-    YWU5Y2VlYmVkNTc1N2ZmNDAxZjM2MTkwYTRjZDZkN2RjNzQ0MGM=
+    Y2UzOTVhMzMzZjllODJlZTE2YzA3M2JiZWEzYmM3MDQwMzg2ZGRjZDUxNTdh
+    YjZjOTRiZDA3OGEwODJiN2MzZDUxMzgyYTEzZGRhMDUxNDVlZTBmNDVhMWFh
+    ODk0OTEzYmI5MzdhMWQ0YzRhNzk3MmU3YmYzMjRiZTkzZjcyYzQ=
   data.tar.gz: !binary |-
-    N2EyOWM2ZTE2MTdlYTY5ODljMDY0NTRlYzU5ZTFlZGQ2ZmUwOTgxMDg4Njkx
-    OWRjYzk5NmY2ZTg1M2RiODg1OTA0MjZkNWQ2NDRlNTQ3MWQ0ODRiYzQ0NGY1
-    Y2QwNGMxNWFkMWQwOWJlMzlmNjVlOTRmYjY0NTFmZDkzMjY4ZTc=
+    MWZmNjNhNjE4N2ZhNmIwYTk2NDk5NWI4MGIwYjZlMGNjMzMxZDE0MGE5Mzgz
+    M2VlOWEyY2MxNDQ4ZDc3YTM3YmM0OTQ1OWExNzMxNWU5NGU5OWE2ZGVmMTc3
+    ZmUzM2QyNTFmNGFiZDg1NGExYWI5OWQ2ZDNjZTJkYjExNTM2YmY=

data/ext/filegdb/double_primitive.cpp

@@ -0,0 +1,35 @@
+
+#include "double_primitive.hpp"
+
+namespace filegdb {
+
+VALUE double_primitive::_klass = Qnil;
+
+VALUE double_primitive::klass() {
+  return double_primitive::_klass;
+}
+
+VALUE double_primitive::set_value(VALUE self, VALUE value) {
+  CHECK_ARGUMENT_FLOAT(value);
+
+  double_primitive *prim = unwrap(self);
+
+  *prim->_value = NUM2DBL(value);
+
+  return prim->wrapped();
+}
+
+VALUE double_primitive::get_value(VALUE self) {
+  double_primitive *prim = unwrap(self);
+  return rb_float_new(*prim->_value);
+}
+
+void double_primitive::define(VALUE module)
+{
+  double_primitive::_klass = rb_define_class_under(module, "DoublePrimitive", rb_cObject);
+  base::define(double_primitive::_klass, true);
+  rb_define_method(double_primitive::_klass, "value", FGDB_METHOD(double_primitive::get_value), 0);
+  rb_define_method(double_primitive::_klass, "value=", FGDB_METHOD(double_primitive::set_value), 1);
+}
+
+}

data/ext/filegdb/double_primitive.hpp

@@ -0,0 +1,29 @@
+#ifndef __FGDB_DOUBLE_PRIMITIVE_HPP__
+#define __FGDB_DOUBLE_PRIMITIVE_HPP__
+
+#include "filegdb.hpp"
+#include "base.hpp"
+#include "primitive.hpp"
+
+namespace filegdb {
+
+class double_primitive : public primitive<double, double_primitive> {
+public:
+  double_primitive() {}
+
+  double_primitive(double *value) : primitive(value) {}
+
+  virtual VALUE klass();
+
+  static VALUE _klass;
+
+  static void define(VALUE module);
+
+  static VALUE set_value(VALUE self, VALUE value);
+
+  static VALUE get_value(VALUE self);
+};
+
+}
+
+#endif

data/ext/filegdb/filegdb.cpp

@@ -9,9 +9,12 @@
 #include "shape_buffer.hpp"
 #include "point_shape_buffer.hpp"
 #include "multi_point_shape_buffer.hpp"
+#include "multi_part_shape_buffer.hpp"
 #include "point.hpp"
 #include "field_info.hpp"
 #include "spatial_reference.hpp"
+#include "integer_primitive.hpp"
+#include "double_primitive.hpp"
 
 VALUE cFileGDB;
 
@@ -25,7 +28,10 @@ extern "C" {
     filegdb::shape_buffer::define(cFileGDB);
     filegdb::point_shape_buffer::define(cFileGDB);
     filegdb::multi_point_shape_buffer::define(cFileGDB);
+    filegdb::multi_part_shape_buffer::define(cFileGDB);
     filegdb::field_info::define(cFileGDB);
     filegdb::spatial_reference::define(cFileGDB);
+    filegdb::integer_primitive::define(cFileGDB);
+    filegdb::double_primitive::define(cFileGDB);
   }
 }

data/ext/filegdb/integer_primitive.cpp

@@ -0,0 +1,36 @@
+
+#include "integer_primitive.hpp"
+
+namespace filegdb {
+
+VALUE integer_primitive::_klass = Qnil;
+
+VALUE integer_primitive::klass() {
+  return integer_primitive::_klass;
+}
+
+
+VALUE integer_primitive::set_value(VALUE self, VALUE value) {
+  CHECK_ARGUMENT_FIXNUM(value);
+
+  integer_primitive *prim = unwrap(self);
+
+  *prim->_value = FIX2INT(value);
+
+  return prim->wrapped();
+}
+
+VALUE integer_primitive::get_value(VALUE self) {
+  integer_primitive *prim = unwrap(self);
+  return INT2FIX(*prim->_value);
+}
+
+void integer_primitive::define(VALUE module)
+{
+  integer_primitive::_klass = rb_define_class_under(module, "IntegerPrimitive", rb_cObject);
+  base::define(integer_primitive::_klass, true);
+  rb_define_method(integer_primitive::_klass, "value", FGDB_METHOD(integer_primitive::get_value), 0);
+  rb_define_method(integer_primitive::_klass, "value=", FGDB_METHOD(integer_primitive::set_value), 1);
+}
+
+}

data/ext/filegdb/integer_primitive.hpp

@@ -0,0 +1,29 @@
+#ifndef __FGDB_INTEGER_PRIMITIVE_HPP__
+#define __FGDB_INTEGER_PRIMITIVE_HPP__
+
+#include "filegdb.hpp"
+#include "base.hpp"
+#include "primitive.hpp"
+
+namespace filegdb {
+
+class integer_primitive : public primitive<int, integer_primitive> {
+public:
+  integer_primitive() {}
+
+  integer_primitive(int *value) : primitive(value) {}
+
+  virtual VALUE klass();
+
+  static VALUE _klass;
+
+  static void define(VALUE module);
+
+  static VALUE set_value(VALUE self, VALUE value);
+
+  static VALUE get_value(VALUE self);
+};
+
+}
+
+#endif

data/ext/filegdb/multi_part_shape_buffer.cpp

@@ -0,0 +1,303 @@
+
+#include "point.hpp"
+#include "shape_buffer.hpp"
+#include "multi_part_shape_buffer.hpp"
+#include "integer_primitive.hpp"
+#include "double_primitive.hpp"
+
+namespace filegdb {
+
+VALUE multi_part_shape_buffer::_klass = Qnil;
+
+VALUE multi_part_shape_buffer::klass() {
+  return multi_part_shape_buffer::_klass;
+}
+
+VALUE multi_part_shape_buffer::setup(VALUE self, VALUE shapeType, VALUE numberOfParts, VALUE numberOfPoints) {
+  CHECK_ARGUMENT_FIXNUM(shapeType);
+  CHECK_ARGUMENT_FIXNUM(numberOfParts);
+  CHECK_ARGUMENT_FIXNUM(numberOfPoints);
+
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  ShapeType nshape_type = (ShapeType)FIX2INT(shapeType);
+
+  fgdbError hr = shape->value().Setup(nshape_type, FIX2INT(numberOfParts), FIX2INT(numberOfPoints));
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  return shape->wrapped();
+}
+
+VALUE multi_part_shape_buffer::get_points(VALUE self) {
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  Point *points = NULL;
+
+  fgdbError hr = shape->value().GetPoints(points);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  int numPoints = 0;
+
+  hr = shape->value().GetNumPoints(numPoints);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE arrayOfPoints = rb_ary_new();
+
+  for (int i = 0; i < numPoints; ++i) {
+    point *p = new point(&points[i]);
+    rb_ary_push(arrayOfPoints, p->wrapped());
+  }
+
+  return arrayOfPoints;
+}
+
+VALUE multi_part_shape_buffer::get_parts(VALUE self) {
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  int *parts = NULL;
+
+  fgdbError hr = shape->value().GetParts(parts);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  int numParts = 0;
+
+  hr = shape->value().GetNumParts(numParts);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE arrayOfParts = rb_ary_new();
+
+  for (int i = 0; i < numParts; ++i) {
+    integer_primitive *value = new integer_primitive(&parts[i]);
+    rb_ary_push(arrayOfParts, value->wrapped());
+  }
+
+  return arrayOfParts;
+}
+
+VALUE multi_part_shape_buffer::get_num_points(VALUE self) {
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  int numPoints = 0;
+
+  fgdbError hr = shape->value().GetNumPoints(numPoints);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  return INT2FIX(numPoints);
+}
+
+VALUE multi_part_shape_buffer::get_num_parts(VALUE self) {
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  int numParts = 0;
+
+  fgdbError hr = shape->value().GetNumParts(numParts);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  return INT2FIX(numParts);
+}
+
+VALUE multi_part_shape_buffer::get_zs(VALUE self)
+{
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  double *zValues;
+
+  fgdbError hr = shape->value().GetZs(zValues);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  int numPoints = 0;
+
+  hr = shape->value().GetNumPoints(numPoints);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE result = rb_ary_new();
+
+  for (int i = 0; i < numPoints; ++i) {
+    rb_ary_push(result, rb_float_new(zValues[i]));
+  }
+
+  return result;
+}
+
+VALUE multi_part_shape_buffer::get_ms(VALUE self)
+{
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  double *mValues;
+
+  fgdbError hr = shape->value().GetMs(mValues);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  int numPoints = 0;
+
+  hr = shape->value().GetNumPoints(numPoints);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE result = rb_ary_new();
+
+  for (int i = 0; i < numPoints; ++i) {
+    rb_ary_push(result, rb_float_new(mValues[i]));
+  }
+
+  return result;
+}
+
+VALUE multi_part_shape_buffer::get_ids(VALUE self)
+{
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  int *idValues;
+
+  fgdbError hr = shape->value().GetIDs(idValues);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  int numPoints = 0;
+
+  hr = shape->value().GetNumPoints(numPoints);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE result = rb_ary_new();
+
+  for (int i = 0; i < numPoints; ++i) {
+    rb_ary_push(result, INT2FIX(idValues[i]));
+  }
+
+  return result;
+}
+
+VALUE multi_part_shape_buffer::get_extent(VALUE self)
+{
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  double *extents = NULL;
+
+  fgdbError hr = shape->value().GetExtent(extents);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE result = rb_ary_new();
+
+  rb_ary_push(result, DBL2NUM(extents[0]));
+  rb_ary_push(result, DBL2NUM(extents[1]));
+  rb_ary_push(result, DBL2NUM(extents[2]));
+  rb_ary_push(result, DBL2NUM(extents[3]));
+
+  return result;
+}
+
+VALUE multi_part_shape_buffer::get_z_extent(VALUE self)
+{
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  double *extents = NULL;
+
+  fgdbError hr = shape->value().GetZExtent(extents);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE result = rb_ary_new();
+
+  rb_ary_push(result, DBL2NUM(extents[0]));
+  rb_ary_push(result, DBL2NUM(extents[1]));
+
+  return result;
+}
+
+VALUE multi_part_shape_buffer::get_m_extent(VALUE self)
+{
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  double *extents = NULL;
+
+  fgdbError hr = shape->value().GetMExtent(extents);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  VALUE result = rb_ary_new();
+
+  rb_ary_push(result, DBL2NUM(extents[0]));
+  rb_ary_push(result, DBL2NUM(extents[1]));
+
+  return result;
+}
+
+VALUE multi_part_shape_buffer::calculate_extent(VALUE self)
+{
+  multi_part_shape_buffer *shape = unwrap(self);
+
+  fgdbError hr = shape->value().CalculateExtent();
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  return Qnil;
+}
+
+void multi_part_shape_buffer::define(VALUE module)
+{
+  multi_part_shape_buffer::_klass = rb_define_class_under(module, "MultiPartShapeBuffer", shape_buffer::_klass);
+  base::define(multi_part_shape_buffer::_klass, true);
+  rb_define_method(multi_part_shape_buffer::_klass, "setup", FGDB_METHOD(multi_part_shape_buffer::setup), 3);
+  rb_define_method(multi_part_shape_buffer::_klass, "get_points", FGDB_METHOD(multi_part_shape_buffer::get_points), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "get_parts", FGDB_METHOD(multi_part_shape_buffer::get_parts), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "get_num_points", FGDB_METHOD(multi_part_shape_buffer::get_num_points), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "get_num_parts", FGDB_METHOD(multi_part_shape_buffer::get_num_parts), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "z", FGDB_METHOD(multi_part_shape_buffer::get_zs), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "m", FGDB_METHOD(multi_part_shape_buffer::get_ms), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "id", FGDB_METHOD(multi_part_shape_buffer::get_ids), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "get_extent", FGDB_METHOD(multi_part_shape_buffer::get_extent), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "get_z_extent", FGDB_METHOD(multi_part_shape_buffer::get_z_extent), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "get_m_extent", FGDB_METHOD(multi_part_shape_buffer::get_m_extent), 0);
+  rb_define_method(multi_part_shape_buffer::_klass, "calculate_extent", FGDB_METHOD(multi_part_shape_buffer::calculate_extent), 0);
+}
+
+}
+
+
+

data/ext/filegdb/multi_part_shape_buffer.hpp

@@ -0,0 +1,38 @@
+#ifndef __FGDB_MULTI_PART_SHAPE_BUFFER_HPP__
+#define __FGDB_MULTI_PART_SHAPE_BUFFER_HPP__
+
+#include "filegdb.hpp"
+#include "shape_buffer_base.hpp"
+
+namespace filegdb {
+  class multi_part_shape_buffer : public shape_buffer_base<multi_part_shape_buffer, MultiPartShapeBuffer> {
+  public:
+    static void define(VALUE module);
+
+    static VALUE setup(VALUE self, VALUE shapeType, VALUE numberOfParts, VALUE numberOfPoints);
+    static VALUE get_points(VALUE self);
+    static VALUE get_parts(VALUE self);
+    static VALUE get_num_points(VALUE self);
+    static VALUE get_num_parts(VALUE self);
+    static VALUE get_zs(VALUE self);
+    static VALUE get_ms(VALUE self);
+    static VALUE get_ids(VALUE self);
+    static VALUE get_extent(VALUE self);
+    static VALUE get_z_extent(VALUE self);
+    static VALUE get_m_extent(VALUE self);
+    static VALUE calculate_extent(VALUE self);
+
+    virtual VALUE klass();
+
+    static VALUE _klass;
+
+    virtual ~multi_part_shape_buffer() {};
+  };
+}
+
+#endif
+
+
+
+
+

data/ext/filegdb/primitive.hpp

@@ -0,0 +1,20 @@
+#ifndef __FGDB_PRIMITIVE_HPP__
+#define __FGDB_PRIMITIVE_HPP__
+
+#include "filegdb.hpp"
+
+namespace filegdb {
+  template<typename T, typename K> class primitive : public base<K> {
+  public:
+    primitive(T *value) : _value(value) {}
+
+    virtual ~primitive() {}
+
+  protected:
+    primitive() {}
+
+    T *_value;
+  };
+}
+
+#endif

data/lib/filegdb/version.rb

@@ -1,3 +1,3 @@
 module FileGDB
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/multi_part_shape_buffer_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+NUM_POINTS = 3
+NUM_PARTS  = 1
+
+describe 'MultiPartShapeBuffer' do
+  before(:each) do
+    @shape = FileGDB::MultiPartShapeBuffer.new
+    @shape.setup(15, NUM_PARTS, NUM_POINTS)
+  end
+
+  it 'sets up the geometry' do
+    lambda { @shape.setup(5, NUM_POINTS, NUM_PARTS) }.should_not raise_error
+  end
+
+  it 'gets the number of points' do
+    @shape.get_num_points.should eq(NUM_POINTS)
+  end
+
+  it 'gets the number of parts' do
+    @shape.get_num_parts.should eq(NUM_PARTS)
+  end
+
+  it 'gets the parts' do
+    @shape.get_parts.should have(1).item
+  end
+
+  it 'sets the parts' do
+    parts = @shape.get_parts
+    parts[0].value = 10
+    @shape.get_parts[0].value.should eq(10)
+  end
+
+  it 'gets the points' do
+    @shape.get_points.should have(3).items
+  end
+
+  it 'gets the z values' do
+    @shape.z.should have(3).items
+  end
+
+  it 'gets the m values' do
+    @shape.m.should have(3).items
+  end
+
+  it 'gets the id values' do
+    lambda { @shape.id }.should raise_error
+  end
+
+  it 'gets the extent' do
+    @shape.get_extent.should eq([0, 0, 0, 0])
+  end
+
+  it 'gets the z extent' do
+    @shape.get_z_extent.should eq([0, 0])
+  end
+
+  it 'gets the m extent' do
+    @shape.get_m_extent.should eq([0, 0])
+  end
+
+  it 'calculates the extent' do
+    lambda { @shape.calculate_extent }.should_not raise_error
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: filegdb
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Zac McCormick
@@ -68,6 +68,8 @@ files:
 - README.md
 - Rakefile
 - ext/filegdb/base.hpp
+- ext/filegdb/double_primitive.cpp
+- ext/filegdb/double_primitive.hpp
 - ext/filegdb/extconf.rb
 - ext/filegdb/field_info.cpp
 - ext/filegdb/field_info.hpp
@@ -88,12 +90,17 @@ files:
 - ext/filegdb/filegdb/lib/libfgdbunixrtl.so
 - ext/filegdb/geodatabase.cpp
 - ext/filegdb/geodatabase.hpp
+- ext/filegdb/integer_primitive.cpp
+- ext/filegdb/integer_primitive.hpp
+- ext/filegdb/multi_part_shape_buffer.cpp
+- ext/filegdb/multi_part_shape_buffer.hpp
 - ext/filegdb/multi_point_shape_buffer.cpp
 - ext/filegdb/multi_point_shape_buffer.hpp
 - ext/filegdb/point.cpp
 - ext/filegdb/point.hpp
 - ext/filegdb/point_shape_buffer.cpp
 - ext/filegdb/point_shape_buffer.hpp
+- ext/filegdb/primitive.hpp
 - ext/filegdb/row.cpp
 - ext/filegdb/row.hpp
 - ext/filegdb/shape_buffer.cpp
@@ -114,6 +121,7 @@ files:
 - spec/field_info_spec.rb
 - spec/filegdb_spec.rb
 - spec/geodatabase_spec.rb
+- spec/multi_part_shape_buffer_spec.rb
 - spec/multi_point_shape_buffer_spec.rb
 - spec/point_shape_buffer_spec.rb
 - spec/row_spec.rb
@@ -154,6 +162,7 @@ test_files:
 - spec/field_info_spec.rb
 - spec/filegdb_spec.rb
 - spec/geodatabase_spec.rb
+- spec/multi_part_shape_buffer_spec.rb
 - spec/multi_point_shape_buffer_spec.rb
 - spec/point_shape_buffer_spec.rb
 - spec/row_spec.rb