Wrapping Data in Ruby Objects

rb_iv_set(rb_obj, "@ptr", LONG2NUM((long)ptr))

Encapsulate C data into Ruby object

To wrap and objectify a C pointer as a Ruby object (so called DATA), use Data_Wrap_Struct().

Data_Wrap_Struct(klass, mark, free, ptr)

Data_Wrap_Struct() returns a created DATA object. The klass argument is the class for the DATA object. The mark argument is the function to mark Ruby objects pointed by this data. The free argument is the function to free the pointer allocation. If this is -1, the pointer will be just freed. The functions mark and free will be called from garbage collector.

You can allocate and wrap the structure in one step.

Data_Make_Struct(klass, type, mark, free, sval)

This macro returns an allocated Data object, wrapping the pointer to the structure, which is also allocated. This macro works like:

(sval = ALLOC(type), Data_Wrap_Struct(klass, mark, free, sval))

Arguments klass, mark, and free work like their counterparts in Data_Wrap_Struct(). A pointer to the allocated structure will be assigned to sval, which should be a pointer of the type specified.

To retrieve the C pointer from the Data object, use the macro Data_Get_Struct().

Data_Get_Struct(obj, type, sval)

A pointer to the structure will be assigned to the variable sval.

void markf(cstruct_type *ptr) { rb_gc_mark(ptr->related_val);}

void freef(cstruct_type *ptr) { delete ptr;}

class Objects {
private:
    VALUE objects;
public:
    Objects() {
        objects = rb_ary_new();
        rb_gc_register_address(&objects);
    }
    ~Objects() {
        // dispose array and flush all elements
        rb_gc_unregister_address(&objects);
        /*      
        mass destruction. GC can no longer
        mark the elements in the Array and 
        therefore they will all get swept.
        */
    }
    void Register(VALUE object) {
        rb_ary_push(objects, object);
    }
    void Unregister(VALUE object) {
        rb_ary_delete(objects, object);
    }
};