capn_proto-rpc 0.1.1.alpha.rpc

data/ext/capn_proto/dynamic_struct_builder.h

@@ -0,0 +1,34 @@
+#ifndef DYNAMIC_STRUCT_BUILDER_H
+#define DYNAMIC_STRUCT_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicStructBuilder {
+  public:
+    using WrappedType = capnp::DynamicStruct::Builder;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType reader, VALUE parent, bool is_root);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE which(VALUE self);
+    static VALUE get(VALUE self, VALUE rb_name);
+    static VALUE set(VALUE self, VALUE rb_name, VALUE rb_obj);
+
+    static VALUE init(VALUE self, VALUE rb_name, VALUE rb_obj);
+    static VALUE init(int argc, VALUE* argv, VALUE self);
+
+    static VALUE write(VALUE self, VALUE file);
+    static VALUE to_bytes(VALUE self);
+
+    static VALUE Class;
+  private:
+    static VALUE _get(VALUE self, VALUE name);
+    static VALUE _set(VALUE self, VALUE rb_name, VALUE rb_obj);
+
+    static VALUE _init(VALUE self, VALUE rb_name, VALUE rb_count, int argc);
+  };
+}
+
+#endif

data/ext/capn_proto/dynamic_struct_reader.cc

@@ -0,0 +1,69 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_value_reader.h"
+#include "class_builder.h"
+#include "exception.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::DynamicStruct::Reader;
+  VALUE DynamicStructReader::Class;
+
+  void DynamicStructReader::Init() {
+    ClassBuilder("DynamicStructReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("which", &which).
+      defineMethod("[]", &get).
+      store(&Class);
+  }
+
+  void DynamicStructReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  VALUE DynamicStructReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* DynamicStructReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicStructReader::create(WrappedType reader, VALUE parent) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE DynamicStructReader::get(VALUE self, VALUE rb_name) {
+    try {
+      return _get(self, rb_name);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicStructReader::_get(VALUE self, VALUE rb_name) {
+    auto reader = *unwrap(self);
+    auto name = Util::toString(rb_name);
+    return DynamicValueReader::to_ruby(reader.get(name), self);
+  }
+
+  VALUE DynamicStructReader::which(VALUE self) {
+    auto schema_maybe = unwrap(self)->which();
+    KJ_IF_MAYBE(schema, schema_maybe) {
+      auto name = schema->getProto().getName();
+      return rb_str_new(name.begin(), name.size());
+    } else {
+      // throw std::invalid_argument("member was null");
+      return Qnil;
+    }
+  }
+}

data/ext/capn_proto/dynamic_struct_reader.h

@@ -0,0 +1,25 @@
+#ifndef DYNAMIC_STRUCT_READER_H
+#define DYNAMIC_STRUCT_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicStructReader {
+  public:
+    using WrappedType = capnp::DynamicStruct::Reader;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType reader, VALUE parent);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE which(VALUE self);
+    static VALUE get(VALUE self, VALUE name);
+
+    static VALUE Class;
+  private:
+    static VALUE _get(VALUE self, VALUE name);
+  };
+}
+
+
+#endif /* DYNAMIC_STRUCT_READER_H */

data/ext/capn_proto/dynamic_value_builder.cc

@@ -0,0 +1,53 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_value_builder.h"
+#include "dynamic_list_builder.h"
+#include "dynamic_struct_builder.h"
+#include "dynamic_object_builder.h"
+
+namespace ruby_capn_proto {
+
+  VALUE DynamicValueBuilder::to_ruby(capnp::DynamicValue::Builder value, VALUE parent) {
+    switch (value.getType())
+    {
+      case capnp::DynamicValue::BOOL:
+        return value.as<bool>() ? Qtrue : Qfalse;
+      case capnp::DynamicValue::INT:
+        return INT2NUM(value.as<int64_t>());
+      case capnp::DynamicValue::UINT:
+        return UINT2NUM(value.as<uint64_t>());
+      case capnp::DynamicValue::FLOAT:
+        return rb_float_new(value.as<double>());
+      case capnp::DynamicValue::TEXT:
+        {
+          auto text = value.as<capnp::Text>();
+          return rb_str_new(text.begin(), text.size());
+        }
+      case capnp::DynamicValue::DATA:
+        {
+          auto data = value.as<capnp::Data>();
+          return rb_str_new((const char*)data.begin(), data.size());
+        }
+      case capnp::DynamicValue::LIST:
+        return DynamicListBuilder::create(value.as<capnp::DynamicList>(), parent);
+      case capnp::DynamicValue::STRUCT:
+        return DynamicStructBuilder::create(value.as<capnp::DynamicStruct>(), parent, false);
+      case capnp::DynamicValue::ENUM:
+        {
+          auto enumerant_maybe = value.as<capnp::DynamicEnum>().getEnumerant();
+          KJ_IF_MAYBE(enumerant, enumerant_maybe) {
+            auto name = enumerant->getProto().getName();
+            return rb_str_new(name.begin(), name.size());
+          } else {
+            return Qnil;
+          }
+        }
+      case capnp::DynamicValue::ANY_POINTER:
+        return DynamicObjectBuilder::create(value.as<capnp::AnyPointer>(), parent);
+      case capnp::DynamicValue::VOID:
+        return Qnil;
+      case capnp::DynamicValue::UNKNOWN:
+      default:
+        return Qnil;
+    }
+  }
+}

data/ext/capn_proto/dynamic_value_builder.h

@@ -0,0 +1,13 @@
+#ifndef DYNAMIC_VALUE_BUILDER_H
+#define DYNAMIC_VALUE_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicValueBuilder {
+  public:
+    static VALUE to_ruby(capnp::DynamicValue::Builder value, VALUE parent);
+  };
+}
+
+#endif /* DYNAMIC_VALUE_BUILDER_H */

data/ext/capn_proto/dynamic_value_reader.cc

@@ -0,0 +1,55 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_value_reader.h"
+#include "dynamic_list_reader.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_object_reader.h"
+#include "dynamic_capability_client.h"
+
+namespace ruby_capn_proto {
+  VALUE DynamicValueReader::to_ruby(capnp::DynamicValue::Reader value, VALUE parent) {
+    switch (value.getType())
+    {
+      case capnp::DynamicValue::CAPABILITY:
+        return DynamicCapabilityClient::create(value.as<capnp::DynamicCapability>());
+      case capnp::DynamicValue::BOOL:
+        return value.as<bool>() ? Qtrue : Qfalse;
+      case capnp::DynamicValue::INT:
+        return INT2NUM(value.as<int64_t>());
+      case capnp::DynamicValue::UINT:
+        return UINT2NUM(value.as<uint64_t>());
+      case capnp::DynamicValue::FLOAT:
+        return rb_float_new(value.as<double>());
+      case capnp::DynamicValue::TEXT:
+        {
+          auto text = value.as<capnp::Text>();
+          return rb_str_new(text.begin(), text.size());
+        }
+      case capnp::DynamicValue::DATA:
+        {
+          auto data = value.as<capnp::Data>();
+          return rb_str_new((const char*)data.begin(), data.size());
+        }
+      case capnp::DynamicValue::LIST:
+        return DynamicListReader::create(value.as<capnp::DynamicList>(), parent);
+      case capnp::DynamicValue::STRUCT:
+        return DynamicStructReader::create(value.as<capnp::DynamicStruct>(), parent);
+      case capnp::DynamicValue::ENUM:
+        {
+          auto enumerant_maybe = value.as<capnp::DynamicEnum>().getEnumerant();
+          KJ_IF_MAYBE(enumerant, enumerant_maybe) {
+            auto name = enumerant->getProto().getName();
+            return rb_str_new(name.begin(), name.size());
+          } else {
+            return Qnil;
+          }
+        }
+      case capnp::DynamicValue::ANY_POINTER:
+        return DynamicObjectReader::create(value.as<capnp::AnyPointer>(), parent);
+      case capnp::DynamicValue::VOID:
+        return Qnil;
+      case capnp::DynamicValue::UNKNOWN:
+      default:
+        return Qnil;
+    }
+  }
+}

data/ext/capn_proto/dynamic_value_reader.h

@@ -0,0 +1,13 @@
+#ifndef DYNAMIC_VALUE_READER_H
+#define DYNAMIC_VALUE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicValueReader {
+  public:
+    static VALUE to_ruby(capnp::DynamicValue::Reader value, VALUE parent);
+  };
+}
+
+#endif /* DYNAMIC_VALUE_READER_H */

data/ext/capn_proto/exception.cc

@@ -0,0 +1,34 @@
+#include "ruby_capn_proto.h"
+#include "exception.h"
+#include "class_builder.h"
+#include "util.h"
+
+// VALUE rb_eException;
+// VALUE rb_eStandardError;
+// VALUE rb_eRuntimeError;
+
+namespace ruby_capn_proto {
+  using WrappedType = kj::Exception;
+  VALUE Exception::Class;
+
+  void Exception::Init() {
+    ClassBuilder("Exception", rb_eException).
+      store(&Class);
+  }
+
+  VALUE Exception::create(WrappedType exception) {
+    VALUE msg = Util::toRubyString(exception.getDescription());
+    VALUE rb_exception = rb_funcall(Class, rb_intern("new"), 1, msg);
+
+    return rb_exception;
+  }
+
+  VALUE Exception::raise(WrappedType exception) {
+    rb_exc_raise(create(exception));
+    return Qnil;
+  }
+
+  void * Exception::raise(void * exception) {
+    rb_exc_raise(create(*((kj::Exception*)exception)));
+  }
+}

data/ext/capn_proto/exception.h

@@ -0,0 +1,20 @@
+#ifndef EXCEPTION_H
+#define EXCEPTION_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class Exception {
+  public:
+    using WrappedType = kj::Exception;
+    static void Init();
+    static VALUE create(WrappedType exception);
+    static VALUE raise(WrappedType exception);
+    static void * raise(void * exception);
+
+    static VALUE Class;
+  };
+}
+
+
+#endif /* EXCEPTION_H */

data/ext/capn_proto/extconf.rb

@@ -0,0 +1,32 @@
+require 'mkmf'
+require File.expand_path("../cxx_compiler", __FILE__)
+
+compiler = CXXCompiler.new({'CXX' => CONFIG['CXX']}.merge(ENV.to_hash))
+unless compiler.has_cxx11_compiler_support?
+  abort "*** A compiler with support for C++11 language features is required."
+end
+unless compiler.has_cxx11_library_support?
+  abort "*** A C++ library with support for C++11 features is required."
+end
+
+$CXXFLAGS = ' -std=c++11 ' 
+
+CONFIG['CXX']      = ENV['CXX'] || CONFIG['CXX']
+CONFIG['CXXFLAGS'] = [(ENV['CXXFLAGS'] || CONFIG['CXXFLAGS']),
+                      compiler.std_flag,
+                      compiler.stdlib_flag].join(' ')
+
+if enable_config('debug')
+  CONFIG['CFLAGS'] += " -O0 -ggdb3"
+else
+  $CPPFLAGS += " -DNDEBUG"
+end
+
+$LDFLAGS += " -lcapnpc"
+$LDFLAGS += " -lcapnp"
+$LDFLAGS += " -lkj"
+$LDFLAGS += " -lcapnp-rpc"
+$LDFLAGS += " -lkj-async"
+
+
+create_makefile('capn_proto/capn_proto')

data/ext/capn_proto/field_list.cc

@@ -0,0 +1,51 @@
+#include "ruby_capn_proto.h"
+#include "field_list.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::StructSchema::FieldList;
+  VALUE FieldList::Class;
+
+  void FieldList::Init() {
+    ClassBuilder("FieldList", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("size", &size).
+      defineMethod("[]", &get).
+      store(&Class);
+  }
+
+  void FieldList::free(WrappedType* p) {
+    p->~FieldList();
+    ruby_xfree(p);
+  }
+
+  VALUE FieldList::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* FieldList::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE FieldList::create(WrappedType schema) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped_schema = unwrap(rb_obj);
+    *wrapped_schema = kj::mv(schema);
+
+    return rb_obj;
+  }
+
+  VALUE FieldList::get(VALUE self, VALUE index) {
+    auto idx = FIX2INT(index);
+    auto list = *unwrap(self);
+    return Qnil;
+    // return Field::create(list[idx]);
+  }
+
+  VALUE FieldList::size(VALUE self) {
+    return INT2FIX(unwrap(self)->size());
+  }
+}

data/ext/capn_proto/field_list.h

@@ -0,0 +1,23 @@
+#ifndef FIELD_LIST_H
+#define FIELD_LIST_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class FieldList {
+  public:
+    using WrappedType = capnp::StructSchema::FieldList;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType schema);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE get(VALUE self, VALUE name);
+    static VALUE size(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+
+#endif /* FIELD_LIST_H */

data/ext/capn_proto/flat_array_message_reader.cc

@@ -0,0 +1,61 @@
+#include "ruby_capn_proto.h"
+#include "message_reader.h"
+#include "flat_array_message_reader.h"
+#include "struct_schema.h"
+#include "dynamic_struct_reader.h"
+#include "class_builder.h"
+#include "exception.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::FlatArrayMessageReader;
+  VALUE FlatArrayMessageReader::Class;
+
+  void FlatArrayMessageReader::Init() {
+    ClassBuilder("FlatArrayMessageReader", MessageReader::Class).
+      defineAlloc(&alloc).
+      defineMethod("initialize", &initialize).
+      defineMethod("get_root", &get_root).
+      store(&Class);
+  }
+
+  VALUE FlatArrayMessageReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE FlatArrayMessageReader::initialize(VALUE self, VALUE rb_buff) {
+    rb_iv_set(self, "buff", rb_buff);
+    auto str = RSTRING_PTR(rb_buff);
+    auto len = RSTRING_LEN(rb_buff);
+    kj::ArrayPtr<const capnp::word> buff((const capnp::word*)str, len/sizeof(capnp::word));
+
+    try {
+      WrappedType* p = unwrap(self);
+      new (p) WrappedType(buff);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+
+    return Qnil;
+  }
+
+  void FlatArrayMessageReader::free(WrappedType* p) {
+    p->~FlatArrayMessageReader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* FlatArrayMessageReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE FlatArrayMessageReader::get_root(VALUE self, VALUE rb_schema) {
+    if (rb_respond_to(rb_schema, rb_intern("schema"))) {
+      rb_schema = rb_funcall(rb_schema, rb_intern("schema"), 0);
+    }
+
+    auto schema = *StructSchema::unwrap(rb_schema);
+    auto reader = unwrap(self)->getRoot<capnp::DynamicStruct>(schema);
+    return DynamicStructReader::create(reader, self);
+  }
+}