filegdb 0.0.1

data/ext/filegdb/point_shape_buffer.hpp

@@ -0,0 +1,32 @@
+#ifndef __FGDB_POINT_SHAPE_BUFFER_HPP__
+#define __FGDB_POINT_SHAPE_BUFFER_HPP__
+
+#include "filegdb.hpp"
+#include "shape_buffer_base.hpp"
+
+namespace filegdb {
+  class point_shape_buffer : public shape_buffer_base<point_shape_buffer, PointShapeBuffer> {
+  public:
+    static void define(VALUE module);
+
+    static VALUE setup(VALUE self, VALUE shapeType);
+    static VALUE get_point(VALUE self);
+    static VALUE get_z(VALUE self);
+    static VALUE get_m(VALUE self);
+    static VALUE get_id(VALUE self);
+    static VALUE set_z(VALUE self, VALUE zValue);
+    static VALUE set_m(VALUE self, VALUE mValue);
+    static VALUE set_id(VALUE self, VALUE idValue);
+
+    virtual VALUE klass();
+
+    static VALUE _klass;
+
+    virtual ~point_shape_buffer() {};
+  };
+}
+
+#endif
+
+
+

data/ext/filegdb/row.cpp

@@ -0,0 +1,222 @@
+
+#include "row.hpp"
+#include "shape_buffer.hpp"
+
+#define DATETIME_FORMAT "%Y-%m-%d %H:%M:%S"
+
+namespace filegdb {
+
+VALUE row::_klass = Qnil;
+
+VALUE row::klass() {
+  return row::_klass;
+}
+
+row::row(table *table)
+: _table(table), _row(new Row)
+{
+}
+
+row::~row() {
+  if (_row) {
+    delete _row;
+    _row = NULL;
+  }
+}
+
+VALUE row::set_string(VALUE self, VALUE column, VALUE value) {
+  row *row = unwrap(self);
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+  std::wstring wvalue = to_wstring(RSTRING_PTR(value));
+
+  fgdbError hr = row->value().SetString(wcolumn, wvalue);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return row->_value;
+}
+
+VALUE row::get_string(VALUE self, VALUE column) {
+  row *row = unwrap(self);
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+  std::wstring wvalue;
+
+  fgdbError hr = row->value().GetString(wcolumn, wvalue);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return rb_str_new2(to_char_array(wvalue));
+}
+
+VALUE row::set_geometry(VALUE self, VALUE geometry) {
+  row *row = unwrap(self);
+
+  shape_buffer *shape = shape_buffer::unwrap(geometry);
+
+  fgdbError hr = row->value().SetGeometry(shape->value());
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return shape->wrapped();
+}
+
+VALUE row::set_date(VALUE self, VALUE column, VALUE date) {
+  CHECK_ARGUMENT_STRING(column)
+  CHECK_ARGUMENT_STRING(date)
+
+  row *row = unwrap(self);
+
+  struct tm datetime;
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+
+  if (strptime(RSTRING_PTR(date), DATETIME_FORMAT, &datetime) != NULL) {
+    fgdbError hr = row->value().SetDate(wcolumn, datetime);
+
+    if (FGDB_IS_FAILURE(hr)) {
+      FGDB_RAISE_ERROR(hr);
+      return Qnil;
+    }
+  } else {
+    FGDB_FATAL("Date could not be parsed.");
+    return Qnil;
+  }
+
+  return row->wrapped();
+}
+
+VALUE row::get_date(VALUE self, VALUE column) {
+  CHECK_ARGUMENT_STRING(column)
+
+  row *row = unwrap(self);
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+
+  struct tm datetime;
+
+  fgdbError hr = row->value().GetDate(wcolumn, datetime);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  char buffer[80];
+
+  size_t length = strftime(buffer, 80, DATETIME_FORMAT, &datetime);
+
+  if (length == 0) {
+    FGDB_FATAL("Date could not be parsed.");
+    return Qnil;
+  }
+
+  return rb_str_new2(buffer);
+}
+
+VALUE row::set_double(VALUE self, VALUE column, VALUE number) {
+  CHECK_ARGUMENT_STRING(column)
+  CHECK_ARGUMENT_FLOAT(number)
+
+  row *row = unwrap(self);
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+
+  fgdbError hr = row->value().SetDouble(wcolumn, NUM2DBL(number));
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return row->wrapped();
+}
+
+VALUE row::get_double(VALUE self, VALUE column) {
+  CHECK_ARGUMENT_STRING(column)
+
+  row *row = unwrap(self);
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+
+  double result = 0;
+
+  fgdbError hr = row->value().GetDouble(wcolumn, result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return rb_float_new(result);
+}
+
+VALUE row::set_integer(VALUE self, VALUE column, VALUE integer) {
+  CHECK_ARGUMENT_STRING(column)
+  CHECK_ARGUMENT_FIXNUM(integer)
+
+  row *row = unwrap(self);
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+
+  fgdbError hr = row->value().SetInteger(wcolumn, FIX2INT(integer));
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return row->wrapped();
+}
+
+VALUE row::get_integer(VALUE self, VALUE column) {
+  CHECK_ARGUMENT_STRING(column)
+
+  row *row = unwrap(self);
+
+  std::wstring wcolumn = to_wstring(RSTRING_PTR(column));
+
+  int32 result = 0;
+
+  fgdbError hr = row->value().GetInteger(wcolumn, result);
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return INT2NUM(result);
+}
+
+VALUE row::get_geometry(VALUE self) {
+  FGDB_FATAL("Not implemented");
+  return Qnil;
+}
+
+void row::define(VALUE module)
+{
+  row::_klass = rb_define_class_under(module, "Row", rb_cObject);
+  base::define(row::_klass, false);
+  rb_define_method(row::_klass, "set_string", FGDB_METHOD(row::set_string), 2);
+  rb_define_method(row::_klass, "get_string", FGDB_METHOD(row::get_string), 1);
+  rb_define_method(row::_klass, "set_geometry", FGDB_METHOD(row::set_geometry), 1);
+  rb_define_method(row::_klass, "get_geometry", FGDB_METHOD(row::get_geometry), 0);
+  rb_define_method(row::_klass, "set_date", FGDB_METHOD(row::set_date), 2);
+  rb_define_method(row::_klass, "get_date", FGDB_METHOD(row::get_date), 1);
+  rb_define_method(row::_klass, "set_double", FGDB_METHOD(row::set_double), 2);
+  rb_define_method(row::_klass, "get_double", FGDB_METHOD(row::get_double), 1);
+  rb_define_method(row::_klass, "set_integer", FGDB_METHOD(row::set_integer), 2);
+  rb_define_method(row::_klass, "get_integer", FGDB_METHOD(row::get_integer), 1);
+}
+
+}

data/ext/filegdb/row.hpp

@@ -0,0 +1,37 @@
+#ifndef __FGDB_ROW_HPP__
+#define __FGDB_ROW_HPP__
+
+#include "filegdb.hpp"
+#include "table.hpp"
+
+namespace filegdb {
+  class row : public base<row> {
+  public:
+    row() : base<row>() {};
+    row(table *table);
+    static void define(VALUE module);
+    static VALUE set_string(VALUE self, VALUE column, VALUE value);
+    static VALUE get_string(VALUE self, VALUE column);
+    static VALUE set_geometry(VALUE self, VALUE geometry);
+    static VALUE get_geometry(VALUE self);
+    static VALUE set_date(VALUE self, VALUE column, VALUE date);
+    static VALUE get_date(VALUE self, VALUE column);
+    static VALUE set_double(VALUE self, VALUE column, VALUE number);
+    static VALUE get_double(VALUE self, VALUE column);
+    static VALUE set_integer(VALUE self, VALUE column, VALUE integer);
+    static VALUE get_integer(VALUE self, VALUE column);
+
+    virtual VALUE klass();
+    static VALUE _klass;
+
+    Row &value() { return *_row; }
+
+    virtual ~row();
+  private:
+    Row *_row;
+    table *_table;
+  };
+}
+
+#endif
+

data/ext/filegdb/shape_buffer.cpp

@@ -0,0 +1,19 @@
+
+#include "shape_buffer.hpp"
+
+namespace filegdb {
+
+VALUE shape_buffer::_klass = Qnil;
+
+VALUE shape_buffer::klass() {
+  return shape_buffer::_klass;
+}
+
+void shape_buffer::define(VALUE module)
+{
+  shape_buffer::_klass = rb_define_class_under(module, "ShapeBuffer", rb_cObject);
+  base::define(shape_buffer::_klass, true);
+}
+
+}
+

data/ext/filegdb/shape_buffer.hpp

@@ -0,0 +1,20 @@
+#ifndef __FGDB_SHAPE_BUFFER_HPP__
+#define __FGDB_SHAPE_BUFFER_HPP__
+
+#include "filegdb.hpp"
+#include "shape_buffer_base.hpp"
+
+namespace filegdb {
+  class shape_buffer : public shape_buffer_base<shape_buffer, ShapeBuffer> {
+  public:
+    static void define(VALUE module);
+
+    virtual VALUE klass();
+
+    static VALUE _klass;
+
+    virtual ~shape_buffer() {};
+  };
+}
+
+#endif

data/ext/filegdb/shape_buffer_base.hpp

@@ -0,0 +1,33 @@
+#ifndef __FGDB_SHAPE_BUFFER_BASE_HPP__
+#define __FGDB_SHAPE_BUFFER_BASE_HPP__
+
+#include "filegdb.hpp"
+#include "base.hpp"
+
+namespace filegdb {
+  template <typename T, typename S>
+  class shape_buffer_base : public base<T> {
+  public:
+    shape_buffer_base() : _shape_buffer(0) {};
+
+    virtual ~shape_buffer_base() {
+      if (_shape_buffer) {
+        delete _shape_buffer;
+        _shape_buffer = NULL;
+      }
+    }
+
+    virtual VALUE initialize(int argc, VALUE *argv) {
+      _shape_buffer = new S;
+      return base<T>::wrapped();
+    }
+
+    S &value() { return *_shape_buffer; }
+  protected:
+    S *_shape_buffer;
+  };
+}
+
+#endif
+
+

data/ext/filegdb/table.cpp

@@ -0,0 +1,65 @@
+
+#include "table.hpp"
+#include "row.hpp"
+
+namespace filegdb {
+
+VALUE table::_klass = Qnil;
+
+VALUE table::klass() {
+  return table::_klass;
+}
+
+table::table(geodatabase *db)
+: _db(db), _table(new Table)
+{
+}
+
+table::~table() {
+  if (_table) {
+    delete _table;
+    _table = NULL;
+  }
+}
+
+VALUE table::create_row_object(VALUE self) {
+  table *table = unwrap(self);
+
+  filegdb::row *row = new filegdb::row(table);
+
+  fgdbError hr = table->value().CreateRowObject(row->value());
+
+  if (FGDB_IS_FAILURE(hr)) {
+    delete row;
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return row->wrapped();
+}
+
+VALUE table::insert(VALUE self, VALUE row) {
+  filegdb::table *table = unwrap(self);
+  filegdb::row *newRow = filegdb::row::unwrap(row);
+
+  fgdbError hr = table->value().Insert(newRow->value());
+
+  if (FGDB_IS_FAILURE(hr)) {
+    FGDB_RAISE_ERROR(hr);
+    return Qnil;
+  }
+
+  return self;
+}
+
+void table::define(VALUE module)
+{
+  table::_klass = rb_define_class_under(module, "Table", rb_cObject);
+  base::define(table::_klass, false);
+  rb_define_method(table::_klass, "create_row_object", FGDB_METHOD(table::create_row_object), 0);
+  rb_define_method(table::_klass, "insert", FGDB_METHOD(table::insert), 1);
+}
+
+}
+
+

data/ext/filegdb/table.hpp

@@ -0,0 +1,29 @@
+#ifndef __FGDB_TABLE_HPP__
+#define __FGDB_TABLE_HPP__
+
+#include "filegdb.hpp"
+#include "geodatabase.hpp"
+
+namespace filegdb {
+  class table : public base<table> {
+  public:
+    table() : base<table>(), _table(0) {};
+    table(geodatabase *db);
+    static VALUE create_row_object(VALUE self);
+    static VALUE insert(VALUE self, VALUE row);
+    static void define(VALUE module);
+
+    virtual VALUE klass();
+    static VALUE _klass;
+
+    Table &value() { return *_table; }
+
+    virtual ~table();
+
+  private:
+    Table *_table;
+    geodatabase *_db;
+  };
+}
+
+#endif