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
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
@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
@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
@return [Boolean] autorelease Get autorelease property. See {Pointer Autorelease section at Pointer}.
# File lib/ffi/autopointer.rb, line 99 def autorelease? @releaser.autorelease end
Generated with the Darkfish Rdoc Generator 2.