Parent

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 179
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 167
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.
# File lib/ffi/autopointer.rb, line 66
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 93
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 99
def autorelease?
  @releaser.autorelease
end
free() click to toggle source

@return [nil] Free the pointer.

# File lib/ffi/autopointer.rb, line 86
def free
  @releaser.free
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.