capn_proto-rpc 0.1.1.alpha.rpc

data/ext/capn_proto/flat_array_message_reader.h

@@ -0,0 +1,21 @@
+#ifndef FLAT_ARRAY_MESSAGE_READER_H
+#define FLAT_ARRAY_MESSAGE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class FlatArrayMessageReader {
+  public:
+    using WrappedType = capnp::FlatArrayMessageReader;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE initialize(VALUE klass, VALUE io);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE get_root(VALUE self, VALUE schema);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* FLAT_ARRAY_MESSAGE_READER_H */

data/ext/capn_proto/init.cc

@@ -0,0 +1,71 @@
+#include "ruby_capn_proto.h"
+
+#include "exception.h"
+
+#include "schema_parser.h"
+#include "parsed_schema.h"
+#include "struct_schema.h"
+#include "interface_schema.h"
+#include "interface_method.h"
+
+#include "capability_client.h"
+#include "remote_promise.h"
+#include "call_context.h"
+#include "EzRpc_server.h"
+#include "EzRpc_client.h"
+#include "dynamic_capability_client.h"
+#include "schema_node_reader.h"
+#include "nested_node_reader.h"
+#include "list_nested_node_reader.h"
+#include "field_list.h"
+
+#include "message_reader.h"
+#include "message_builder.h"
+#include "stream_fd_message_reader.h"
+#include "malloc_message_builder.h"
+#include "flat_array_message_reader.h"
+
+#include "dynamic_struct_reader.h"
+#include "dynamic_struct_builder.h"
+#include "dynamic_list_reader.h"
+#include "dynamic_list_builder.h"
+#include "dynamic_object_reader.h"
+#include "dynamic_object_builder.h"
+
+using namespace ruby_capn_proto;
+
+extern "C" {
+  void Init_capn_proto() {
+    Exception::Init();
+
+    SchemaParser::Init();
+    ParsedSchema::Init();
+    StructSchema::Init();
+    InterfaceSchema::Init();
+    InterfaceMethod::Init();
+
+    CapabilityClient::Init();
+    RemotePromise::Init();
+    CallContext::Init();
+    EzRpcCapabilityServer::Init();
+    EzRpcCapabilityClient::Init();
+    DynamicCapabilityClient::Init();
+    SchemaNodeReader::Init();
+    NestedNodeReader::Init();
+    ListNestedNodeReader::Init();
+    FieldList::Init();
+
+    MessageReader::Init();
+    MessageBuilder::Init();
+    StreamFdMessageReader::Init();
+    MallocMessageBuilder::Init();
+    FlatArrayMessageReader::Init();
+
+    DynamicStructReader::Init();
+    DynamicStructBuilder::Init();
+    DynamicListReader::Init();
+    DynamicListBuilder::Init();
+    DynamicObjectReader::Init();
+    DynamicObjectBuilder::Init();
+  }
+}

data/ext/capn_proto/interface_method.cc

@@ -0,0 +1,38 @@
+#include "ruby_capn_proto.h"
+#include "interface_method.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::InterfaceSchema::Method;
+  VALUE InterfaceMethod::Class;
+
+  void InterfaceMethod::Init() {
+    ClassBuilder("InterfaceMethod", rb_cObject).
+      defineAlloc(&alloc).
+      // no methods...
+      store(&Class);
+  }
+
+  void InterfaceMethod::free(WrappedType* p) {
+    p->~Method();
+    ruby_xfree(p);
+  }
+
+  VALUE InterfaceMethod::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* InterfaceMethod::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE InterfaceMethod::create(WrappedType method) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped_method = unwrap(rb_obj);
+    *wrapped_method = kj::mv(method);
+    return rb_obj;
+  }
+}

data/ext/capn_proto/interface_method.h

@@ -0,0 +1,21 @@
+#ifndef INTERFACE_METHOD_SCHEMA_H
+#define INTERFACE_METHOD_SCHEMA_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class InterfaceMethod {
+  public:
+    using WrappedType = capnp::InterfaceSchema::Method;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType method);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    // no methods...
+    static VALUE Class;
+  };
+}
+
+
+#endif /* INTERFACE_METHOD_SCHEMA_H */

data/ext/capn_proto/interface_schema.cc

@@ -0,0 +1,51 @@
+#include "ruby_capn_proto.h"
+#include "interface_schema.h"
+#include "interface_method.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::InterfaceSchema;
+  VALUE InterfaceSchema::Class;
+
+  void InterfaceSchema::Init() {
+    ClassBuilder("InterfaceSchema", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("find_method_by_name" , &find_method_by_name).
+      store(&Class);
+  }
+
+  void InterfaceSchema::free(WrappedType* p) {
+    p->~InterfaceSchema();
+    ruby_xfree(p);
+  }
+
+  VALUE InterfaceSchema::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* InterfaceSchema::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE InterfaceSchema::create(WrappedType schema, VALUE parent) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped_schema = unwrap(rb_obj);
+    *wrapped_schema = kj::mv(schema);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE InterfaceSchema::find_method_by_name(VALUE self, VALUE name){
+    capnp::InterfaceSchema::Method value;
+    KJ_IF_MAYBE(value, unwrap(self)->findMethodByName(Util::toString(name))) {
+      return InterfaceMethod::create(*value);
+    } else {
+      return Qfalse;
+    }
+  }
+}

data/ext/capn_proto/interface_schema.h

@@ -0,0 +1,26 @@
+#ifndef INTERFACE_SCHEMA_H
+#define INTERFACE_SCHEMA_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class InterfaceSchema {
+  public:
+    using WrappedType = capnp::InterfaceSchema;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType schema, VALUE parent);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    // commented methods below don't are strictly needed.
+    //static VALUE getMethodByName(VALUE self, VALUE name);
+    //static VALUE getMethods(VALUE self);
+    static VALUE find_method_by_name(VALUE self, VALUE name);
+
+
+    static VALUE Class;
+  };
+}
+
+
+#endif /* INTERFACE_SCHEMA_H */

data/ext/capn_proto/list_nested_node_reader.cc

@@ -0,0 +1,53 @@
+#include "ruby_capn_proto.h"
+#include "list_nested_node_reader.h"
+#include "nested_node_reader.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using NodeList = ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader;
+
+  VALUE ListNestedNodeReader::Class;
+
+  void ListNestedNodeReader::Init() {
+    ClassBuilder("ListNestedNodeReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("size", &size).
+      defineMethod("[]", &get).
+      store(&Class);
+  }
+
+  void ListNestedNodeReader::free(NodeList* p) {
+    p->~NodeList();
+    ruby_xfree(p);
+  }
+
+  VALUE ListNestedNodeReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(NodeList)));
+  }
+
+  NodeList* ListNestedNodeReader::unwrap(VALUE self) {
+    NodeList* p;
+    Data_Get_Struct(self, NodeList, p);
+    return p;
+  }
+
+  VALUE ListNestedNodeReader::create(NodeList schema, VALUE parent) {
+    VALUE rb_obj = alloc(Class);
+    NodeList* wrapped_schema = unwrap(rb_obj);
+    *wrapped_schema = kj::mv(schema);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE ListNestedNodeReader::size(VALUE self) {
+    return INT2FIX(unwrap(self)->size());
+  }
+
+  VALUE ListNestedNodeReader::get(VALUE self, VALUE index) {
+    auto idx = FIX2INT(index);
+    auto list = *unwrap(self);
+    return NestedNodeReader::create(list[idx]);
+  }
+}

data/ext/capn_proto/list_nested_node_reader.h

@@ -0,0 +1,24 @@
+#ifndef LIST_NESTED_NODE_READER_H
+#define LIST_NESTED_NODE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class ListNestedNodeReader {
+  public:
+    using NodeList = ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader;
+
+    static void Init();
+    static VALUE initialize(VALUE klass);
+    static VALUE alloc(VALUE klass);
+    static void free(NodeList* p);
+    static NodeList* unwrap(VALUE self);
+    static VALUE create(NodeList reader, VALUE parent);
+    static VALUE size(VALUE self);
+    static VALUE get(VALUE self, VALUE index);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* LIST_NESTED_NODE_READER_H */

data/ext/capn_proto/malloc_message_builder.cc

@@ -0,0 +1,51 @@
+#include "ruby_capn_proto.h"
+#include "malloc_message_builder.h"
+#include "message_builder.h"
+#include "struct_schema.h"
+#include "dynamic_struct_builder.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::MallocMessageBuilder;
+  VALUE MallocMessageBuilder::Class;
+
+  void MallocMessageBuilder::Init() {
+    ClassBuilder("MallocMessageBuilder", MessageBuilder::Class).
+      defineAlloc(&alloc).
+      defineMethod("initialize", &initialize).
+      defineMethod("init_root", &init_root).
+      // defineMethod("get_root", &get_root).
+      store(&Class);
+  }
+
+  VALUE MallocMessageBuilder::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE MallocMessageBuilder::initialize(VALUE self) {
+    WrappedType* p = unwrap(self);
+    new (p) WrappedType();
+    return Qnil;
+  }
+
+  void MallocMessageBuilder::free(WrappedType* p) {
+    p->~MallocMessageBuilder();
+    ruby_xfree(p);
+  }
+
+  WrappedType* MallocMessageBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE MallocMessageBuilder::init_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 builder = unwrap(self)->initRoot<capnp::DynamicStruct>(schema);
+    return DynamicStructBuilder::create(builder, self, true);
+  }
+}

data/ext/capn_proto/malloc_message_builder.h

@@ -0,0 +1,21 @@
+#ifndef MALLOC_MESSAGE_BUILDER_H
+#define MALLOC_MESSAGE_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class MallocMessageBuilder {
+  public:
+    using WrappedType = capnp::MallocMessageBuilder;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE initialize(VALUE klass);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE init_root(VALUE name, VALUE schema);
+
+    static VALUE Class;
+  };
+}
+
+#endif

data/ext/capn_proto/message_builder.cc

@@ -0,0 +1,22 @@
+#include "ruby_capn_proto.h"
+#include "message_builder.h"
+#include "class_builder.h"
+#include "struct_schema.h"
+#include "dynamic_struct_reader.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::MessageBuilder;
+  VALUE MessageBuilder::Class;
+
+  void MessageBuilder::Init() {
+    ClassBuilder("MessageBuilder", rb_cObject).
+      store(&Class);
+  }
+
+  WrappedType* MessageBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+}

data/ext/capn_proto/message_builder.h

@@ -0,0 +1,17 @@
+#ifndef MESSAGE_BUILDER_H
+#define MESSAGE_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class MessageBuilder {
+  public:
+    using WrappedType = capnp::MessageBuilder;
+    static void Init();
+    static WrappedType* unwrap(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* MESSAGE_BUILDER_H */

data/ext/capn_proto/message_reader.cc

@@ -0,0 +1,30 @@
+#include "ruby_capn_proto.h"
+#include "message_reader.h"
+#include "class_builder.h"
+#include "struct_schema.h"
+#include "dynamic_struct_reader.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::MessageReader;
+  VALUE MessageReader::Class;
+
+  void MessageReader::Init() {
+    ClassBuilder("MessageReader", rb_cObject).
+      store(&Class);
+  }
+
+  // XXX
+  // I wanted to use inheritance here for #get_root,
+  // but this segfaults unless I reinterpret_cast to the right
+  // subclass of capnp::MessageReader. Whish I know more about
+  // the C++ object model :(...
+  // Worst case scenario, I could probably use tempalates...
+  // If only I had experience with them.
+
+  WrappedType* MessageReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+}