### Home Classes Methods

### In Files

- ext/ffi_c/ffi.c

### Parent

Object

### Methods

- ::new
- #[]
- #[]=
- #each
- #size
- #to_a
- #to_ptr

### Included Modules

- Enumerable

### 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::Struct::InlineArray

### Public Class Methods

initialize(memory, field) click to toggle source
@param [AbstractMemory] memory
@param [StructField] field
@return [self]

    static VALUE
    inline_array_initialize(VALUE self, VALUE rbMemory, VALUE rbField)
    {
        InlineArray* array;

        Data_Get_Struct(self, InlineArray, array);
        array->rbMemory = rbMemory;
        array->rbField = rbField;

        Data_Get_Struct(rbMemory, AbstractMemory, array->memory);
        Data_Get_Struct(rbField, StructField, array->field);
        Data_Get_Struct(array->field->rbType, ArrayType, array->arrayType);
        Data_Get_Struct(array->arrayType->rbComponentType, Type, array->componentType);

        array->op = get_memory_op(array->componentType);
        if (array->op == NULL && array->componentType->nativeType == NATIVE_MAPPED) {
            array->op = get_memory_op(((MappedType *) array->componentType)->type);
        }

        array->length = array->arrayType->length;

        return self;
    }

### Public Instance Methods

[](index) click to toggle source
@param [Numeric] index
@return [Type, Struct]

    static VALUE
    inline_array_aref(VALUE self, VALUE rbIndex)
    {
        InlineArray* array;

        Data_Get_Struct(self, InlineArray, array);

        if (array->op != NULL) {
            VALUE rbNativeValue = array->op->get(array->memory,
                    inline_array_offset(array, NUM2INT(rbIndex)));
            if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
                return rb_funcall(((MappedType *) array->componentType)->rbConverter,
                        rb_intern("from_native"), 2, rbNativeValue, Qnil);
            } else {
                return rbNativeValue;
            }

        } else if (array->componentType->nativeType == NATIVE_STRUCT) {
            VALUE rbOffset = INT2NUM(inline_array_offset(array, NUM2INT(rbIndex)));
            VALUE rbLength = INT2NUM(array->componentType->ffiType->size);
            VALUE rbPointer = rb_funcall(array->rbMemory, rb_intern("slice"), 2, rbOffset, rbLength);

            return rb_class_new_instance(1, &rbPointer, ((StructByValue *) array->componentType)->rbStructClass);
        } else {

            rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(array->arrayType->rbComponentType));
            return Qnil;
        }
    }

[]=(index, value) click to toggle source
@param [Numeric] index
@param [Type, Struct]
@return [value]

    static VALUE
    inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
    {
        InlineArray* array;

        Data_Get_Struct(self, InlineArray, array);

        if (array->op != NULL) {
            if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
                rbValue = rb_funcall(((MappedType *) array->componentType)->rbConverter,
                        rb_intern("to_native"), 2, rbValue, Qnil);
            }
            array->op->put(array->memory, inline_array_offset(array, NUM2INT(rbIndex)),
                rbValue);

        } else if (array->componentType->nativeType == NATIVE_STRUCT) {
            int offset = inline_array_offset(array, NUM2INT(rbIndex));
            Struct* s;

            if (!rb_obj_is_kind_of(rbValue, rbffi_StructClass)) {
                rb_raise(rb_eTypeError, "argument not an instance of struct");
                return Qnil;
            }

            checkWrite(array->memory);
            checkBounds(array->memory, offset, array->componentType->ffiType->size);

            Data_Get_Struct(rbValue, Struct, s);
            checkRead(s->pointer);
            checkBounds(s->pointer, 0, array->componentType->ffiType->size);

            memcpy(array->memory->address + offset, s->pointer->address, array->componentType->ffiType->size);

        } else {
            ArrayType* arrayType;
            Data_Get_Struct(array->field->rbType, ArrayType, arrayType);

            rb_raise(rb_eArgError, "set not supported for %s", rb_obj_classname(arrayType->rbComponentType));
            return Qnil;
        }

        return rbValue;
    }

each click to toggle source
Yield block for each element of +self+.

    static VALUE
    inline_array_each(VALUE self)
    {
        InlineArray* array;

        int i;

        Data_Get_Struct(self, InlineArray, array);

        for (i = 0; i < array->length; ++i) {
            rb_yield(inline_array_aref(self, INT2FIX(i)));
        }

        return self;
    }

size click to toggle source
@return [Numeric]
Get size

    static VALUE
    inline_array_size(VALUE self)
    {
        InlineArray* array;

        Data_Get_Struct(self, InlineArray, array);

        return UINT2NUM(((ArrayType *) array->field->type)->length);
    }

to_a click to toggle source
@return [Array]
Convert +self+ to an array.

    static VALUE
    inline_array_to_a(VALUE self)
    {
        InlineArray* array;
        VALUE obj;
        int i;

        Data_Get_Struct(self, InlineArray, array);
        obj = rb_ary_new2(array->length);

        for (i = 0; i < array->length; ++i) {
            rb_ary_push(obj, inline_array_aref(self, INT2FIX(i)));
        }

        return obj;
    }

to_ptr click to toggle source
@return [AbstractMemory]
Get pointer to +self+ content.

    static VALUE
    inline_array_to_ptr(VALUE self)
    {
        InlineArray* array;

        Data_Get_Struct(self, InlineArray, array);

        return rb_funcall(array->rbMemory, rb_intern("slice"), 2,
            UINT2NUM(array->field->offset), UINT2NUM(array->arrayType->base.ffiType->size));
    }

[Validate]

Generated with the Darkfish Rdoc Generator 2.