MqCall_rb.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#include "LibMqMsgque_private_rb.h"
#include "misc_check_rb.h"
 
/* LABEL-END */
 
mk_inline VALUE NS(sRescue) (
  MK_RT_ARGS
  MK_MNG const mng,
  VALUE(*proc)(ANYARGS),
  VALUE data
) {
  int state;
  VALUE ret = rb_protect(proc, data, &state);
  if (state) {
    OT_ERROR_LNG_2_META_2(mng,"ProcessEvent");
  }
  return ret;
}
 
// ==========================================================================
 
// method callback without self
static VALUE NS(sCallMethodWithoutSelf) (VALUE method) {
  return rb_method_call(0, NULL, method);
}
 
// method callback with self
static VALUE NS(sCallMethodWithSelf) (VALUE array) {
  const VALUE *valP = rb_array_const_ptr(array);
  return rb_method_call(1, &valP[0], valP[1]);
}
 
// proc callback with self
static VALUE NS(sCallProcWithSelf) (VALUE array) {
  const VALUE *valP = rb_array_const_ptr(array);
  return rb_proc_call_with_block(valP[1], 1, &valP[0], Qnil);
}
 
// ==========================================================================
// the global "Proc"
/*
[ServiceCall signature]
  1. The *service-ctx* is the *context* for which the service was defined.
 
  callback-args := service-ctx:MqContextC[in]
  [static]   def callback ( callback-args )
  [instance] class YYY
               def callback ( callback-args )
  [class]    class ZZZ 
               def self.callback ( callback-args )
[ServiceCall signature]
*/
 
enum MkErrorE NS(ServiceCall) ( MQ_SERVICE_CALL_ARGS )
{ 
  MQ_SERVICE_CALL_CHECK;
 
  struct MkCallS *call = __data__;
  int argNum = 1;
 
  if (!MqCtxCheck(mqctx)) {
    mk_dbg_color_ln(MK_COLOR_RED, "%s", "mqctx invalid");
  }
  if (!MqCtxCheck(call->hdl)) {
    mk_dbg_color_ln(MK_COLOR_RED, "%s", "call->hdl invalid");
  }
 
  // 1. check environment
  if (OT_LNG_NULL_IS(call->procCallback)) return MK_OK;
 
//MkDbgDeepX_3(mqctx, "AAA", "cmd=%s", VAL2STRN(rb_inspect(call->procCallback)));
 
  // 2. if not already done initialize
  if (call->procCall == NULL) {
    assert(!OT_LNG_NULL_IS(call->procArgs));
    switch (call->procType) {
      case MkCallS_own_method: {
        OT_SETUP_self
        argNum = rb_equal(rb_funcallv(call->procCallback,MK(id_receiver),0,NULL),self) ? 0 : 1;
        if (argNum > call->procArity) goto methode_arg_error;
        if (call->procArity == 0) {
          call->procNeedSelf = false;
          call->procCall = NS(sCallMethodWithoutSelf);
        } else {
          call->procNeedSelf = true;
          call->procCall = NS(sCallMethodWithSelf);
        }
      }
      break;
      case MkCallS_proc:
        call->procNeedSelf = true;
        call->procCall = NS(sCallProcWithSelf);
        if (argNum != call->procArity) goto methode_arg_error;
      break;
      default:
        MkErrorSetV_3M(mqctx, "WrongInitError", "found invalid procType for callback '%s'", VAL2STRN(call->procCallback));
        goto error;
      break;
    }
  }
 
  // 3. call callback
  if (call->procNeedSelf == false) {
    // without "self"
    if (rb_obj_is_kind_of(call->procCallback, rb_cMethod) != Qtrue) {
      mk_dbg_color_ln(MK_COLOR_RED, "%s", "call->procCallback invalid");
    }
    NS(sRescue)(MK_RT_CALL mqctx,call->procCall,call->procCallback);
  } else {
    // with "self"
    OT_SETUP_self;
    VALUE ary = rb_ary_resize(call->procArgs,2);
    rb_ary_store(ary,0,self);
    rb_ary_store(ary,1,call->procCallback);
    NS(sRescue)(MK_RT_CALL mqctx,call->procCall,ary);
  }
  MkErrorCheck_0E();
 
MkDbgDeepX_3(mqctx, "BBB", "cmd=%s", VAL2STRN(rb_inspect(call->procCallback)));
  return MkErrorGetCode_0E();
 
methode_arg_error:
  MkErrorSetV_3M(mqctx, "WrongNumberOfArgError", "for callback '%s' exactly '%d' argument is required, but '%d' was received", 
    VAL2STRN(call->procCallback), argNum, call->procArity);
  goto error;
 
error:
MkDbgDeepX_3(mqctx, "EEE", "cmd=%s", VAL2STRN(rb_inspect(call->procCallback)));
//printSTACK_1(mqctx)
  return MkErrorStack_0E();
}
 
void NS(ServiceFree) ( MQ_SERVICE_FREE_ARGS ) {
  MK(CallFree)(dataP);
}
 
VALUE NS(sCopyWithSelf) (MQ_CTX const mqctx, VALUE meth) {
  MkRtSetup_X(mqctx);
  OT_SETUP_self;
  meth = rb_funcallv(meth,MK(id_clone),0,NULL);
  meth = rb_funcallv(meth,MK(id_unbind),0,NULL);
  meth = rb_funcall(meth,MK(id_bind),1,self);
  return meth;
}
 
VALUE NS(sCopyWithoutSelf) (MQ_CTX const mqctx, VALUE proc) {
  return rb_funcallv(proc,MK(id_clone),0,NULL);
}
 
void NS(ServiceCopy) ( MQ_SERVICE_COPY_ARGS ) {
  struct MkCallS *call = *dataP = MkSysMemDup(MK_ERROR_PANIC, *dataP, sizeof(struct MkCallS));
 
  if (call->procNeedSelf) {
    call->procCallback = NS(sRescue)(MK_RT_CALL mqctx, NS(sCopyWithSelf), call->procCallback);
  } else {
    call->procCallback = NS(sRescue)(MK_RT_CALL mqctx, NS(sCopyWithoutSelf), call->procCallback);
  }
  INCR_REF(&call->procCallback);
}
 
void NS(ProcMark) (MK_RT_ARGS MK_PTR data) {
  struct MkCallS *call = (struct MkCallS*) data;
//printV("call=%p, data=%p\n", call, call->procCallback)
  rb_gc_mark(call->procCallback);
}
 
// ==========================================================================
 
 
#include "tmpl/mq_misc_check_lng.h"
 
enum MkErrorE NS(CheckConstructor) (
  OT_Check_ARGS,
  MK_CCP          *retP
) 
{
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
    goto error;
  }
  OT_OBJ_T objV = OT_LNG_OBJV((*skipP)++);
  if (rb_class_inherited_p(objV,MQ(MqContextC)) != Qnil) {
    *retP = (MK_CCP) objV;
  } else if (rb_class_inherited_p(objV,MK(MkObjectC)) != Qnil) {
    WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(NS(MqContextC)), OT_LNG_NAME_FROM_CLASS(objV));
  } else {
    WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(NS(MqContextC)), OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK;
error:
  return OT_ERROR_STACK;
}