filegdb 0.0.1

data/ext/filegdb/geodatabase.hpp

@@ -0,0 +1,53 @@
+#ifndef __FGDB_GEODATABASE_HPP__
+#define __FGDB_GEODATABASE_HPP__
+
+#include "filegdb.hpp"
+#include "base.hpp"
+
+namespace filegdb {
+  class table;
+
+  class geodatabase : public base<geodatabase> {
+  public:
+    geodatabase();
+    static VALUE create(VALUE klass, VALUE filename);
+    static VALUE open(VALUE klass, VALUE filename);
+    static VALUE delete_database(VALUE klass, VALUE filename);
+    static VALUE close(VALUE self);
+    static VALUE create_table(VALUE self, VALUE tableName, VALUE tableDefinition);
+    static VALUE create_feature_dataset(VALUE self, VALUE featureSetDefinition);
+    static VALUE open_table(VALUE self, VALUE tableName);
+    static VALUE close_table(VALUE self, VALUE table);
+    static VALUE delete_dataset(VALUE self, VALUE path, VALUE datasetType);
+    static VALUE rename(VALUE self, VALUE path, VALUE datasetType, VALUE newName);
+    static VALUE move(VALUE self, VALUE path, VALUE newParentPath);
+    static VALUE get_child_datasets(VALUE self, VALUE parentPath, VALUE datasetType);
+    static VALUE get_dataset_definition(VALUE self, VALUE path, VALUE datasetType);
+    static VALUE get_dataset_documentation(VALUE self, VALUE path, VALUE datasetType);
+    static VALUE get_child_dataset_definitions(VALUE self, VALUE parentPath, VALUE datasetType);
+    static VALUE get_related_dataset_definitions(VALUE self, VALUE path, VALUE relType, VALUE datasetType);
+    static VALUE get_dataset_types(VALUE self);
+    static VALUE get_dataset_relationship_types(VALUE self);
+    static VALUE get_related_datasets(VALUE self, VALUE path, VALUE relType, VALUE datasetType);
+    static VALUE create_domain(VALUE self, VALUE domainDefinition);
+    static VALUE alter_domain(VALUE self, VALUE domainDefinition);
+    static VALUE delete_domain(VALUE self, VALUE domainName);
+    static VALUE get_domain_definition(VALUE self, VALUE domainName);
+    static VALUE get_query_name(VALUE self, VALUE path);
+
+    static void define(VALUE module);
+
+    virtual ~geodatabase();
+
+    virtual void mark();
+    virtual VALUE klass();
+
+    static VALUE _klass;
+
+  private:
+    Geodatabase *_gdb;
+    std::vector<table *> _tables;
+  };
+}
+
+#endif

data/ext/filegdb/multi_point_shape_buffer.cpp

@@ -0,0 +1,254 @@
+
+#include "point.hpp"
+#include "shape_buffer.hpp"
+#include "multi_point_shape_buffer.hpp"
+
+namespace filegdb {
+
+VALUE multi_point_shape_buffer::_klass = Qnil;
+
+VALUE multi_point_shape_buffer::klass() {
+  return multi_point_shape_buffer::_klass;
+}
+
+VALUE multi_point_shape_buffer::setup(VALUE self, VALUE shapeType, VALUE numberOfPoints) {
+  CHECK_ARGUMENT_FIXNUM(shapeType);
+  CHECK_ARGUMENT_FIXNUM(numberOfPoints);
+
+  multi_point_shape_buffer *shape = unwrap(self);
+
+  ShapeType nshape_type = (ShapeType)FIX2INT(shapeType);
+
+  fgdbError hr = shape->value().Setup(nshape_type, FIX2INT(numberOfPoints));
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  return shape->wrapped();
+}
+
+VALUE multi_point_shape_buffer::get_points(VALUE self) {
+  multi_point_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_point_shape_buffer::get_num_points(VALUE self) {
+  multi_point_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_point_shape_buffer::get_zs(VALUE self)
+{
+  multi_point_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_point_shape_buffer::get_ms(VALUE self)
+{
+  multi_point_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_point_shape_buffer::get_ids(VALUE self)
+{
+  multi_point_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_point_shape_buffer::get_extent(VALUE self)
+{
+  multi_point_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_point_shape_buffer::get_z_extent(VALUE self)
+{
+  multi_point_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_point_shape_buffer::get_m_extent(VALUE self)
+{
+  multi_point_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_point_shape_buffer::calculate_extent(VALUE self)
+{
+  multi_point_shape_buffer *shape = unwrap(self);
+
+  fgdbError hr = shape->value().CalculateExtent();
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  return Qnil;
+}
+
+void multi_point_shape_buffer::define(VALUE module)
+{
+  multi_point_shape_buffer::_klass = rb_define_class_under(module, "MultiPointShapeBuffer", shape_buffer::_klass);
+  base::define(multi_point_shape_buffer::_klass, true);
+  rb_define_method(multi_point_shape_buffer::_klass, "setup", FGDB_METHOD(multi_point_shape_buffer::setup), 2);
+  rb_define_method(multi_point_shape_buffer::_klass, "get_points", FGDB_METHOD(multi_point_shape_buffer::get_points), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "get_num_points", FGDB_METHOD(multi_point_shape_buffer::get_num_points), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "z", FGDB_METHOD(multi_point_shape_buffer::get_zs), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "m", FGDB_METHOD(multi_point_shape_buffer::get_ms), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "id", FGDB_METHOD(multi_point_shape_buffer::get_ids), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "get_extent", FGDB_METHOD(multi_point_shape_buffer::get_extent), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "get_z_extent", FGDB_METHOD(multi_point_shape_buffer::get_z_extent), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "get_m_extent", FGDB_METHOD(multi_point_shape_buffer::get_m_extent), 0);
+  rb_define_method(multi_point_shape_buffer::_klass, "calculate_extent", FGDB_METHOD(multi_point_shape_buffer::calculate_extent), 0);
+}
+
+}
+
+

data/ext/filegdb/multi_point_shape_buffer.hpp

@@ -0,0 +1,35 @@
+#ifndef __FGDB_MULTI_POINT_SHAPE_BUFFER_HPP__
+#define __FGDB_MULTI_POINT_SHAPE_BUFFER_HPP__
+
+#include "filegdb.hpp"
+#include "shape_buffer_base.hpp"
+
+namespace filegdb {
+  class multi_point_shape_buffer : public shape_buffer_base<multi_point_shape_buffer, MultiPointShapeBuffer> {
+  public:
+    static void define(VALUE module);
+
+    static VALUE setup(VALUE self, VALUE shapeType, VALUE numberOfPoints);
+    static VALUE get_points(VALUE self);
+    static VALUE get_num_points(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_point_shape_buffer() {};
+  };
+}
+
+#endif
+
+
+
+

data/ext/filegdb/point.cpp

@@ -0,0 +1,44 @@
+
+#include "point.hpp"
+
+namespace filegdb {
+
+VALUE point::_klass = Qnil;
+
+VALUE point::klass() {
+  return point::_klass;
+}
+
+VALUE point::set_x(VALUE self, VALUE x) {
+  unwrap(self)->value->x = NUM2DBL(x);
+
+  return x;
+}
+
+VALUE point::get_x(VALUE self) {
+  return rb_float_new(unwrap(self)->value->x);
+}
+
+VALUE point::set_y(VALUE self, VALUE y) {
+  unwrap(self)->value->y = NUM2DBL(y);
+
+  return y;
+}
+
+VALUE point::get_y(VALUE self) {
+  return rb_float_new(unwrap(self)->value->y);
+}
+
+void point::define(VALUE module)
+{
+  point::_klass = rb_define_class_under(module, "Point", rb_cObject);
+  base::define(point::_klass, false);
+  rb_define_method(point::_klass, "x=", FGDB_METHOD(point::set_x), 1);
+  rb_define_method(point::_klass, "x", FGDB_METHOD(point::get_x), 0);
+  rb_define_method(point::_klass, "y=", FGDB_METHOD(point::set_y), 1);
+  rb_define_method(point::_klass, "y", FGDB_METHOD(point::get_y), 0);
+}
+
+}
+
+

data/ext/filegdb/point.hpp

@@ -0,0 +1,31 @@
+#ifndef __FGDB_POINT_HPP__
+#define __FGDB_POINT_HPP__
+
+#include "filegdb.hpp"
+#include "base.hpp"
+
+namespace filegdb {
+  class point : public base<point> {
+  public:
+    point() : value(0) {};
+    point(Point *p) : value(p) {};
+    static void define(VALUE module);
+
+    static VALUE set_x(VALUE self, VALUE x);
+    static VALUE get_x(VALUE self);
+
+    static VALUE set_y(VALUE self, VALUE y);
+    static VALUE get_y(VALUE self);
+
+    virtual VALUE klass();
+
+    static VALUE _klass;
+
+    virtual ~point() {};
+
+    Point *value;
+  };
+}
+
+#endif
+

data/ext/filegdb/point_shape_buffer.cpp

@@ -0,0 +1,162 @@
+
+#include "point.hpp"
+#include "shape_buffer.hpp"
+#include "point_shape_buffer.hpp"
+
+namespace filegdb {
+
+VALUE point_shape_buffer::_klass = Qnil;
+
+VALUE point_shape_buffer::klass() {
+  return point_shape_buffer::_klass;
+}
+
+VALUE point_shape_buffer::setup(VALUE self, VALUE shapeType) {
+  point_shape_buffer *shape = unwrap(self);
+
+  ShapeType nshape_type = (ShapeType)FIX2INT(shapeType);
+
+  fgdbError hr = shape->value().Setup(nshape_type);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+  }
+
+  return shape->wrapped();
+}
+
+VALUE point_shape_buffer::get_point(VALUE self) {
+  point_shape_buffer *shape = unwrap(self);
+
+  Point *out = NULL;
+
+  fgdbError hr = shape->value().GetPoint(out);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  point *result = new point(out);
+
+  return result->wrapped();
+}
+
+VALUE point_shape_buffer::get_z(VALUE self) {
+  point_shape_buffer *shape = unwrap(self);
+
+  double *result = NULL;
+
+  fgdbError hr = shape->value().GetZ(result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return rb_float_new(*result);
+}
+
+VALUE point_shape_buffer::get_m(VALUE self) {
+  point_shape_buffer *shape = unwrap(self);
+
+  double *result = NULL;
+
+  fgdbError hr = shape->value().GetM(result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return rb_float_new(*result);
+}
+
+VALUE point_shape_buffer::get_id(VALUE self) {
+  point_shape_buffer *shape = unwrap(self);
+
+  int *result = NULL;
+
+  fgdbError hr = shape->value().GetID(result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return INT2FIX(*result);
+}
+
+VALUE point_shape_buffer::set_z(VALUE self, VALUE zValue) {
+  CHECK_ARGUMENT_FLOAT(zValue);
+
+  point_shape_buffer *shape = unwrap(self);
+
+  double *result = NULL;
+
+  fgdbError hr = shape->value().GetZ(result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  *result = NUM2DBL(zValue);
+
+  return zValue;
+}
+
+VALUE point_shape_buffer::set_m(VALUE self, VALUE mValue) {
+  CHECK_ARGUMENT_FLOAT(mValue);
+
+  point_shape_buffer *shape = unwrap(self);
+
+  double *result = NULL;
+
+  fgdbError hr = shape->value().GetM(result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  *result = NUM2DBL(mValue);
+
+  return mValue;
+}
+
+VALUE point_shape_buffer::set_id(VALUE self, VALUE idValue) {
+  CHECK_ARGUMENT_FIXNUM(idValue);
+
+  point_shape_buffer *shape = unwrap(self);
+
+  int *result = NULL;
+
+  fgdbError hr = shape->value().GetID(result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  *result = FIX2INT(idValue);
+
+  return idValue;
+}
+
+void point_shape_buffer::define(VALUE module)
+{
+  point_shape_buffer::_klass = rb_define_class_under(module, "PointShapeBuffer", shape_buffer::_klass);
+  base::define(point_shape_buffer::_klass, true);
+  rb_define_method(point_shape_buffer::_klass, "setup", FGDB_METHOD(point_shape_buffer::setup), 1);
+  rb_define_method(point_shape_buffer::_klass, "get_point", FGDB_METHOD(point_shape_buffer::get_point), 0);
+  rb_define_method(point_shape_buffer::_klass, "z", FGDB_METHOD(point_shape_buffer::get_z), 0);
+  rb_define_method(point_shape_buffer::_klass, "m", FGDB_METHOD(point_shape_buffer::get_m), 0);
+  rb_define_method(point_shape_buffer::_klass, "id", FGDB_METHOD(point_shape_buffer::get_id), 0);
+  rb_define_method(point_shape_buffer::_klass, "z=", FGDB_METHOD(point_shape_buffer::set_z), 1);
+  rb_define_method(point_shape_buffer::_klass, "m=", FGDB_METHOD(point_shape_buffer::set_m), 1);
+  rb_define_method(point_shape_buffer::_klass, "id=", FGDB_METHOD(point_shape_buffer::set_id), 1);
+}
+
+}
+