class Fiddle::Closure - Documentation for Ruby 3.2

# class Fiddle::Closure

## Description¶ ↑

An FFI closure wrapper, for handling callbacks.

## Example¶ ↑

    closure = Class.new(Fiddle::Closure) {
      def call
        10
      end
    }.new(Fiddle::TYPE_INT, [])
       #=> #<#<Class:0x0000000150d308>:0x0000000150d240>
    func = Fiddle::Function.new(closure, [], Fiddle::TYPE_INT)
       #=> #<Fiddle::Function:0x00000001516e58>
    func.call
       #=> 10

### Attributes

args[R]

arguments of the FFI closure

ctype[R]

the C type of the return of the FFI closure

### Public Class Methods

create(*args) { |closure| ... } click to toggle source

Create a new closure. If a block is given, the created closure is automatically freed after the given block is executed.

The all given arguments are passed to `Fiddle::Closure.new`. So using this method without block equals to `Fiddle::Closure.new`.

## Example¶ ↑

    Fiddle::Closure.create(TYPE_INT, [TYPE_INT]) do |closure|
      # closure is freed automatically when this block is finished.
    end

    # File ext/fiddle/lib/fiddle/closure.rb, line 16
    def create(*args)
      if block_given?
        closure = new(*args)
        begin
          yield(closure)
        ensure
          closure.free
        end
      else
        new(*args)
      end
    end

new(ret, args, abi = Fiddle::DEFAULT) click to toggle source

Construct a new `Closure` object.

- `ret` is the C type to be returned

- `args` is an `Array` of arguments, passed to the callback function

- `abi` is the abi of the closure

If there is an error in preparing the ffi_cif or ffi_prep_closure, then a `RuntimeError` will be raised.

    static VALUE
    initialize(int argc, VALUE *argv, VALUE self)
    {
        initialize_data data;
        data.self = self;
        data.argc = argc;
        data.argv = argv;
        return rb_rescue(initialize_body, (VALUE)&data,
                         initialize_rescue, (VALUE)&data);
    }

### Public Instance Methods

free() click to toggle source

Free this closure explicitly. You can’t use this closure anymore.

If this closure is already freed, this does nothing.

    static VALUE
    closure_free(VALUE self)
    {
        fiddle_closure *closure;
        TypedData_Get_Struct(self, fiddle_closure, &closure_data_type, closure);
        if (closure) {
            dealloc(closure);
            RTYPEDDATA_DATA(self) = NULL;
        }
        return RUBY_Qnil;
    }

freed?() click to toggle source

Whether this closure was freed explicitly.

    static VALUE
    closure_freed_p(VALUE self)
    {
        fiddle_closure *closure;
        TypedData_Get_Struct(self, fiddle_closure, &closure_data_type, closure);
        return closure ? RUBY_Qfalse : RUBY_Qtrue;
    }

to_i() click to toggle source

Returns the memory address for this closure.

    static VALUE
    to_i(VALUE self)
    {
        fiddle_closure *closure = get_raw(self);
        return PTR2NUM(closure->code);
    }