### Home Classes Methods

### In Files

- lib/ffi/autopointer.rb

### Parent

FFI::Pointer

### Namespace

- CLASS FFI::AutoPointer::CallableReleaser
- CLASS FFI::AutoPointer::DefaultReleaser
- CLASS FFI::AutoPointer::Releaser

### Methods

- ::from_native
- ::native_type
- ::new
- #autorelease=
- #autorelease?
- #free

### Files

- Makefile
- LICENSE
- compile
- configure
- depcomp
- stamp-vti
- install-sh
- libtool-version
- mdate-sh
- missing

### Class/Module Index

Quicksearch

- FFI
- FFI::ArrayType
- FFI::AutoPointer
- FFI::AutoPointer::CallableReleaser
- FFI::AutoPointer::DefaultReleaser
- FFI::AutoPointer::Releaser
- FFI::ConstGenerator
- FFI::ConstGenerator::Constant
- FFI::DynamicLibrary
- FFI::DynamicLibrary::Symbol
- FFI::Enum
- FFI::Enums
- FFI::Function
- FFI::Generator
- FFI::Generator::Task
- FFI::IO
- FFI::ManagedStruct
- FFI::Platform
- FFI::PlatformError
- FFI::Pointer
- FFI::StrPtrConverter
- FFI::Struct
- FFI::Struct::InlineArray
- FFI::Struct::ManagedStructConverter
- FFI::StructByReference
- FFI::StructByValue
- FFI::StructGenerator
- FFI::StructGenerator::Field
- FFI::StructLayout
- FFI::StructLayout::Enum
- FFI::StructLayout::InnerStruct
- FFI::StructLayout::Mapped
- FFI::StructLayoutBuilder
- FFI::TypesGenerator
- FFI::Union
- FFI::VariadicInvoker

No matching classes.

# 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.

    # 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

[Validate]

Generated with the Darkfish Rdoc Generator 2.