Class | FFI::AutoPointer
In: | lib/ffi/autopointer.rb
Parent: | Pointer

### Methods

autorelease= free from_native native_type new

### Classes and Modules

Class FFI::AutoPointer::CallableReleaser
Class FFI::AutoPointer::DefaultReleaser
Class FFI::AutoPointer::Releaser

### Public Class methods

from_native(val, ctx)

Create a new AutoPointer.

Override {DataConverter#from_native}. @overload self.from_native(ptr, ctx) @param [Pointer] ptr @param ctx not used. Please set `nil`. @return [AutoPointer]

native_type()

Return native type of AutoPointer.

Override {DataConverter#native_type}. @return [Type::POINTER] @raise {RuntimeError} if class does not implement a +release+ method

new(ptr, proc=nil, &block)

@overload initialize(pointer, method)

     @param [Pointer] pointer
     @param [Method] method
     @return [self]
     The passed Method will be invoked at GC time.

@overload initialize(pointer, proc)

     @param [Pointer] pointer
     @return [self]
     The passed Proc will be invoked at GC time (SEE WARNING BELOW!)
     @note WARNING: passing a proc _may_ cause your pointer to never be GC'd, unless you're
      careful to avoid trapping a reference to the pointer in the proc. See the test
      specs for examples.

@overload initialize(pointer) { |p| … }

     @param [Pointer] pointer
     @yieldparam [Pointer] p +pointer+ passed to the block
     @return [self]
     The passed block will be invoked at GC time.
     @note WARNING: passing a block will cause your pointer to never be GC'd. This is bad.

@overload initialize(pointer)

     @param [Pointer] pointer
     @return [self]
     The pointer's release() class method will be invoked at GC time.

@note The safest, and therefore preferred, calling

     idiom is to pass a Method as the second parameter. Example usage:

      class PointerHelper
        def self.release(pointer)
          ...
        end
      end

      p = AutoPointer.new(other_pointer, PointerHelper.method(:release))

     The above code will cause PointerHelper#release to be invoked at GC time.

@note

     The last calling idiom (only one parameter) is generally only
     going to be useful if you subclass {AutoPointer}, and override
     #release, which by default does nothing.

### Public Instance methods

autorelease=(autorelease)

@param [Boolean] autorelease @return [Boolean] `autorelease` Set `autorelease` property. See {Pointer Autorelease section at Pointer}.

free()

@return [nil] Free the pointer.

[Validate]