class FFI::AutoPointer

def autorelease=(autorelease)
  @releaser.autorelease=(autorelease)
end

def free
  @releaser.free
end

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

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

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

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

idiom is to pass a Method as the second parameter. Example usage:
Please note that the safest, and therefore preferred, calling

WARNING: passing a block will cause your pointer to never be GC'd. This is bad.
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.

AutoPointer.new(pointer) => the pointer's release() class method will be invoked at GC time
AutoPointer.new(pointer) { |p| ... } => the passed block will be invoked at GC time (SEE WARNING BELOW!)
AutoPointer.new(pointer, proc) => the passed Proc will be invoked at GC time (SEE WARNING BELOW!)
AutoPointer.new(pointer, method) => the passed Method will be invoked at GC time
call-seq:

def initialize(ptr, proc=nil, &block)
  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
  self.parent = ptr
  ObjectSpace.define_finalizer(self, @releaser)
  self
end