MqFactoryC_rb.c

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#define SetupRtFromObj(hd)  AllRtSetup_NULL
 
/* LABEL-START */
#define META_FILE_NAME "MqFactoryC_rb.c"
 
#include  "LibMqMsgque_private_rb.h"
 
#define OT_CLASS            NS(MqFactoryC)
#define OT_CLASS_NAME       "MqFactoryC"
 
#define OT_LNG2META(O)      MqFct(VAL2MNG(O))
 
OT_CLS_T OT_CLASS;
 
// new Class type object
static MK_TYP MqFactoryCTT = NULL;
OT_OBJ_T MQ(MqFactoryC_MK_NULL) = 0;
 
// GS marker in "Data_Wrap_Struct"
static void  NS(sMark)    (MK_PTR);
 
// ruby datatype of the wrapped struct
static rb_data_type_t NS(MqFactoryC_T) = {
  "MqFactoryC",
  {
    NS(sMark),
    MK(AtomDeleteSoft),
    0, /* dsize */
    0, /* reserved[1] */
  },
  NULL, /* parent */
  NULL, /* data */
  RUBY_TYPED_FREE_IMMEDIATELY
};
 
// >>THIS<< is a Phase-1-CONSTRUCTOR: a constructor which create the SELF object
// A Phase-2-CONSTRUCTOR is a constructor which configure an already existing object
// DO: create a new SELF and link this SELF with the MQ-Object "mng"
// clazz is the toplevel "subclass" or "MqFactoryC"
mk_inline OT_OBJ_T NS(LNG_CONSTR) (OT_CLS_T clazz, MK_MNG mng, int objc, VALUE* objv) {
  return MK(AtomObjCrt)(clazz,&NS(MqFactoryC_T),mng,objc,objv);
}
// MQ: ObjNew feature: called to return a new or an already existing RUBY-SELF-Object
// -> moved to: msgque_rb.h
// OT_OBJ_T NS(MqFactoryC_ObjNew) (MK_FCT hdl) {
//   return MK(AtomObjNew) (MqFactoryC_X2obj(hdl));
// }
// MQ: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MqFactoryC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  OT_OBJ_T self = NS(LNG_CONSTR) (OT_CLASS, obj, 0, NULL);
  return VAL2PTR(self);
}
// MQ: called on instance-destruction for a "selfCreate" instance → goal: destroy the SELF
static void NS(MqFactoryC_selfDelete) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
  OT_OBJECT_DELETE_HARD(PTR2VAL(ptr));
}
// MQ: called to destroy link from SELF to META
static void NS(MqFactoryC_selfUnlink) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
  OT_OBJ_T self =  PTR2VAL(ptr);
  RDATA(self)->data = NULL;
}
// initialize the RUBY and MO class specific object
#define S_INIT NS(sInit)(MK_RT_CALL_ONLY)
static void NS(sInit)(MK_RT_ARGS_ONLY) {
 
  // add "selfCreate" and "selfDelete" feature to the MQ-MqFactoryC-Type
  MqFactoryCTT->selfCreate    = NS(MqFactoryC_selfCreate);
  MqFactoryCTT->selfDelete    = NS(MqFactoryC_selfDelete);
  MqFactoryCTT->selfUnlink    = NS(MqFactoryC_selfUnlink);
 
  // create the RUBY class
  OT_CLASS = rb_define_class_under(OT_PKG, "MqFactoryC", MK_BASE_CLASS);
  rb_undef_alloc_func(OT_CLASS);
 
  /* define the "NULL" object */
  VALUE nullO = TypedData_Wrap_Struct (OT_CLASS, &NS(MqFactoryC_T), MK_NULL);
  NS(MqFactoryC_MK_NULL) = nullO;
  INCR_REF(&NS(MqFactoryC_MK_NULL));
}
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MqFactoryC);
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MqFactoryC);
#define OT_SETUP_hdl_constr         AllRtSetup_NULL; \
                                    OT_OBJ_T clazz = self; \
                                    MqFactoryC_type hdl = (MqFactoryC_type) &MkERROR;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MqFactoryC);
#define OT_SETUP_hdl_static         AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MqFactoryC##_TT;
#define OT_SETUP_hdl_static_constr  OT_SETUP_hdl_static
 
#if !defined(SetupRtFromObj_X)
  #define SetupRtFromObj_X(hdl)     AllRtSetup_X(hdl)
  #define SetupRtFromObj_XN(hdl)    AllRtSetup_XN(hdl)
#endif
 
/* LABEL-END */
 
 
// BEGIN-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// doc-key: MqFactoryC,MqFactory,sCc,func
#define Add_doc "MqFactoryC MqFactoryC.Add(constructor:class, ?ident:string=\"MK_NULL\"?)"
#define new_doc "MqFactoryC MqFactoryC.new(constructor:class, ?ident:string=\"MK_NULL\"?)"
 
// doc-key: MqFactoryC,MqFactory,sc_,func
#define Get_doc "MqFactoryC MqFactoryC.Get(?ident:string=\"\"?)"
#define GetCalled_doc "MqFactoryC MqFactoryC.GetCalled(?ident:string=\"\"?)"
#define GetCalledL_doc "MqFactoryC MqFactoryC.GetCalledL(largs:MkBufferListC)"
#define GetNull_doc "MqFactoryC MqFactoryC.GetNull()"
#define HandleResolve_doc "MqFactoryC MqFactoryC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "MqFactoryC MqFactoryC.Instances()"
 
// doc-key: MqFactoryC,MqFactory,sm_,func
#define DefaultIdent_doc "string MqFactoryC.DefaultIdent()"
#define InitialIdent_doc "string MqFactoryC.InitialIdent()"
#define LogAll_doc "MqFactoryC.LogAll(?callfunc:string=\"MK_NULL\"?)"
 
// doc-key: MqFactoryC,MqFactory,oCx,func
#define Dup2_doc "MqFactoryC fct.Dup2(ident:string) (const)"
 
// doc-key: MqFactoryC,MqFactory,oc_,func
#define Default_doc "MqFactoryC fct.Default()"
#define Initial_doc "MqFactoryC fct.Initial()"
#define Next_doc "MqFactoryC fct.Next()"
#define Prev_doc "MqFactoryC fct.Prev()"
 
// doc-key: MqFactoryC,MqFactory,oco,func
#define New_doc "MqContextC fct.New()"
 
// doc-key: MqFactoryC,MqFactory,om_,func
#define GetOriginalIdent_doc "string fct.GetOriginalIdent() (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
// skip class-overload: Log → MkObjectLog
 
// END-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
static ID NS(id_new);
 
static VALUE NS(sFactoryCall) (VALUE args) {
  const VALUE *argsP = rb_array_const_ptr(args);
  // return MK(OtNewInstanceWithOneArg)(argsP[0],argsP[1]);
  return rb_funcall(argsP[0], NS(id_new), 1, argsP[1]);
}
 
static enum MkErrorE
NS(sFactoryCTor)( MQ_CALLBACK_FACTORY_CTOR_ARGS )
{
  MQ_CTX mqctx = NULL;
  VALUE args;
  VALUE tmplO;
  VALUE self;
  VALUE class;
 
//printXV(tmpl, "RUBY: Factory[%s] -> %s\n", MqFactoryGetOriginalIdent(fct), MqLogFactoryE(create))
 
  // setup tmpl
  tmplO = CTX2VAL(tmpl);
 
  // a child use the class of the "parent" and NOT the class from the "factory"
  if (create & (MQ_FACTORY_NEW_CHILD)) {
    class = CLASS_OF(tmplO);
  } else {
    class = PTR2VAL(fct->fct_ctor.data);
  }
 
  // call "new"
  args = rb_ary_new3(2, class, tmplO);
  int status;
  self = rb_protect(NS(sFactoryCall), args, &status);
  if (status) {
    MK(MkExceptionC_Catch) (OT_Prefix_CALL NULL, NULL, __func__, "ProcessEvent");
  }
  rb_ary_free(args);
 
  if (NIL_P(self) || MkErrorCheckE_0E() ) {
    // special:  RUBY does NOT call the destructor of a "broken" instance, this create a "left-over"
    //           MkRuntimeS::cid (not bad but different from other languages)
    // set at:   MqContextInit->MQ_RT_REF.cid = context
    MkRuntimeSetCID(NULL);
    goto error;
  }
  mqctx = VAL2CTX(self);
 
  if (create & (MQ_FACTORY_NEW_CHILD)) {
    MqSetupDup(mqctx, tmpl);
  }
 
  // a MQ_FACTORY_NEW_FILTER has "mqctx->obj.self" as ONLY reference… incr "refCnt"
  // related to "NS(sFactoryDTor)→MQ_FACTORY_NEW_INIT→DECR_REG"
  if (create & MQ_FACTORY_NEW_FILTER) {
    INCR_REF((VALUE*)(&mqctx->super.obj.self));
  }
 
  // ruby-special: default event handler has !no! data and calling just the
  // ruby-event-update function. CHILD does not need to call it too
  if (create & MQ_FACTORY_NEW_CHILD && mqctx->setup.Event.data == NULL) {
    mqctx->setup.Event.fCall = NULL;
  }
  
  *contextP = mqctx;
  return MK_OK;
 
error:
  *contextP = NULL;
  return MkErrorStack_0E();
}
 
static void
NS(sFactoryDTor)(
  MK_RT_ARGS
  MQ_CTX mqctx,
  bool doFactoryDelete,
  MQ_FCT const fct
)
{
  // related to "NS(sFactoryCTor)→MQ_FACTORY_NEW_INIT→INCR_REG"
  if (doFactoryDelete && mqctx->setup.factoryCall == MQ_FACTORY_NEW_FILTER) {
    // DECR_REG does NOT call the destructor… just delete the "reference"
    DECR_REF ((VALUE*)(&mqctx->super.obj.self));
  }
 
  // delete final -> only if not already done
  MqContextDelete (mqctx);
}
 
static void NS(sFactoryDataFree) ( MK_RT_ARGS MK_PTR *dataP) {
  if (*dataP != NULL) {
    /* I have NOT found any RUBY function to check if VM is still active !!
    DECR_REF((VALUE*)dataP);
    */
  }
  *dataP = NULL;
}
 
static void NS(sFactoryDataCopy) ( MK_RT_ARGS MK_PTR *dataP) {
  if (*dataP != NULL) {
    INCR_REF((VALUE*)dataP);  // THREAD → no DEEP copy
  }
}
 
/*****************************************************************************/
/*                                                                           */
/*                                static                                     */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-MqFactoryC - created by 'rb_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Export,sc_
 
static OT_ProcRet NS(MqFactoryC_HandleResolve) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleResolve_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryHandleResolve (netHdl);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Class-Export,om_
 
// skip on class-overload: MqFactoryHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MqFactoryC_HandleGet) (MqFactoryC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MqFactoryC_Class_RB_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Introspection,oc_
 
static OT_ProcRet NS(MqFactoryC_Next) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryNext (hdl);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_Prev) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryPrev (hdl);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Class-Introspection,sc_
 
static OT_ProcRet NS(MqFactoryC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryInstances ();
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MqFactoryC_Class_RB_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Misc,sc_
 
static OT_ProcRet NS(MqFactoryC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGetNull ();
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MqFactoryC_Class_RB_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Get,sc_
 
static OT_ProcRet NS(MqFactoryC_Get) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,1,Get_doc);
  MK_STRN ident = "";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGet (ident);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_GetCalled) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,1,GetCalled_doc);
  MK_STRN ident = "";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGetCalled (ident);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_GetCalledL) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(GetCalledL_doc);
  MkBufferListCreateTLS_T(largs,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (largs,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGetCalledL (largs);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Get,om_
 
static OT_ProcRet NS(MqFactoryC_GetOriginalIdent) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetOriginalIdent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqFactoryGetOriginalIdent (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MqFactoryC_Get_RB_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Misc,oc_
 
static OT_ProcRet NS(MqFactoryC_Default) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Default_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryDefault (hdl);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_Initial) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Initial_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryInitial (hdl);
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,oco
 
static OT_ProcRet NS(MqFactoryC_New) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(New_doc);
  OT_CHECK_NOARGS;
  MQ_CTX val_out;
  MkErrorC_Check(hdl,MqFactoryNew (hdl, NULL, &val_out));
  OT_retObj_SET_CTX(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,om_
 
// skip on class-overload: MqFactoryLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MqFactoryC_Log) (MqFactoryC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,sm_
 
static OT_ProcRet NS(MqFactoryC_DefaultIdent) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(DefaultIdent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqFactoryDefaultIdent ());
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_InitialIdent) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(InitialIdent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqFactoryInitialIdent ());
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_LogAll) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,1,LogAll_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqFactoryLogAll (callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MqFactoryC_Misc_RB_API
 
 
// doc-key: MqFactoryC,MqFactoryC-TOR,oCx
 
static OT_ProcRet NS(MqFactoryC_Dup2) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Dup2_doc);
  MK_STRN ident = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryDup2 (hdl, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
  }
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-TOR,sCc
 
static OT_ProcRet NS(MqFactoryC_Add) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(1,2,Add_doc);
  MK_CCP constructor = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CONSTRUCTOR(constructor))
  MK_STRN ident = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(ident)) {ident = OT_GET_CONSTR_NAME(constructor);}
  MQ_FCT retVal = MqFactoryAdd (NULL, NS(sFactoryCTor), constructor, NS(sFactoryDataFree), NS(sFactoryDataCopy), NS(sFactoryDTor), NULL, NULL, NULL, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_FCT(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_new) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(1,2,new_doc);
  MK_CCP constructor = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CONSTRUCTOR(constructor))
  MK_STRN ident = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  if (MkSysStringIsNULL(ident)) {ident = OT_GET_CONSTR_NAME(constructor);}
  MQ_FCT retVal = MqFactoryAdd (NULL, NS(sFactoryCTor), constructor, NS(sFactoryDataFree), NS(sFactoryDataCopy), NS(sFactoryDTor), NULL, NULL, NULL, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MqFactoryC_TOR_RB_API
 
// END-MqFactoryC - created by 'rb_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                                public                                     */
/*                                                                           */
/*****************************************************************************/
 
static void NS(sMark)(MK_PTR mng) 
{
  MQ_FCT fct = MqFct(mng);
  if (fct == NULL) return;
  if (fct->fct_ctor.data) rb_gc_mark((VALUE)fct->fct_ctor.data);
  if (fct->fct_dtor.data) rb_gc_mark((VALUE)fct->fct_dtor.data);
}
 
void NS(MqFactoryC_Init)(MQ_RT_ARGS_ONLY) {
 
  // init type
  MqFactoryCTT = MqFactoryC_TT;
  S_INIT;
 
  // BEGIN-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // doc-key: MqFactoryC,MqFactory,sCc
  OT_METH_S ( MqFactoryC, Add,                       MqFactoryC_Add                      )
  OT_METH_C ( MqFactoryC, new,                       MqFactoryC_new                      )
 
  // doc-key: MqFactoryC,MqFactory,sc_
  OT_METH_O ( MqFactoryC, Get,                       MqFactoryC_Get                      )
  OT_METH_S ( MqFactoryC, Get,                       MqFactoryC_Get                      )
  OT_METH_O ( MqFactoryC, GetCalled,                 MqFactoryC_GetCalled                )
  OT_METH_S ( MqFactoryC, GetCalled,                 MqFactoryC_GetCalled                )
  OT_METH_O ( MqFactoryC, GetCalledL,                MqFactoryC_GetCalledL               )
  OT_METH_S ( MqFactoryC, GetCalledL,                MqFactoryC_GetCalledL               )
  OT_METH_O ( MqFactoryC, GetNull,                   MqFactoryC_GetNull                  )
  OT_METH_S ( MqFactoryC, GetNull,                   MqFactoryC_GetNull                  )
  OT_METH_O ( MqFactoryC, HandleResolve,             MqFactoryC_HandleResolve            )
  OT_METH_S ( MqFactoryC, HandleResolve,             MqFactoryC_HandleResolve            )
  OT_METH_O ( MqFactoryC, Instances,                 MqFactoryC_Instances                )
  OT_METH_S ( MqFactoryC, Instances,                 MqFactoryC_Instances                )
 
  // doc-key: MqFactoryC,MqFactory,sm_
  OT_METH_O ( MqFactoryC, DefaultIdent,              MqFactoryC_DefaultIdent             )
  OT_METH_S ( MqFactoryC, DefaultIdent,              MqFactoryC_DefaultIdent             )
  OT_METH_O ( MqFactoryC, InitialIdent,              MqFactoryC_InitialIdent             )
  OT_METH_S ( MqFactoryC, InitialIdent,              MqFactoryC_InitialIdent             )
  OT_METH_O ( MqFactoryC, LogAll,                    MqFactoryC_LogAll                   )
  OT_METH_S ( MqFactoryC, LogAll,                    MqFactoryC_LogAll                   )
 
  // END-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // BEGIN-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // doc-key: MqFactoryC,MqFactory,oCx
  OT_METH_O ( MqFactoryC, Dup2,                      MqFactoryC_Dup2                     )
 
  // doc-key: MqFactoryC,MqFactory,oc_
  OT_METH_O ( MqFactoryC, Default,                   MqFactoryC_Default                  )
  OT_METH_O ( MqFactoryC, Initial,                   MqFactoryC_Initial                  )
  OT_METH_O ( MqFactoryC, Next,                      MqFactoryC_Next                     )
  OT_METH_O ( MqFactoryC, Prev,                      MqFactoryC_Prev                     )
 
  // doc-key: MqFactoryC,MqFactory,oco
  OT_METH_O ( MqFactoryC, New,                       MqFactoryC_New                      )
 
  // doc-key: MqFactoryC,MqFactory,om_
  OT_METH_O ( MqFactoryC, GetOriginalIdent,          MqFactoryC_GetOriginalIdent         )
  // skip class-overload: MqFactoryHandleGet → HandleGet, MqFactoryC_HandleGet
  // skip class-overload: MqFactoryLog → Log, MqFactoryC_Log
 
  // END-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // setup default factory… required for objects created WITHOUT factory
  // example: Filter3.rb
  if (!strcmp(MqFactoryDefaultIdent(), "libmqmsgque")) {
 
    if  ( MqFactoryDefault(
            MqFactoryInitial(
              MqFactoryAdd (NULL, 
                NS(sFactoryCTor), (MK_PTR)NS(MqContextC), NULL, NULL, 
                  NS(sFactoryDTor), NULL, NULL, NULL, 
                    "rbmsgque"
              )
            )
          ) == NULL
        ) 
    {         
      OT_ERROR_RUNTIME("MqFactoryC", "create default factory failed")
    }
  }
 
  NS(id_new) = rb_intern("new");
}