mrubybind automatically creates C function/class-method binder for mruby, using C++ template partial specialization. require C++11. because it use std::function and lambda.
- Put following source codes into your project.
- mrubybind.cc
- mrubybind.h
- Include "mrubybind.h"
- Use
MrubyBindinstance to bind C function/class-method to mruby.
- C function (Any type you want):
int square(int x) {
return x * x;
}- Bind it using mrubybind
bindmethod:
#include "mrubybind.h"
void install_square_function(mrb_state* mrb) {
mrubybind::MrubyBind b(mrb);
b.bind("square", square);
}You can throw away MrubyBind instance after binding function.
- Call it from mruby:
puts square(1111) #=> 1234321- C++ class:
class Foo {
public:
Foo(int x) : x_(x) {
cout << "Foo::ctor(" << x << ")" << endl;
}
virtual ~Foo() {
cout << "Foo::dtor()" << endl;
}
int bar(int y) {
return x_ + y;
}
static int baz(int z) {
return z * z;
}
private:
int x_;
};- Bind C++ class using mrubybind
bind_class,bind_instance_methodandbind_static_methodmethod:
#include "mrubybind.h"
// Helper function for constructor.
Foo* new_foo(int x) {
return new Foo(x);
}
void install_foo_class(mrb_state* mrb) {
mrubybind::MrubyBind b(mrb);
b.bind_class("Foo", new_foo);
b.bind_instance_method("Foo", "bar", &Foo::bar);
b.bind_static_method("Foo", "baz", &Foo::baz);
}- Call it from mruby:
foo = Foo.new(123) #=> Foo::ctor(123)
p foo #=> #<Foo:0x7fa828803d80>
p foo.bar(567) #=> 690
p Foo.baz(9999) #=> 99980001
#=> Foo::dtor()- Pass
RClass*instace forMrubyBindconstructor:
void install(mrb_state* mrb) {
RClass* mod = mrb_define_module(mrb, "YourModule");
mrubybind::MrubyBind b(mrb, mod);
b.bind("foo", foo);
}You can use YourModule.foo function from mruby.
- Use
bind_constmethod:
void install(mrb_state* mrb) {
mrubybind::MrubyBind b(mrb);
b.bind_const("FOO", FOO_VALUE);
}- define C++ function having callback function
std::string call_block(mrubybind::FuncPtr<void(int a0)> f) {
if(f)
{
f.func()(23);
}
return "called\n";
}- Bind it using mrubybind:
#include "mrubybind.h"
void install_call_block_function(mrb_state* mrb) {
mrubybind::MrubyBind b(mrb);
b.bind("call_block", call_block);
}- Call it from mruby:
puts call_block { |a0|
puts "a0 = #{a0}"
}- Define C++ function managing class instance:
class ClassValue{
public:
int a;
ClassValue(){
a = 7;
}
~ClassValue(){
}
void decriment(){
a--;
}
};
std::shared_ptr<ClassValue> create_class_value()
{
return std::shared_ptr<ClassValue>(new ClassValue());
}
void class_value_increment(std::shared_ptr<ClassValue> cv)
{
cv->a++;
}
int class_value_get_a(std::shared_ptr<ClassValue> cv)
{
return cv->a;
}
void class_value_decriment(std::shared_ptr<ClassValue> cv)
{
cv->decriment();
}- Register class and bind function:
#include "mrubybind.h"
void install_class_value_function(mrb_state* mrb) {
mrubybind::MrubyBind b(mrb);
b.bind("create_class_value", create_class_value);
b.bind_class<std::shared_ptr<ClassValue> >("ClassValue");
b.bind("class_value_increment", class_value_increment);
b.bind("class_value_get_a", class_value_get_a);
b.bind_custom_method(NULL, "ClassValue", "decriment", class_value_decriment);
}-
Call it from mruby:
cv = create_class_value puts "cv -> #{class_value_get_a(cv)}" class_value_increment(cv) puts "cv -> #{class_value_get_a cv}" cv.decriment puts "cv -> #{class_value_get_a cv}"
- Recieve mruby object reference function:
mrubybind::MrubyRef mruby_ref;
void set_mruby_ref(mrubybind::MrubyRef r){
mruby_ref = r;
}- Bind it using mrubybind:
#include "mrubybind.h"
void install_mruby_ref_function(mrb_state* mrb) {
mrubybind::MrubyBind b(mrb);
b.bind("set_mruby_ref", set_mruby_ref);
}- Send from mruby code:
set_mruby_ref "3test"- Manage reference of mruby object on C++:
std::cout << "mruby_ref = " << mruby_ref.to_s() << std::endl;
std::cout << "mruby_ref = " << mruby_ref.to_i() << std::endl;
std::cout << "mruby_ref = " << mruby_ref.call("gsub", "te", "toa").to_s() << std::endl;| C++ type | mruby type |
|---|---|
| int, unsigned int | Fixnum |
| float, double | Float |
| const char*, string | String |
| bool | TrueClass or FalseClass |
| void* | Object |
| mrubybind::FuncPtr<...> | Proc |
| mrubybind::MrubyRef | Any Mruby Object |
| registered class | registered class |
See mrubybind.h.
MIT license.