MqFactoryC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "MqFactoryC_py.c"
 
#include "LibMqMsgque_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(MqFactoryCR))
#define OT_CLASS_NAME               "MqFactoryC"
 
#define OT_LNG2META(O)              MqFct(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(MqFactoryC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#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         MK_RT_UNUSED AllRtSetup_NULL; \
                                    MQ_FCT hdl = (MQ_FCT) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MqFactoryC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED 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
 
// MO class
#undef MqFactoryCTT
#define MqFactoryCTT MQ(MqMsgqueThreadState).MqFactoryCTT
/* MqFactoryC_MK_NULL defined in LibMqMsgque_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(MqFactoryC_CTOR) (MK_RT_ARGS OT_CLS_T type, MQ_FCT hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,MqFactoryC_X2obj(hdl));
}
 
// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
 
// 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) {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}
// 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 self, MK_PTR const env) {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}
// META: called to destroy link from SELF to META
static void NS(MqFactoryC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}
 
// initialize the PY and MO 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); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MqFactoryCR).tp_base = MqFactoryC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MqFactoryC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MqFactoryC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#if 0
#define SetupRtFromObj_XN(hdl)      AllRtSetup_XN(hdl)
 
#undef OT_SETUP_hdl
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MqFactoryC) \
                                    bool is_constr_hard = false;
#undef OT_SETUP_hdl_constr
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MqFactoryC##_TT; \
                                    bool is_constr_hard = true; 
#undef OT_SETUP_hdl_static
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MqFactoryC##_TT; \
                                    bool is_constr_hard = false;
#undef OT_SETUP_hdl_static_constr
#define OT_SETUP_hdl_static_constr  MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MqFactoryC##_TT; \
                                    bool is_constr_hard = true;
 
#undef OT_retObj_RETURN
#define OT_retObj_RETURN                                                         \
if (is_constr_hard) {                                                            \
  /* BUG-FIX */                                                                  \
  /* the factory is always global and has NO link to an external variable… */    \
  /* need "Py_INCREF" to keep the factory alive */                               \
  /* test: Nhi1Exec server.py */                                                 \
                                    Py_INCREF (retObj);                          \
}                                                                                \
                                    return ((PyObject*)retObj);
#endif
 
 
// BEGIN-DOC - created by 'py_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 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
static enum MkErrorE
NS(sFactoryCTor) ( MQ_CALLBACK_FACTORY_CTOR_ARGS )
{
  MQ_CTX        mqctx = NULL;
  enum MkErrorE ret = MK_OK;
  PyObject*     argsO=NULL, *resultO=NULL;
  PyObject*     typeO = fct->fct_ctor.data;
  PyObject*     tmplO = (tmpl ? MkOBJ_R(tmpl).self : NULL);
 
//printXV(tmpl, "PYTH: Factory[%s] -> %s\n", MqFactoryGetOriginalIdent(fct), MqLogFactoryE(create))
  if (create == MQ_FACTORY_NEW_THREAD) {
#if 0
    ret = MkErrorSetC_1E("internal error: MQ_FACTORY_NEW_THREAD not supported");
    goto error;
#else
 
    static PyInterpreterConfig config = {
        .use_main_obmalloc = 0,
        .allow_fork = 0,
        .allow_exec = 0,
        .allow_threads = 1,
        .allow_daemon_threads = 0,
        .check_multi_interp_extensions = 1,
        .gil = PyInterpreterConfig_OWN_GIL,
    };
 
    PyThreadState *tstate = NULL;
    PyStatus status = Py_NewInterpreterFromConfig(&tstate, &config);
    if (MK_RT_REF.mkThreadData.ptr == NULL) {
      MK_RT_REF.mkThreadData = (MkThreadDataS) { "pymqmsgque", tstate } ;
    } else if (strcmp(MK_RT_REF.mkThreadData.name,"pymqmsgque") == 0) {
      MkErrorSetC_1E("'MK_RT_REF.mkThreadData' not NULL as expected");
    } else {
      MkErrorSetV_1E("MK_RT_REF.mkThreadData' already in use with extension: %s", MK_RT_REF.mkThreadData.name);
    }
 
mk_dbg_color_ln(MK_COLOR_YELLOW,"MQ_FACTORY_NEW_THREAD -> thread<%p>", tstate);
 
    if (PyStatus_Exception(status)) {
      return MkErrorSetC_3_NULL(status.err_msg, status.func, 300+status.exitcode);
    }
 
    Py_XINCREF(typeO);
    Py_XINCREF(tmplO);
 
    // mark new interpreter as "MQ_STARTUP_IS_THREAD"
    PyObject *mainM = PyImport_AddModule("__main__");
    PyObject *strO = PyUnicode_FromString("MQ_STARTUP_IS_THREAD");
    PyObject_SetAttrString(mainM,"__name__", strO);
    Py_CLEAR(strO);
 
    // source initial script
    MK_STRN fn = MqInitGetArg0()->data[1]->storage.first.C;
    FILE *FH = fopen(fn, "r");
    PyObject * mD = PyModule_GetDict(mainM);
    PyObject *retO = PyRun_FileEx(FH,fn,Py_file_input,mD,mD,true);
    if (retO == NULL) {
      ret = MkErrorSetC_1E("MQ_FACTORY_NEW_THREAD failed");
      //PyGILState_Release(gilstate);
      goto error3;
    }
    Py_CLEAR(retO);
 
    // type is from the "wrong" interpreter → try to figure out the right one
    PyObject* QualNameO = PyType_GetQualName((PyTypeObject*)typeO);
    if (QualNameO == NULL) goto error2;
 
    Py_CLEAR(typeO);
    typeO = PyObject_GetAttr(mainM,QualNameO);
    Py_CLEAR(QualNameO);
 
    if (typeO == NULL) goto error2;
 
    // need a NEW template class because the OLD class has a TYPE in the WRONG interpreter.
    Py_CLEAR(tmplO);
    tmplO = MK(AtomCreate)(MK_RT_CALL (PyTypeObject*)typeO,MkOBJ(tmpl));
 
    goto cont;
 
  error2:
    ret = MkErrorSetC_1E("internal error: unable to resolve type");
  error3:
    goto error;
  cont:
#endif
  } else {
 
    Py_XINCREF(typeO);
    Py_XINCREF(tmplO);
  }
 
  // get typeO from "parent"
  if (tmplO && create & (MQ_FACTORY_NEW_CHILD|MQ_FACTORY_NEW_SLAVE|MQ_FACTORY_NEW_FILTER)) {
    Py_CLEAR(typeO);
    typeO = Py_NewRef(Py_TYPE(tmplO));
  }
 
  // setup argsO
  if (create & MQ_FACTORY_NEW_INIT) {
    argsO = PyTuple_New(0);
  } else {
    argsO = PyTuple_New(1);
    PyTuple_SET_ITEM(argsO, 0, tmplO);
    Py_INCREF(tmplO);
  }
 
  if (typeO == NULL) {
    PyErr_SetString(PyExc_RuntimeError,"internal error: factory object constructor is 'NULL'");
    goto error;
  } else {
    // call constructor
    resultO = PyObject_Call(typeO, argsO, NULL);
    check_NULL(resultO) goto error;
  }
 
  // right typeO?
  if (!PyObject_IsInstance(resultO, (PyObject*) &NS(MqContextCR))) goto error;
  mqctx = VAL2CTX(resultO);
 
  // check for MQ error
  MkErrorCheck(MkErrorGetCode_0E());
 
  // copy and initialize "setup" data
  if (create & (MQ_FACTORY_NEW_CHILD)) {
    // !Attention!. the ctxId would be set later… in MqLinkCreate…
    MqSetupDup(mqctx, tmpl);
  }
 
  // a MQ_FACTORY_NEW_FILTER has "MkOBJ_R(mqctx).self" as ONLY reference… incr "refCnt"
  // related to "NS(sFactoryDTor)→MQ_FACTORY_NEW_INIT→Py_XINCREF"
  if (create & MQ_FACTORY_NEW_FILTER) {
    Py_XINCREF(resultO);
  }
 
  *contextP = mqctx;
 
end:
//printTxt("OK")
  // not used anymore because "Py_INCREF(self)" in "MqContextC_New" was deleted
  //Py_CLEAR(resultO);
  Py_CLEAR(argsO);
  Py_CLEAR(tmplO);
  Py_CLEAR(typeO);
//printXLngObj(mqctx,resultO)
 
  return ret;
 
error:
//printTxt("ERROR")
  Py_CLEAR(resultO);
  *contextP = NULL;
  OT_ERROR_LNG_2_META(MK_ERROR_DEFAULT);
  ret = MkErrorStack_0E();
  goto end;
}
 
static void MK_DECL
NS(sFactoryDTor) (
  MK_RT_ARGS
  MQ_CTX context,
  bool doFactoryDelete,
  MQ_FCT const data
) {
 
  // related to "NS(sFactoryCTor)→MQ_FACTORY_NEW_INIT→Py_XINCREF"
  if (doFactoryDelete && context->setup.factoryCall == MQ_FACTORY_NEW_FILTER) {
    OT_OBJ_T selfO = OT_SELF_X(context);
    Py_CLEAR (selfO);
  }
 
  // do a 'hard'-delete if 'Py_CLEAR' does NOT call the destructor
  MqContextDelete (context);
}
 
static void MK_DECL 
NS(sFactoryDataFree) (
  MK_RT_ARGS
  MK_PTR *dataP
) {
  if (_Py_IsFinalizing()) return;
  Py_CLEAR(*dataP);
}
 
static void MK_DECL 
NS(sFactoryDataCopy) (
  MK_RT_ARGS
  MK_PTR *dataP
) {
  PyObject *arg = *dataP;
  Py_INCREF(arg);   // THREAD → no DEEP copy
}
 
 
// BEGIN-MqFactoryC - created by 'py_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_PY_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_PY_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_PY_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_PY_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_PY_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), NS(sFactoryDTor), 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_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);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_TOR_PY_API
 
// END-MqFactoryC - created by 'py_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
static PyMethodDef NS(MqFactoryC_Methods)[] = {
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // doc-key: MqFactoryC,MqFactory,sCc
  { "Add"              , (PyCFunction) NS(MqFactoryC_Add)              , METH_VARARGS|METH_CLASS , Add_doc },
 
  // doc-key: MqFactoryC,MqFactory,sc_
  { "Get"              , (PyCFunction) NS(MqFactoryC_Get)              , METH_VARARGS|METH_CLASS , Get_doc },
  { "GetCalled"        , (PyCFunction) NS(MqFactoryC_GetCalled)        , METH_VARARGS|METH_CLASS , GetCalled_doc },
  { "GetCalledL"       , (PyCFunction) NS(MqFactoryC_GetCalledL)       , METH_O|METH_CLASS       , GetCalledL_doc },
  { "GetNull"          , (PyCFunction) NS(MqFactoryC_GetNull)          , METH_NOARGS|METH_CLASS  , GetNull_doc },
  { "HandleResolve"    , (PyCFunction) NS(MqFactoryC_HandleResolve)    , METH_O|METH_CLASS       , HandleResolve_doc },
  { "Instances"        , (PyCFunction) NS(MqFactoryC_Instances)        , METH_NOARGS|METH_CLASS  , Instances_doc },
 
  // doc-key: MqFactoryC,MqFactory,sm_
  { "DefaultIdent"     , (PyCFunction) NS(MqFactoryC_DefaultIdent)     , METH_NOARGS|METH_CLASS  , DefaultIdent_doc },
  { "InitialIdent"     , (PyCFunction) NS(MqFactoryC_InitialIdent)     , METH_NOARGS|METH_CLASS  , InitialIdent_doc },
  { "LogAll"           , (PyCFunction) NS(MqFactoryC_LogAll)           , METH_VARARGS|METH_CLASS , LogAll_doc },
 
  // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // doc-key: MqFactoryC,MqFactory,oCx
  { "Dup2"             , (PyCFunction) NS(MqFactoryC_Dup2)             , METH_O                  , Dup2_doc },
 
  // doc-key: MqFactoryC,MqFactory,oc_
  { "Default"          , (PyCFunction) NS(MqFactoryC_Default)          , METH_NOARGS             , Default_doc },
  { "Initial"          , (PyCFunction) NS(MqFactoryC_Initial)          , METH_NOARGS             , Initial_doc },
  { "Next"             , (PyCFunction) NS(MqFactoryC_Next)             , METH_NOARGS             , Next_doc },
  { "Prev"             , (PyCFunction) NS(MqFactoryC_Prev)             , METH_NOARGS             , Prev_doc },
 
  // doc-key: MqFactoryC,MqFactory,oco
  { "New"              , (PyCFunction) NS(MqFactoryC_New)              , METH_NOARGS             , New_doc },
 
  // doc-key: MqFactoryC,MqFactory,om_
  { "GetOriginalIdent" , (PyCFunction) NS(MqFactoryC_GetOriginalIdent) , METH_NOARGS             , GetOriginalIdent_doc },
  // skip class-overload: MqFactoryHandleGet → HandleGet, NS(MqFactoryC_HandleGet)
  // skip class-overload: MqFactoryLog → Log, NS(MqFactoryC_Log)
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
static PyObject* NS(sMqFactoryC_Str) (MqFactoryC_Obj *self) {
  MkRtSetup_X(self->hdl);
  return STRN2VAL(MkSysPrintF("MqFactoryC[%s]", self->hdl ? self->hdl->originalIdent : NULL));
}
 
// vim: Marker(p)
 
int 
NS(pMqFactoryC_Setup) (MQ_RT_ARGS OT_OBJ_T m)
{
  if (!strcmp(MqFactoryDefaultIdent(), "libmqmsgque")) {
    if  ( MqFactoryDefault(
            MqFactoryInitial(
              MqFactoryAdd (MK_ERROR_FORMAT,
                NS(sFactoryCTor), (MK_PTR)&NS(MqContextCR), NULL, NULL, 
                  NS(sFactoryDTor), NULL, NULL, NULL,
                    "pymqmsgque"
              )
            )
          ) == NULL
        ) 
    {
      PyErr_SetString(PyExc_RuntimeError, "MqFactoryS exception");
      goto error;
    }
  }
 
  return 0;
error:
  return -1;
}
 
// OT_CLASS_TYPE_REF NS(MqFactoryCR) = {0};
OT_CLASS_TYPE_REF NS(MqFactoryCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymqmsgque.MqFactoryC",
  .tp_doc         = "PyMqMsgque MqFactoryC Type",
  .tp_itemsize    = sizeof(MqFactoryC_Obj),
  .tp_itemsize    = 0,
  .tp_new         = (newfunc)     NS(MqFactoryC_new),
  .tp_methods     = NS(MqFactoryC_Methods),
  .tp_flags       = Py_TPFLAGS_DEFAULT,
  .tp_base        = NULL,
  .tp_str         = (reprfunc) NS(sMqFactoryC_Str)
};
 
int 
NS(pMqFactoryC_Init) (MK_RT_ARGS OT_OBJ_T m)
{
  MQ_STATIC_RT;
  ClassInit
 
  // MqFactoryCTT->noSelf = true;
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap