void registerDataType(VALUE klass, RUBY_DATA_FUNC freefunc, size_t (*sizefunc)(const void *))
{
if(!NIL_P(klass))
{
rb_data_type_t *parent = NULL;
if(rb_obj_is_kind_of(klass, rb_cClass)) {
parent = unwrapDataType(rb_class_superclass(klass));
//if the class does include EvtHandler,
// add it as a parent if class doesnt already have one
if(!parent && rb_class_inherited_p(klass, rb_mWXEvtHandler) == Qtrue) {
parent = unwrapDataType(rb_mWXEvtHandler);
}
}
rb_data_type_t str = {
rb_class2name(klass),
{0, freefunc, sizefunc,},
parent, NULL,
};
datatypeholder[klass] = str;
if(freefunc) {
rb_data_type_t str_const = {
(std::string(rb_class2name(klass)) + "(const)").c_str(),
{0, 0, sizefunc,},
&datatypeholder[klass], NULL,
};
datatypeholder_const[klass] = str_const;
}else {
datatypeholder_const[klass] = str;
}
}
}
/*
* call-seq: initialize(struc_class)
* @param [Struct] struct_calss
* @return [self]
* A new instance of StructByReference.
*/
static VALUE
sbr_initialize(VALUE self, VALUE rbStructClass)
{
StructByReference* sbr = NULL;
if (!rb_class_inherited_p(rbStructClass, rbffi_StructClass)) {
rb_raise(rb_eTypeError, "wrong type (expected subclass of FFI::Struct)");
}
Data_Get_Struct(self, StructByReference, sbr);
sbr->rbStructClass = rbStructClass;
return self;
}
VALUE
numo_na_upcast(VALUE type1, VALUE type2)
{
VALUE upcast_hash;
VALUE result_type;
if (type1==type2) {
return type1;
}
upcast_hash = rb_const_get(type1, rb_intern("UPCAST"));
result_type = rb_hash_aref(upcast_hash, type2);
if (NIL_P(result_type)) {
if (TYPE(type2)==T_CLASS) {
if (RTEST(rb_class_inherited_p(type2,cNArray))) {
upcast_hash = rb_const_get(type2, rb_intern("UPCAST"));
result_type = rb_hash_aref(upcast_hash, type1);
}
}
}
return result_type;
}
VALUE
na_make_view_struct(VALUE self, VALUE dtype, VALUE offset)
{
size_t i, n;
int j, k, ndim;
size_t *shape;
size_t *idx1, *idx2;
ssize_t stride;
stridx_t *stridx;
narray_t *na, *nt;
narray_view_t *na1, *na2;
VALUE klass;
volatile VALUE view;
GetNArray(self,na);
// build from Numo::Struct
if (rb_obj_is_kind_of(dtype,cNArray)) {
GetNArray(dtype,nt);
ndim = na->ndim + nt->ndim;
shape = ALLOCA_N(size_t,ndim);
// struct dimensions
for (j=0; j<na->ndim; j++) {
shape[j] = na->shape[j];
}
// member dimension
for (j=na->ndim,k=0; j<ndim; j++,k++) {
shape[j] = nt->shape[k];
}
klass = CLASS_OF(dtype);
stridx = ALLOC_N(stridx_t, ndim);
stride = na_dtype_elmsz(klass);
for (j=ndim,k=nt->ndim; k; ) {
SDX_SET_STRIDE(stridx[--j],stride);
stride *= nt->shape[--k];
}
} else {
ndim = na->ndim;
shape = ALLOCA_N(size_t,ndim);
for (j=0; j<ndim; j++) {
shape[j] = na->shape[j];
}
klass = CLASS_OF(self);
if (TYPE(dtype)==T_CLASS) {
if (RTEST(rb_class_inherited_p(dtype,cNArray))) {
klass = dtype;
}
}
stridx = ALLOC_N(stridx_t, ndim);
}
view = na_s_allocate_view(klass);
na_copy_flags(self, view);
GetNArrayView(view, na2);
na_setup_shape((narray_t*)na2, ndim, shape);
na2->stridx = stridx;
switch(na->type) {
case NARRAY_DATA_T:
case NARRAY_FILEMAP_T:
stride = na_get_elmsz(self);
for (j=na->ndim; j--;) {
SDX_SET_STRIDE(na2->stridx[j], stride);
stride *= na->shape[j];
}
na2->offset = 0;
na2->data = self;
break;
case NARRAY_VIEW_T:
GetNArrayView(self, na1);
for (j=na1->base.ndim; j--; ) {
if (SDX_IS_INDEX(na1->stridx[j])) {
n = na1->base.shape[j];
idx1 = SDX_GET_INDEX(na1->stridx[j]);
idx2 = ALLOC_N(size_t, na1->base.shape[j]);
for (i=0; i<n; i++) {
idx2[i] = idx1[i];
}
SDX_SET_INDEX(na2->stridx[j],idx2);
} else {
na2->stridx[j] = na1->stridx[j];
}
}
na2->offset = na1->offset;
na2->data = na1->data;
break;
}
if (RTEST(offset)) {
na2->offset += NUM2SIZET(offset);
}
return view;
}
static VALUE
rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
{
ID id;
VALUE body;
NODE *node;
int noex = NOEX_PUBLIC;
if (argc == 1) {
id = rb_to_id(argv[0]);
body = rb_block_lambda();
}
else if (argc == 2) {
id = rb_to_id(argv[0]);
body = argv[1];
if (!rb_obj_is_method(body) && !rb_obj_is_proc(body)) {
rb_raise(rb_eTypeError,
"wrong argument type %s (expected Proc/Method)",
rb_obj_classname(body));
}
}
else {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
}
if (RDATA(body)->dmark == (RUBY_DATA_FUNC) bm_mark) {
struct METHOD *method = (struct METHOD *)DATA_PTR(body);
VALUE rklass = method->rklass;
if (rklass != mod) {
if (FL_TEST(rklass, FL_SINGLETON)) {
rb_raise(rb_eTypeError,
"can't bind singleton method to a different class");
}
if (!RTEST(rb_class_inherited_p(mod, rklass))) {
rb_raise(rb_eTypeError,
"bind argument must be a subclass of %s",
rb_class2name(rklass));
}
}
node = method->body;
}
else if (rb_obj_is_proc(body)) {
rb_proc_t *proc;
body = proc_dup(body);
GetProcPtr(body, proc);
if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) {
proc->block.iseq->defined_method_id = id;
proc->block.iseq->klass = mod;
proc->is_lambda = Qtrue;
}
node = NEW_BMETHOD(body);
}
else {
/* type error */
rb_raise(rb_eTypeError, "wrong argument type (expected Proc/Method)");
}
/* TODO: visibility */
rb_add_method(mod, id, node, noex);
return body;
}
