Class | FFI::AutoPointer |
In: |
lib/ffi/autopointer.rb
|
Parent: | Pointer |
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]
Return native type of AutoPointer.
Override {DataConverter#native_type}. @return [Type::POINTER] @raise {RuntimeError} if class does not implement a +release+ method
@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.