class FFI::AutoPointer
Public Class Methods
from_native(val, ctx)
click to toggle source
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]
# File lib/ffi/autopointer.rb, line 189 def self.from_native(val, ctx) self.new(val) end
native_type()
click to toggle source
Return native type of AutoPointer.
Override {DataConverter#native_type}. @return [Type::POINTER] @raise
{RuntimeError} if class does not implement a #release
method
# File lib/ffi/autopointer.rb, line 177 def self.native_type raise RuntimeError.new("no release method defined for #{self.inspect}") unless self.respond_to?(:release) Type::POINTER end
new(ptr, proc=nil, &block)
click to toggle source
@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.
Calls superclass method
# File lib/ffi/autopointer.rb, line 76 def initialize(ptr, proc=nil, &block) super(ptr.type_size, ptr) raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer) @releaser = if proc raise RuntimeError.new("proc must be callable") unless proc.respond_to?(:call) CallableReleaser.new(ptr, proc) else raise RuntimeError.new("no release method defined") unless self.class.respond_to?(:release) DefaultReleaser.new(ptr, self.class) end ObjectSpace.define_finalizer(self, @releaser) self end
Public Instance Methods
autorelease=(autorelease)
click to toggle source
@param [Boolean] autorelease @return [Boolean] autorelease
Set
autorelease
property. See {Pointer Autorelease section at
Pointer}.
# File lib/ffi/autopointer.rb, line 103 def autorelease=(autorelease) @releaser.autorelease=(autorelease) end
autorelease?()
click to toggle source
@return [Boolean] autorelease
Get autorelease
property. See {Pointer Autorelease section at Pointer}.
# File lib/ffi/autopointer.rb, line 109 def autorelease? @releaser.autorelease end
free()
click to toggle source
@return [nil] Free the pointer.
# File lib/ffi/autopointer.rb, line 96 def free @releaser.free end