MqFactoryC_cc.hh

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#pragma once
 
namespace ccmqmsgque {
 
  typedef struct {
    MK_NUM     size;
    MqFactoryC **data;
  } MqFactoryC_A;
 
  class MqFactoryC : public MkObjectC {
 
    friend class MqMsgque;
    template <class T> friend class MqFactoryCT;
 
/* LABEL-START */
 
 
    public:
      static thread_local MqFactoryC MK_NULL_REF;
 
    private:
 
      static MqFactoryC* MqFactoryC_GetSelf (MQ_FCT hdl) {
        return (hdl != NULL ? static_cast<MqFactoryC*>((*MqFactoryC_X2obj(hdl)).self) : &MK_NULL_REF);
      }
 
    #ifdef MqFactoryC_selfCreate_overload
      static MK_PTR MqFactoryC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env);
    #else
      static MK_PTR MqFactoryC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
        return new MqFactoryC(obj);
      }
    #endif
 
      static void MqFactoryC_selfDelete (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        delete static_cast<MqFactoryC*>(self);
      }
 
      static void MqFactoryC_selfUnlink (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        MqFactoryC* selfO = static_cast<MqFactoryC*>(self);
        selfO->atomUnlink();
      }
 
      void MqFactoryC_Init (MQ_FCT hdl)   { atomInit(MqFactoryC_X2obj(hdl)); };
 
 
      static MqFactoryC* MqFactoryC_ObjCreate (MK_RT_ARGS MQ_FCT hdl) {
        return static_cast<MqFactoryC*>(MkObjectC::atomObjCreate(MK_RT_CALL MqFactoryC_X2obj(hdl)));
      }
 
#ifndef META_IS_MkObjectC
      MqFactoryC   (MK_OBJ obj) : MkObjectC(obj) {};
#endif
 
    public:
 
#ifndef META_IS_MkObjectC
      MqFactoryC   (MQ_FCT hdl) : MkObjectC(MqFactoryC_X2obj(hdl)) {};
#endif
 
      static MqFactoryC* MqFactoryC_ObjNew (MK_RT_ARGS MQ_FCT hdl) {
        return (hdl ? static_cast<MqFactoryC*>(MkObjectC::atomObjNew(MK_RT_CALL MqFactoryC_X2obj(hdl))) : &MK_NULL_REF);
      }
 
      MQ_FCT getFCT() const {
        MQ_FCT ret = reinterpret_cast<MQ_FCT>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MQ_FCT getFCT__null_allow() const {
        return reinterpret_cast<MQ_FCT>(hdl);
      };
 
      MQ_FCTN getFCTN() const {
        MQ_FCTN ret = reinterpret_cast<MQ_FCTN>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MQ_FCTN getFCTN__null_allow() const {
        return reinterpret_cast<MQ_FCTN>(hdl);
      };
 
      static MQ_FCT getFCT(MqFactoryC* clsHdl) {
        MQ_FCT ret = clsHdl ? reinterpret_cast<MQ_FCT>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MqFactoryC);
        return ret;
      };
 
      static MQ_FCT getFCT__null_allow(MqFactoryC* clsHdl) {
        return clsHdl ? reinterpret_cast<MQ_FCT>(clsHdl->hdl) : NULL;
      };
 
      static MQ_FCTN getFCTN(const MqFactoryC* clsHdl) {
        MQ_FCTN ret = clsHdl ? reinterpret_cast<MQ_FCTN>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MqFactoryC);
        return ret;
      };
 
      static MQ_FCTN getFCTN__null_allow(const MqFactoryC* clsHdl) {
        return clsHdl ? reinterpret_cast<MQ_FCTN>(clsHdl->hdl) : NULL;
      };
 
      static MQ_FCT getFCT(const MqFactoryC& clsHdl) {
        return clsHdl.getFCT();
      };
 
      static MQ_FCT getFCT__null_allow(const MqFactoryC& clsHdl) {
        return clsHdl.getFCT__null_allow();
      };
 
      static MQ_FCTN getFCTN(const MqFactoryC& clsHdl) {
        return clsHdl.getFCTN();
      };
 
      static MQ_FCTN getFCTN__null_allow(const MqFactoryC& clsHdl) {
        return clsHdl.getFCTN__null_allow();
      };
 
      bool Check() const {
        return (hdl && MqFctCheck(hdl));
      };
 
/* LABEL-END */
 
    private:
 
      MqFactoryC () {};
 
    //   BEGIN-MqFactoryC - created by 'cc_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
    public:
 
      // doc-key: MqFactoryC,MqFactoryC-Class-Export,sc_,public
 
      static MqFactoryC* HandleResolve (MK_HDL netHdl);
 
      // doc-key: MqFactoryC,MqFactoryC-Class-Export,om_,public
 
      // skip class-overload: MK_HDL HandleGet ()
 
    // MqFactoryC_Class_CC_API
 
 
    public:
 
      // doc-key: MqFactoryC,MqFactoryC-Class-Introspection,oc_,public
 
      MqFactoryC* Next ();
 
      MqFactoryC* Prev ();
 
      // doc-key: MqFactoryC,MqFactoryC-Class-Introspection,sc_,public
 
      static MqFactoryC* Instances ();
 
    // MqFactoryC_Class_CC_API
 
 
    public:
 
      // doc-key: MqFactoryC,MqFactoryC-Class-Misc,sc_,public
 
      static MqFactoryC* GetNull ();
 
    // MqFactoryC_Class_CC_API
 
 
    public:
 
      // doc-key: MqFactoryC,MqFactoryC-Get,sc_,public
 
      static MqFactoryC* Get (MK_STRN ident = "");
 
      static MqFactoryC* GetCalled (MK_STRN ident = "");
 
      static MqFactoryC* GetCalled (const MkBufferListC* largs);
 
      static MqFactoryC* GetCalled (const MkBufferListC& largs);
 
      // doc-key: MqFactoryC,MqFactoryC-Get,om_,public
 
      MK_STRN GetOriginalIdent () const;
 
    // MqFactoryC_Get_CC_API
 
 
    public:
 
      // doc-key: MqFactoryC,MqFactoryC-Misc,oc_,public
 
      MqFactoryC* Default ();
 
      MqFactoryC* Initial ();
 
      // doc-key: MqFactoryC,MqFactoryC-Misc,oco,public
 
      virtual MqContextC* New ();
 
      // doc-key: MqFactoryC,MqFactoryC-Misc,om_,public
 
      // skip class-overload: void Log (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const
 
      // skip class-overload: void Log (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const
 
      // doc-key: MqFactoryC,MqFactoryC-Misc,sm_,public
 
      static MK_STRN DefaultIdent ();
 
      static MK_STRN InitialIdent ();
 
      static void LogAll (MK_STRN callfunc = __builtin_FUNCTION());
 
    // MqFactoryC_Misc_CC_API
 
 
    public:
 
      // doc-key: MqFactoryC,MqFactoryC-TOR,oCx,public
 
      MqFactoryC* Dup2 (MK_STRN ident) const;
 
      MqFactoryC* Dup2 (const std::string& ident) const;
 
    // MqFactoryC_TOR_CC_API
 
    //   END-MqFactoryC - created by 'cc_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  };
 
 
  template <class T>
  class MqFactoryCT : public MqFactoryC {
 
    friend class MqStaticC;
 
    private:
      MqFactoryCT() {};
 
//MkSysPrintStackTrace(libmqmsgque::MK_ERROR_PRINT, __func__);
//self->LogObj();
 
      // [self_example]
      static MK_OBJ ObjectSelfCreate (MK_RT_ARGS MK_TYP const type, MK_PTR const tmpl, MK_PTR const lnk) {
        T* self = NULL;
        try {
 
//printV("type=%p, tmpl=%p", type, tmpl)
//MkRuntimeC::Debug();
 
          // !! attention !! if the constructor has a BUG the destructor is called and the "c++ obj" becomes unusable
          self = new T(type, static_cast<MqContextC*>(tmpl));
          if (self) self->Init();
        } catch (const std::exception& ex) {
//MkRuntimeC::Debug();
          MkErrorC::DEFAULT()->Catch(ex)->Stack();
        }
//self->DbgLogC();
        return self?self->hdl:NULL;
      }
 
      static void ObjectSelfDelete (MK_RT_ARGS MK_PTR selfP, MK_PTR env) {
        T* self = static_cast<T*>(selfP);
//self->DbgLogC();
        delete self;
      }
 
      static MK_PTR FactorySelfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR dmy) {
        return new MqFactoryCT<T>(obj);
      }
 
      static void FactorySelfDelete (MK_RT_ARGS MK_PTR selfptr, MK_PTR env) {
        delete static_cast<MqFactoryCT<T>*>(selfptr);
      }
      // [self_example]
 
      MqFactoryCT (MK_OBJ obj) : MqFactoryC(obj) {};
 
      static MqFactoryCT<T>* MqFactoryCT_ObjNew (MK_RT_ARGS MQ_FCT fct) {
        return static_cast<MqFactoryCT<T>*>(MkObjectC::atomObjNew(MK_RT_CALL MkOBJ(fct)));
      }
    
    public:
 
      static MqFactoryCT<T>* Add(MK_STRN ident) {
        MkRtSetup_NULL;
        auto ret = MqFactoryCT<T>::MqFactoryCT_ObjNew(MK_RT_CALL MqFactoryTypeAdd (MK_ERROR_FORMAT, ident, 
          FactorySelfCreate, FactorySelfDelete, ObjectSelfCreate, ObjectSelfDelete
        ));
        if (ret == NULL) {
          if (MkErrorCheckE_NULL()) {
            MkErrorC::DEFAULT()->Raise();
          } else {
            throw MkConstructorNullExceptionC(ident);
          }
        }
        return ret;
      }
 
      static MqFactoryCT<T>* Get(MK_STRN ident="") {
        MkRtSetup_NULL;
        return MqFactoryCT<T>::MqFactoryCT_ObjNew(MK_RT_NULL MqFactoryGet(ident));
      }
 
      inline T* New() {
        return static_cast<T*>(MqFactoryC::New());
      }
 
      MQ_CTXT Type() {
        return (MQ_CTXT)getFCT()->fct_ctor.data;
      }
  };
 
 
}