MqFactoryC_atl.c

Go to the documentation of this file.

 
/* LABEL-INIT */
 
/* LABEL-START */
 
#define   META_FILE_NAME      "MqFactoryC_atl.c"
 
#include  "LibMqMsgque_private_atl.h"
 
#define   OT_CLASS            amqrt->AtlMqFactoryC
#define   OT_NULL             amqrt->AtlMqFactoryC_MK_NULL
#define   OT_CLASS_NAME       "MqFactoryC"
 
#define   SELF2HDL(O)         MqFct(VAL2MNG(O))
 
// LNG: class
// -> moved to LibMqMsgque_atl.h → OT_MQ_RT_S → AtlMqMsgqueCTT;
 
// META: ObjNew feature: called to return a new or an already existing ATL-SELF-Object
// -> moved to LibMqMsgque_atl.h → MqMsgqueC_ObjNew
 
// META: 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 const obj, MK_PTR const env) {
  SETUP_amqrt(env);
  return AtomMake(obj,OT_CLASS,NULL,NULL,env);
}
 
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(MqFactoryC_selfDelete) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amqrt(env);
  MK(AtomDeleteHard) (OT_MK_CALL selfO);
}
 
// META: called to destroy link from SELF to META
static void NS(MqFactoryC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amqrt(env);
  return MK(AtomUnlink) (OT_MK_CALL selfO);
}
 
#define OT_SETUP_hdl                  SetupHdlFromMetaData_2(MQ_FCT)
#define OT_SETUP_hdl__null_allow      SetupHdlFromMetaData__null_allow_2(MQ_FCT)
#define OT_SETUP_hdl_destr            SetupHdlFromMetaData__null_allow_2(MQ_FCT)
#define OT_SETUP_hdl_constr           SetupHdlConstr(MqFactoryC)
#define OT_SETUP_hdl_static_constr    OT_SETUP_hdl_static
#define OT_SETUP_hdl_static           SetupHdlStatic(MqFactoryC)
 
#define OT_retObj_CONSTR(x)           OT_retObj_SET(AtomInit(OT_SELF,MqFactoryC_X2obj(x),amqrt))
 
// initialize the ATL and META class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (MqFactoryCTT == NULL) MqFactoryCTT = MqFactorySTT; \
 \
  /* protect against double call */ \
  if (MqFactoryCTT->selfCreate == NS(MqFactoryC_selfCreate)) return MK_OK; \
 \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MqFactoryCTT->selfCreate    = NS(MqFactoryC_selfCreate); \
  MqFactoryCTT->selfDelete    = NS(MqFactoryC_selfDelete); \
  MqFactoryCTT->selfUnlink    = NS(MqFactoryC_selfUnlink); \
 \
  /* create the ATL-class */ \
  OT_CLASS = AltClassDef(MqFactoryCTT,&amqrt->AtlMqFactoryC_NS); \
    if (OT_CLASS == NULL) goto error; \
    OT_REF_INCR(OT_CLASS); \
 \
  /* create the ATL static Methods */ \
  check_LNG(AtlUnknownSetup (NS(sOtClassDef),amqrt)) goto error; \
 \
  /* create the ATL instance Methods */ \
  check_LNG(AtlUnknownSetup (NS(sInstanceDef),amqrt)) goto error; \
 \
  /* after class was modified, recompile the class */ \
  RL_init(2, recompile, RL_T(0,RecompileN)); RL_O(1,OT_CLASS) ; \
    int retI = RL_EvalEx(0); \
      if (retI != TCL_OK) return retI; \
 \
  /* define the "NULL" object */ \
  OT_NULL = AtomCreateNULL(OT_CLASS, "::MqFactoryC::MK_NULL", (MK_PTR)amqrt); \
    if (OT_NULL == NULL) goto error; \
    OT_REF_INCR(OT_NULL);
/* LABEL-END */
 
#undef META_CONTEXT_S
#define META_CONTEXT_S          mqctx
 
 
extern MkThreadLocal bool NS(inMain);
 
static char msg[] = "ERROR: a 'MqFactoryC' command was called OUTSIDE"                               \
" of the 'atlmqmsgque::Main'-proc.\n"                                                                \
"\n"                                                                                                 \
"Description: a 'atlmqmsgque SERVER' listen on a port and start for every incoming connetion\n"      \
"a sub-server. If a thread sub-server was choosen... with the '--thread' commandline-option...\n"    \
"a new thread is created. To setup a new thread the INITIAL tcl-file is RE-READ again and\n"         \
"PROCS and VARIABLES are initialized. The NEW thread has it's own 'Main'-proc and so... the\n"       \
"original 'Main'-proc is skipped. If a 'factory' command is used OUTSIDE of the 'Main'-proc...\n"    \
"the initial 'Factory' will be created TWICE. The creation of multiple 'Factory' objects...\n"       \
"with the SAME name... is an ERROR.";                                                                \
 
#undef    OT_SETUP_hdl_constr
#define   OT_SETUP_hdl_constr                                                          \
  if (NS(inMain) == false) {                                                           \
    Tcl_SetResult(interp,msg,TCL_STATIC);                                              \
    return TCL_ERROR;                                                                  \
  }                                                                                    \
  SetupHdlConstr(MqFactoryC)
 
#undef    OT_SETUP_hdl_static_constr
#define   OT_SETUP_hdl_static_constr                                                   \
  if (NS(inMain) == false) {                                                           \
    Tcl_SetResult(interp,msg,TCL_STATIC);                                              \
    return TCL_ERROR;                                                                  \
  }                                                                                    \
  SetupHdlStatic(MqFactoryC)
 
static void NS(sFactoryDataFree) ( MK_RT_ARGS MK_PTR *dataP)
{
  return;
  SETUP_amkrt(NULL);
printP(interp)
  if (interp == NULL || Tcl_InterpDeleted(interp)) return;
  OT_REF_DECR_AND_NULL(*dataP);   // OT_REF_INCR in: CheckConstructor 
}
 
static void NS(sFactoryDataCopy) ( MK_RT_ARGS MK_PTR *dataP)
{
  *dataP = OT_OBJ_COPY(*dataP);
}
 
 
// BEGIN-DOC - created by 'atl_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 CTOR_doc "MqFactoryC [MqFactoryC::CTOR 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 [MqFactoryC::Dup2 $fct ident:string] (const)"
 
// doc-key: MqFactoryC,MqFactory,oc_,func
#define Default_doc "MqFactoryC [MqFactoryC::Default $fct]"
#define Initial_doc "MqFactoryC [MqFactoryC::Initial $fct]"
#define Next_doc "MqFactoryC [MqFactoryC::Next $fct]"
#define Prev_doc "MqFactoryC [MqFactoryC::Prev $fct]"
 
// doc-key: MqFactoryC,MqFactory,oco,func
#define New_doc "MqContextC [MqFactoryC::New $fct]"
 
// doc-key: MqFactoryC,MqFactory,om_,func
#define GetOriginalIdent_doc "string [MqFactoryC::GetOriginalIdent $fct] (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
// skip class-overload: Log → MkObjectLog
 
// END-DOC - created by 'atl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// \anchor tcl_mqmsgque_MqFactoryC_New
//static OT_ProcRet NS(MqFactoryC_NewMqC) (MqFactoryC_ARGS);
 
 
#ifdef CALLGRIND_DEBUG
# include "valgrind/callgrind.h"
#endif
 
static enum MkErrorE NS(sFactoryCTor) ( MQ_CALLBACK_FACTORY_CTOR_ARGS )
{
//printTxt("11111111111111111111111111111111111111111111111111111111111111111111111111111111111")
//colorYELLOW("mkrt<%p>, mqrt<%p>, amkrc<%p>, amqrc<%p>", mkrt, mqrt, &amkrtR, &amqrt);
 
//printSTACK_0()
//MkObjLog(fct);
 
  MQ_CTX      mqctx = NULL;
  OT_SELF_T   retO = NULL;
  OT_CLS_T    clsO = NULL, clsTO = NULL;
  OT_OBJ_T    tmplO = tmpl ? META2VAL_X(tmpl) : NULL;
  OT_MQ_RT_T  amqrt = &amqrtR;
  OT_MK_RT_T  amkrt = &amkrtR;
  OT_ENV_T    interp = NULL;
 
//#define CALLGRIND_DEBUG
 
  if (create == MQ_FACTORY_NEW_THREAD) {
//printTxt("222222222222222222222222222222222222222222222222222222")
#ifdef CALLGRIND_DEBUG
printTxt("start CALLGRIND_ZERO_STATS")
printSTACK_0()
CALLGRIND_ZERO_STATS;
#endif
    interp = Tcl_CreateInterp();
    // tmpl→MK_ERROR_DEFAULT 25.11.2019 aotto
    check_LNG(Tcl_Init(interp)) {
      return MkErrorSetV_1E ("[ThreadCreateError] Tcl_Init : %s", Tcl_GetStringResult(interp));
    }
    // mark new interpreter as "MQ_STARTUP_IS_THREAD"
    Tcl_SetVar (interp, "MQ_STARTUP_IS_THREAD", "yes", TCL_GLOBAL_ONLY);
    // source initial script
    check_LNG(Tcl_EvalFile(interp, MqInitGetArg0()->data[1]->storage.first.C)) {
      return MkErrorSetV_1E ("[ThreadCreateError] Tcl_EvalFile : %s", Tcl_GetStringResult(interp));
    }
    // set script
    check_NULL(AtlInfoScript(MqInitGetArg0()->data[1]->storage.first.C)) {
      return MkErrorSetV_1E ("[ThreadCreateError] AtlInfoScript : %s", Tcl_GetStringResult(interp));
    }
#ifdef CALLGRIND_DEBUG
CALLGRIND_DUMP_STATS_AT("tcl_thread_startup");
printTxt("end CALLGRIND_ZERO_STATS")
#endif
  } 
  if (interp == NULL) interp  = amqrt->interp;
  MOX_RT_T moxrt = amkrt->moxrt;
 
//colorBLUE("mkrt<%p>, mqrt<%p>, amkrt<%p>, amqrt<%p>", mkrt, mqrt, amkrt, amqrt);
//colorWHITE("interp<%p>, amqrt->interp<%p>, amkrt->interp<%p>", interp, amqrt->interp, amkrt->interp);
 
  Tcl_ResetResult(interp);
 
  // reflection -> "child" use the same "Tcl_Class" as tmpl=parent
  if (tmplO && create & (MQ_FACTORY_NEW_CHILD|MQ_FACTORY_NEW_SLAVE|MQ_FACTORY_NEW_FILTER)) {
    clsTO = MoxMy__CLASS__N(tmplO);
    if (clsTO == NULL) {
      MkErrorSetV_1E("FactoryError: the template '%s' is no instance", VAL2STR(tmplO));
      goto error;
    }
  } else {
    clsTO = fct->fct_ctor.data ? fct->fct_ctor.data : MqContextC_lngO;
  }
 
  // security check of the Tcl_Class pointer
  if (clsTO == NULL) {
    MkErrorSetC_1E("FactoryError: unable to find Constructor");
    goto error;
  }
 
  // on a NEW interpreter the class also have to be resolved new
  if (create & (MQ_FACTORY_NEW_THREAD)) {
    // always assume that 'clsTO' is from OTHER thread
    // attention: this code create an ATL-CLASS-OBJECT with AtlClassDefGetNN
    // SIDE EFFECT: register a "AtlClassDefT" into the namespace
    OT_NS_T clsNs = Tcl_FindNamespace(interp,VAL2STR(clsTO),NULL,TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG);
      if (clsNs == NULL) goto error;
    clsO = AtlGetClassFrmNsPtr(clsNs,TCL_LEAVE_ERR_MSG);
      if (clsO == NULL) goto error;
  } else {
    clsO = clsTO;
  }
 
  // Call Factory -> Contructor
  int       lobjc=0;
  OT_OBJ_T  lobjv[1];
 
  // 2. add "self"
  // MQ_FACTORY_NEW_THREAD get a NEW "interp" and "tmpl->obj.self" is only defined
  // on the original interp -> no "tmpl" possible -> missing "MqConfigDup"
  if (create & (MQ_FACTORY_NEW_INIT|MQ_FACTORY_NEW_THREAD)) {
    ;
  } else {
    lobjv[lobjc++] = tmplO;
  }
 
  // 3. evaluate the script
  check_LNG(MoxCreate3N(clsO, NULL, NULL, lobjc, lobjv)) {
    OT_ERROR_LNG_2_META(NULL);
    goto error;
  }
  retO = Tcl_GetObjResult(interp);
    OT_REF_INCR(retO);
 
  // 4. get context
  mqctx = MqCtx(VAL2MNG(retO));
  if (mqctx == NULL) {
    MkErrorSetV_1E("Factory return '%s', this is not a MqContextC type", VAL2STR(retO));
    goto error;
  }
 
//printLV("222 → <%p>\n", mqctx->setup.Event.data)
 
  // 5. check for MQ error
  MkErrorCheck_0E();
 
  // 6. do the missing "MqConfigDup" from "2"
  // BUGFIX: without MQ_FACTORY_NEW_CHILD the OT_CONSTRUCTOR_POST prefix will NOT cleanup
  if (tmpl && create & (MQ_FACTORY_NEW_THREAD|MQ_FACTORY_NEW_CHILD|MQ_FACTORY_NEW_FILTER)) {
    MqConfigDup(mqctx, tmpl);
  }
 
  // 7. copy and initialize "setup" data
  // "MQ_FACTORY_NEW_THREAD|MQ_FACTORY_NEW_FORK" is only used to support NON factory startup
  if (tmpl && create & (MQ_FACTORY_NEW_THREAD|MQ_FACTORY_NEW_CHILD|MQ_FACTORY_NEW_FORK)) {
//MkObjLog(tmpl);
    MqSetupDup(mqctx, tmpl);
  }
 
  // tcl-special: default event handler has !no! data and calling just the
  // tcl-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;
  }
  
//printLV("333 → <%p>\n", mqctx->setup.Event.data)
//printXV(mqctx,"333 → MqLinkGetTargetIdent = %s\n", MqLinkGetTargetIdent(mqctx))
  *contextP = mqctx;
  Ot_DecrRefCount(retO);
  return MK_OK;
 
error:
  *contextP = NULL;
  if (retO) {
    MoxDestroyN(retO);
    OT_REF_DECR(retO);
  }
  return MkErrorStack_0E();
}
 
/*
static void NS(sFactoryDTor) (
  MK_RT_ARGS
  MQ_CTX hdl,
  bool doFactoryCleanup,
  MQ_FCT fct
) {
  if (doFactoryCleanup) {
    SETUP_amqrt(NULL);
    OT_SELF_T selfO = OT_SELF_X(hdl);
    if (selfO && OT_OBJECT_DELETE_HARD(selfO)) return;
  }
 
  MqContextDelete(hdl);
}
*/
 
 
// BEGIN-MqFactoryC - created by 'atl_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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_ATL_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_Class_ATL_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_Class_ATL_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_Get_ATL_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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 ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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 ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MqFactoryC_Misc_ATL_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);
    goto error;
  }
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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), NULL, NULL, NULL, NULL, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_CTOR) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(1,2,CTOR_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), NULL, NULL, NULL, NULL, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_TOR_ATL_API
 
// END-MqFactoryC - created by 'atl_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sOtClassDef)[] = {
  // BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // doc-key: MqFactoryC,MqFactory,sCc
  { "::MqFactoryC::Add"              , NS(MqFactoryC_Add)              },
 
  // doc-key: MqFactoryC,MqFactory,sc_
  { "::MqFactoryC::Get"              , NS(MqFactoryC_Get)              },
  { "::MqFactoryC::GetCalled"        , NS(MqFactoryC_GetCalled)        },
  { "::MqFactoryC::GetCalledL"       , NS(MqFactoryC_GetCalledL)       },
  { "::MqFactoryC::GetNull"          , NS(MqFactoryC_GetNull)          },
  { "::MqFactoryC::HandleResolve"    , NS(MqFactoryC_HandleResolve)    },
  { "::MqFactoryC::Instances"        , NS(MqFactoryC_Instances)        },
 
  // doc-key: MqFactoryC,MqFactory,sm_
  { "::MqFactoryC::DefaultIdent"     , NS(MqFactoryC_DefaultIdent)     },
  { "::MqFactoryC::InitialIdent"     , NS(MqFactoryC_InitialIdent)     },
  { "::MqFactoryC::LogAll"           , NS(MqFactoryC_LogAll)           },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sInstanceDef)[] = {
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // doc-key: MqFactoryC,MqFactory,oC_
  { "::MqFactoryC::MqFactoryC"       , NS(MqFactoryC_CTOR)             },
 
  // doc-key: MqFactoryC,MqFactory,oCx
  { "::MqFactoryC::Dup2"             , NS(MqFactoryC_Dup2)             },
 
  // doc-key: MqFactoryC,MqFactory,oc_
  { "::MqFactoryC::Default"          , NS(MqFactoryC_Default)          },
  { "::MqFactoryC::Initial"          , NS(MqFactoryC_Initial)          },
  { "::MqFactoryC::Next"             , NS(MqFactoryC_Next)             },
  { "::MqFactoryC::Prev"             , NS(MqFactoryC_Prev)             },
 
  // doc-key: MqFactoryC,MqFactory,oco
  { "::MqFactoryC::New"              , NS(MqFactoryC_New)              },
 
  // doc-key: MqFactoryC,MqFactory,om_
  { "::MqFactoryC::GetOriginalIdent" , NS(MqFactoryC_GetOriginalIdent) },
  // skip class-overload: HandleGet → MkObjectHandleGet
  // skip class-overload: Log → MkObjectLog
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  { NULL }
};
 
 
int
NS(MqFactoryC_Setup) (MK_RT_ARGS Tcl_Interp *interp)
{
  if (!strcmp(MqFactoryDefaultIdent(), "libmqmsgque")) {
    if  ( MqFactoryDefault(
            MqFactoryInitial(
              MqFactoryAdd (MK_ERROR_FORMAT,
                NS(sFactoryCTor), NULL, NULL, NULL, NULL, NULL, NULL, NULL, "atlmqmsgque"
              )
            )
          ) == NULL
        )
    { 
      Tcl_SetResult(interp,"MqFactoryS exception",TCL_STATIC);
      return TCL_ERROR;
    }
  }
  return TCL_OK;
}
 
int NS(pMqFactoryC_Init) ( OT_MQ_ARGS OT_NS_T ns )
{
  MQ_STATIC_RT;
  ClassInit
 
  return TCL_OK;
error:
  return TCL_ERROR;
}