capn_proto-rpc 0.1.1.alpha.rpc

data/ext/capn_proto/class_builder.cc

@@ -0,0 +1,80 @@
+#include "ruby_capn_proto.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+
+  VALUE defineClass(const char *name, VALUE superclass = rb_cObject) {
+    VALUE CapnProto = rb_define_module("CapnProto");
+    VALUE klass = rb_define_class_under(CapnProto, name, superclass);
+    // rb_funcall(klass, rb_intern("private_class_method"), 1, rb_str_new2("new"));
+    return klass;
+  }
+
+  ClassBuilder::ClassBuilder(const char* name, VALUE superclass) {
+    this->value = defineClass(name, superclass);
+  }
+  ClassBuilder::ClassBuilder(const char* name, const char* supername) {
+    VALUE superclass = defineClass(supername);
+    this->value = defineClass(name, superclass);
+  }
+
+  ClassBuilder& ClassBuilder::defineAlloc(VALUE (*impl)(VALUE)) {
+    rb_define_alloc_func(this->value, (VALUE (*)(VALUE))impl);
+    return *this;
+  }
+
+  ClassBuilder& ClassBuilder::defineConst(const char* name, VALUE value) {
+    rb_define_const(this->value, name, value);
+    return *this;
+  }
+
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, -1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 0);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 2);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 3);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, -1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 0);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 2);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 3);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineEnumConst(const char* name, int value) {
+    rb_define_const(this->value, name, INT2FIX(value));
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::store(VALUE* storage) {
+    rb_gc_register_address(storage);
+    *storage = this->value;
+    return *this;
+  }
+}

data/ext/capn_proto/class_builder.h

@@ -0,0 +1,72 @@
+#ifndef CLASS_BUILDER_H
+#define CLASS_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class ClassBuilder {
+  public:
+    ClassBuilder() {};
+    ClassBuilder(const char* name, VALUE superclass = rb_cObject);
+    ClassBuilder(const char* name, const char* supername);
+    ClassBuilder& defineAlloc(VALUE (*impl)(VALUE));
+    ClassBuilder& defineConst(const char* name, VALUE value);
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE));
+    ClassBuilder& defineEnumConst(const char* name, int value);
+    ClassBuilder& store(VALUE* storage);
+    inline operator VALUE() {return this->value;}
+  protected:
+    VALUE value;
+  };
+
+  template <VALUE(* f)(int, VALUE*, VALUE)>
+  VALUE handleExceptions(int argc, VALUE* argv, VALUE self)
+  {
+    try {
+      return f(argc, argv, self);
+    } catch (...) {
+      rb_raise(rb_eRuntimeError, "caught unkown error");
+    }
+  }
+
+  template <VALUE(* f)(VALUE)>
+  VALUE handleExceptions(VALUE self)
+  {
+    return f(self);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg1)
+  {
+    return f(self, arg1);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg1, VALUE arg2)
+  {
+    return f(self, arg1, arg2);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE, VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg2, VALUE arg1, VALUE arg3)
+  {
+    return f(self, arg1, arg2, arg3);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE, VALUE, VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg2, VALUE arg1, VALUE arg3, VALUE arg4)
+  {
+    return f(self, arg1, arg2, arg3, arg4);
+  }
+}
+
+#endif /* CLASS_BUILDER_H */

data/ext/capn_proto/cxx_compiler.rb

@@ -0,0 +1,126 @@
+require 'shellwords'
+require 'tmpdir'
+
+# Discovers support for C++11 features,
+# and any required CXXFLAGS for such features.
+class CXXCompiler
+  CXX_COMPILER_FEATURES = <<-CODE
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    #ifdef __has_include
+    #if __has_include(<type_traits>)
+    #include <type_traits>
+    #endif
+    #endif
+  CODE
+
+  CXX_LIBRARY_FEATURES = <<-CODE
+    #include <initializer_list>
+    #include <unordered_map>
+    #include <atomic>
+    #include <thread>
+  CODE
+
+  # env: The environment variables (e.g. CXX, CXXFLAGS).
+  def initialize(env)
+    @env = env.dup
+    @exist = system("command -v #{@env['CXX'].shellescape} >/dev/null 2>&1")
+  end
+
+  # True if the compiler is accessible on the $PATH.
+  def exist?
+    @exist
+  end
+
+  # True if support for C++11 was detected, false otherwise.
+  def has_cxx11_compiler_support?
+    !!std_flag
+  end
+
+  # True if support for C++11 libraries was detected, false otherwise.
+  def has_cxx11_library_support?
+    !!stdlib_flag
+  end
+
+  # The required std flag (e.g. '-std=c++11'),
+  # empty string if unecessary given the current environment and/or compiler,
+  # or nil in the case where the compiler has no support.
+  def std_flag
+    test_compiler_flags(@env)
+    @std_flag
+  end
+
+  # The required stdlib flag (e.g. '-stdlib=libc++'),
+  # empty string if unecessary given the current environment and/or compiler,
+  # or nil in the case where the compiler has no support.
+  def stdlib_flag
+    test_compiler_flags(@env)
+    @stdlib_flag
+  end
+
+  private
+
+  # Detect any required flags.
+  def test_compiler_flags(env)
+    return if @tested || !exist?
+    @tested = true
+
+    cxxflags = (env['CXXFLAGS'] || '')
+    env = env.dup
+
+    flags = ['', '-std=gnu++11', '-std=gnu++0x', '-std=c++11', '-std=c++0x']
+    @std_flag = flags.detect do |flag|
+      env['CXXFLAGS'] = [cxxflags, flag].join(' ')
+      compile(CXX_COMPILER_FEATURES, env)
+    end
+
+    return unless @std_flag
+
+    env = env.dup
+    flags = ['', '-stdlib=libc++']
+    @stdlib_flag = flags.detect do |flag|
+      env['CXXFLAGS'] = [cxxflags, std_flag, flag].join(' ')
+      compile(CXX_LIBRARY_FEATURES, env)
+    end
+  end
+
+  # Compile a snippet of C++, returning true or false to indicate
+  # success.
+  def compile(code, env)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        File.open("test.cc", "w") {|f| f.write(code)}
+        system("#{env['CXX'].shellescape} #{env['CXXFLAGS']} -c test.cc >/dev/null 2>&1")
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  compiler         = CXXCompiler.new(ENV.to_hash)
+  cxx              = ENV['CXX']
+  cxxflags         = ENV['CXXFLAGS']
+  extra_cxxflags   = [compiler.std_flag, compiler.stdlib_flag].join(' ')
+  compiler_support = compiler.has_cxx11_compiler_support? ? 'YES' : 'NO'
+  lib_support      = compiler.has_cxx11_library_support? ? 'YES' : 'NO'
+
+  puts "     given CXX      = #{cxx}"
+  puts "     given CXXFLAGS = #{cxxflags}"
+  puts "additional CXXFLAGS = #{extra_cxxflags}"
+  puts ""
+  puts "Has C++11 compiler support?  #{compiler_support}"
+  puts "Has C++11 library support?   #{lib_support}"
+end

data/ext/capn_proto/dynamic_capability_client.cc

@@ -0,0 +1,73 @@
+#include "ruby_capn_proto.h"
+#include "capability_client.h"
+#include "dynamic_capability_client.h"
+#include "interface_schema.h"
+#include "interface_method.h"
+#include "remote_promise.h"
+#include "exception.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::DynamicCapability::Client;
+  VALUE DynamicCapabilityClient::Class;
+
+  void DynamicCapabilityClient::Init() {
+    ClassBuilder("DynamicCapabilityClient", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("request_and_send" , &request_and_send).
+      store(&Class);
+  }
+
+  void DynamicCapabilityClient::free(WrappedType* p) {
+    p->~Client();
+    ruby_xfree(p);
+  }
+
+  VALUE DynamicCapabilityClient::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* DynamicCapabilityClient::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicCapabilityClient::create(VALUE client, VALUE interschema) {
+
+    VALUE self = alloc(Class);
+    WrappedType* rb_self = unwrap(self);
+    auto dyncap = CapabilityClient::unwrap(client)->castAs<capnp::DynamicCapability>(*InterfaceSchema::unwrap(interschema));
+    new (rb_self) capnp::DynamicCapability::Client(dyncap);
+
+    return self;
+  }
+
+  VALUE DynamicCapabilityClient::create(WrappedType native_client){
+    VALUE self = alloc(Class);
+    WrappedType* rb_self = unwrap(self);
+    new (rb_self) capnp::DynamicCapability::Client(native_client);
+
+    return self;
+  }
+
+  VALUE DynamicCapabilityClient::request_and_send(VALUE self , VALUE rb_method , VALUE arrays){
+    // have, a method and a list of lists each list containing a value to set
+    // return, a remote promise.
+    // Data must be a array of arrays
+    // arrays must be like ['expression','literal','3']
+    // this will set in the expression param literal = 3
+    try{
+      auto* method = InterfaceMethod::unwrap(rb_method);
+      auto  request = unwrap(self)->newRequest(*method);
+
+      RemotePromise::setParam(&request,arrays);
+
+      capnp::RemotePromise<capnp::DynamicStruct> r = request.send();
+      return RemotePromise::create(r);
+    }catch(kj::Exception e){
+      Exception::raise(e);
+    }
+  }
+}

data/ext/capn_proto/dynamic_capability_client.h

@@ -0,0 +1,22 @@
+#ifndef DYNAMIC_CAPABILITY_CLIENT_H
+#define DYNAMIC_CAPABILITY_CLIENT_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicCapabilityClient {
+  public:
+    using WrappedType = capnp::DynamicCapability::Client;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(VALUE capclient, VALUE schema);
+    static VALUE create(WrappedType native_dynclient);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE request_and_send(VALUE self, VALUE method, VALUE data);
+    static VALUE Class;
+  };
+}
+
+
+#endif /* DYNAMIC_CAPABILITY_CLIENT_H */

data/ext/capn_proto/dynamic_list_builder.cc

@@ -0,0 +1,123 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_list_builder.h"
+#include "dynamic_value_builder.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_struct_builder.h"
+#include "exception.h"
+#include "util.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::DynamicList::Builder;
+  VALUE DynamicListBuilder::Class;
+
+  void DynamicListBuilder::Init() {
+    ClassBuilder("DynamicListBuilder", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("[]", &get).
+      defineMethod("[]=", &set).
+      defineMethod("size", &size).
+      store(&Class);
+  }
+
+  VALUE DynamicListBuilder::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  void DynamicListBuilder::free(WrappedType* p) {
+    p->~Builder();
+    ruby_xfree(p);
+  }
+
+  WrappedType* DynamicListBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicListBuilder::create(WrappedType builder, VALUE parent) {
+    auto rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(builder);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE DynamicListBuilder::size(VALUE self) {
+    return INT2FIX(unwrap(self)->size());
+  }
+
+  VALUE DynamicListBuilder::get(VALUE self, VALUE rb_index) {
+    try {
+      return _get(self, rb_index);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicListBuilder::_get(VALUE self, VALUE rb_index) {
+    auto builder = *unwrap(self);
+    auto size = builder.size();
+
+    unsigned long index;
+    if (Util::isNegative(rb_index)) {
+      index = NUM2LONG(rb_index) % builder.size();
+    } else {
+      index = NUM2ULONG(rb_index);
+    }
+
+    // return DynamicValueBuilder::to_ruby(builder.get(field), self);
+    return DynamicValueBuilder::to_ruby(builder[index], self);
+  }
+
+  VALUE DynamicListBuilder::set(VALUE self, VALUE rb_index, VALUE rb_obj) {
+    try {
+      return _set(self, rb_index, rb_obj);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicListBuilder::_set(VALUE self, VALUE rb_index, VALUE rb_obj) {
+    VALUE klass = rb_funcall(rb_obj, rb_intern("class"), 0);
+
+    unsigned long field;
+    if (Util::isNegative(rb_index)) {
+      field = NUM2LONG(rb_index) % unwrap(self)->size();
+    } else {
+      field = NUM2ULONG(rb_index);
+    }
+
+    // TODO: handle assigning lists (see _setDynamicField)
+    if FIXNUM_P(rb_obj) {
+      if (Util::isNegative(rb_obj)) {
+        unwrap(self)->set(field, NUM2LONG(rb_obj));
+      } else {
+        unwrap(self)->set(field, NUM2ULONG(rb_obj));
+      }
+    } else if (RB_TYPE_P(rb_obj, T_FLOAT)) {
+      unwrap(self)->set(field, RFLOAT_VALUE(rb_obj));
+    } else if (rb_obj == Qtrue || rb_obj == Qfalse) {
+      unwrap(self)->set(field, (rb_obj == Qtrue) ? true : false);
+    } else if (RB_TYPE_P(rb_obj, T_STRING)) {
+      // TODO: need to ensure that the UTF8 char buffer is null terminated.
+      // consider something similar to rb_string_value_cstr,
+      // which grows the the buffer if necessary.
+      capnp::DynamicValue::Reader tmp =
+        capnp::Text::Reader(RSTRING_PTR(rb_obj), RSTRING_LEN(rb_obj));
+      unwrap(self)->set(field, tmp);
+    } else if (NIL_P(rb_obj)) {
+      unwrap(self)->set(field, capnp::VOID);
+    } else if (rb_equal(klass, DynamicStructReader::Class)) {
+      unwrap(self)->set(field, *DynamicStructReader::unwrap(rb_obj));
+    } else if (rb_equal(klass, DynamicStructBuilder::Class)) {
+      unwrap(self)->set(field, (*DynamicStructBuilder::unwrap(rb_obj)).asReader());
+    } else {
+      // TODO: raise "Non primitive type"
+    }
+
+    return rb_obj;
+  }
+}