使用Rice使用C ++构建Ruby扩展：如何将Ruby方法的指针（回调）传递给C ++函数？

Question

我有一个很酷的C ++库，名为libcage 。 我需要从Ruby脚本调用库中的类方法。 我正在使用Rice使用C ++构建Ruby扩展 。

一种方法， join从一个类cage使用参数作为指针给回调函数。 C ++中回调的简化示例性用法示例：

/* File example.cpp */
#include <libcage/cage.hpp>

void joinCallback(bool joinResult) {
    // do something
}
int main(int argc, char *argv[]) {
    libcage::cage *cage = new libcage::cage;
    cage->join("localhost", 80, &joinCallback);
}
/* End of file example.cpp */

某些事件后， join方法将调用callback函数。 没问题，但是我想在Ruby中定义回调函数！

# File example.rb
require './rb_libcage'  # C++ extension library

def joinCallback(joinResult)
    # do something
end

cage = Cage.new
cage.join "localhost", 80, method(:joinCallback)
# End of file example.rb

现在不起作用。 我不知道如何通过以下示例中的调用参数callback_to_ruby 将Ruby方法的指针传递给C ++函数 。

---

编辑：

我现在实际上有这个：

/* File rb_libcage.cpp */
#include "rice/Class.hpp"
#include "rice/Data_Type.hpp"
#include "rice/Constructor.hpp"

#include "cage.hpp"

Rice::Object __callback_to_ruby;
ID           __callback_id_to_ruby;

namespace {
    void c_callback(bool result)
    {
        if (result)
                    std::cout << "join: succeeded" << std::endl;
            else
                    std::cout << "join: failed" << std::endl;

            /* This does not work! */
            __callback_to_ruby.call(__callback_id_to_ruby,"AsyncCallback"); 
            /**
             * terminate called after throwing an instance of 'Rice::Exception'
             *  what():  undefined method `call' for "AsyncCallback":String
             * Aborted
         */
    }
    class Cage_wrapper
    {
        public:
            Cage_wrapper() : cage(new libcage::cage()) {}

            void join(std::string host, int port, Rice::Object callback_to_ruby) {
                __callback_to_ruby = callback_to_ruby;
                __callback_id_to_ruby = rb_intern("call");
                __callback_to_ruby.call(__callback_id_to_ruby,"test"); /* This works! */

                /* cage->join() will make another thread that will call ASYNCHRONOUSLY c_callback function */
                cage->join(host, port, &c_callback); 
            }
        private:
            libcage::cage *cage;
    };

    extern "C"
    void Init_rb_libcage(void)
    {
        RUBY_TRY
        {
            Rice::define_class<Cage_wrapper>("Cage")
                .define_constructor(Rice::Constructor<Cage_wrapper>())
                .define_method("join", &Cage_wrapper::join);
        }
        RUBY_CATCH
    }
} // namespace
/* End of file rb_libcage.cpp */

和Ruby脚本：

# File example.rb
require './rb_libcage'  # C++ extension library

ruby_callback = lambda {|x| print "From ruby script join result: ", x, "\n" }
cage = Cage.new
cage.join "localhost", 80, ruby_callback
puts 'After join'
# End of file example.rb

rb_libcage.cpp是可编译的，运行example.rb如下所示：

From ruby script join result: test
After join
join: succeeded
terminate called after throwing an instance of 'Rice::Exception'
  what():  undefined method `call' for "AsyncCallback":String
Aborted

我可以调用同步回调，但不能调用异步回调。 会失去语境吗？ 如何成功从C ++代码异步调用ruby回调？

最好的问候，帕维尔

PS：我发现了有关在Ruby C扩展中构建异步回调的有用文章。

Answer 1

我不是红宝石专家，但我在想Cage_wrapper.join方法签名可能看起来更像

void join(std::string host, int port, Rice::Object *ruby_proc)

您可以将ruby proc用作本机库的回调。 即Rice :: Object是红宝石处理程序。

然后在某个时候，您将要执行ruby_proc.call（）。 因此，您可能需要将对ruby_proc.call的调用包装在一个可调用于本机笼连接的回调中。