MkObjectC_cc.hh

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#pragma once
 
#include <cxxabi.h>
 
#define META_IS_MkObjectC
 
namespace ccmkkernel {
 
  typedef struct {
    MK_NUM    size;
    MkObjectC **data;
  } MkObjectC_A;
 
  typedef void (*MkObjectDeleteSCB) (MK_STRN const,MK_HDL const,MK_HDL const);     
 
  class MkObjectC {
 
    friend class MkKernel;
    friend class MkObjectDeleteCallbackC;
 
/* LABEL-START */
 
 
    public:
      static thread_local MkObjectC MK_NULL_REF;
 
    private:
 
      static MkObjectC* MkObjectC_GetSelf (MK_OBJ hdl) {
        return (hdl != NULL ? static_cast<MkObjectC*>((*MkObjectC_X2obj(hdl)).self) : &MK_NULL_REF);
      }
 
    #ifdef MkObjectC_selfCreate_overload
      static MK_PTR MkObjectC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env);
    #else
      static MK_PTR MkObjectC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
        return new MkObjectC(obj);
      }
    #endif
 
      static void MkObjectC_selfDelete (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        delete static_cast<MkObjectC*>(self);
      }
 
      static void MkObjectC_selfUnlink (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        MkObjectC* selfO = static_cast<MkObjectC*>(self);
        selfO->atomUnlink();
      }
 
      void MkObjectC_Init (MK_OBJ hdl)   { atomInit(MkObjectC_X2obj(hdl)); };
 
 
      static MkObjectC* MkObjectC_ObjCreate (MK_RT_ARGS MK_OBJ hdl) {
        return static_cast<MkObjectC*>(MkObjectC::atomObjCreate(MK_RT_CALL MkObjectC_X2obj(hdl)));
      }
 
#ifndef META_IS_MkObjectC
      MkObjectC   (MK_OBJ obj) : MkObjectC(obj) {};
#endif
 
    public:
 
#ifndef META_IS_MkObjectC
      MkObjectC   (MK_OBJ hdl) : MkObjectC(MkObjectC_X2obj(hdl)) {};
#endif
 
      static MkObjectC* MkObjectC_ObjNew (MK_RT_ARGS MK_OBJ hdl) {
        return (hdl ? static_cast<MkObjectC*>(MkObjectC::atomObjNew(MK_RT_CALL MkObjectC_X2obj(hdl))) : &MK_NULL_REF);
      }
 
      MK_OBJ getOBJ() const {
        MK_OBJ ret = reinterpret_cast<MK_OBJ>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MK_OBJ getOBJ__null_allow() const {
        return reinterpret_cast<MK_OBJ>(hdl);
      };
 
      MK_OBJN getOBJN() const {
        MK_OBJN ret = reinterpret_cast<MK_OBJN>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MK_OBJN getOBJN__null_allow() const {
        return reinterpret_cast<MK_OBJN>(hdl);
      };
 
      static MK_OBJ getOBJ(MkObjectC* clsHdl) {
        MK_OBJ ret = clsHdl ? reinterpret_cast<MK_OBJ>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MkObjectC);
        return ret;
      };
 
      static MK_OBJ getOBJ__null_allow(MkObjectC* clsHdl) {
        return clsHdl ? reinterpret_cast<MK_OBJ>(clsHdl->hdl) : NULL;
      };
 
      static MK_OBJN getOBJN(const MkObjectC* clsHdl) {
        MK_OBJN ret = clsHdl ? reinterpret_cast<MK_OBJN>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MkObjectC);
        return ret;
      };
 
      static MK_OBJN getOBJN__null_allow(const MkObjectC* clsHdl) {
        return clsHdl ? reinterpret_cast<MK_OBJN>(clsHdl->hdl) : NULL;
      };
 
      static MK_OBJ getOBJ(const MkObjectC& clsHdl) {
        return clsHdl.getOBJ();
      };
 
      static MK_OBJ getOBJ__null_allow(const MkObjectC& clsHdl) {
        return clsHdl.getOBJ__null_allow();
      };
 
      static MK_OBJN getOBJN(const MkObjectC& clsHdl) {
        return clsHdl.getOBJN();
      };
 
      static MK_OBJN getOBJN__null_allow(const MkObjectC& clsHdl) {
        return clsHdl.getOBJN__null_allow();
      };
 
      bool Check() const {
        return (hdl && MkObjCheck(hdl));
      };
 
/* LABEL-END */
 
#undef META_IS_MkObjectC 
 
    protected:
      MK_OBJ  hdl = NULL;
#if META_HAS_THREAD
      MK_RT   mkrt = NULL;
#endif
 
      void atomInit (MK_OBJ obj) {
        hdl = obj;
        if (obj != NULL) MkRefIncrSelf(hdl,this,NULL);
#if META_HAS_THREAD
        mkrt = MkRT_O(obj);
#endif
      }
 
      void atomUnlink () {
        if (hdl) {
          MkRefDecrWithoutSelf(hdl);
        }
      }
 
      MkObjectC () {
        atomInit(NULL);
      };
      MkObjectC (MK_OBJ obj) {
        atomInit(obj);
      }
      
      void inline ErrorCheck (  enum MkErrorE err, 
                                MK_STRN const caller = __builtin_FUNCTION(), 
                                MK_I32  const line   = __builtin_LINE()
      ) const {
        if (MkErrorCheckI(err)) MkExceptionC::Raise(hdl, caller, line);
      }
      void inline ErrorCheck (  MK_STRN const caller = __builtin_FUNCTION(), 
                                MK_I32  const line   = __builtin_LINE()
      ) const {
        if (MkErrorCheckE_NULL())   MkExceptionC::Raise(hdl, caller, line);
      }
      static inline void ErrorCheck(
          MK_MNGN mng, enum MkErrorE err,
          MK_STRN const caller = __builtin_FUNCTION(), 
          MK_I32 const line   = __builtin_LINE()
      ) {
        if (MkErrorCheckI(err)) MkExceptionC::Raise(mng, caller, line);
      }
 
      // very often used function
      static inline MK_PTR atomObjNew (MK_RT_ARGS MK_OBJ obj) {
        MK_PTR self = NULL;
        ErrorCheck(obj, MkSelfNew(obj,&self,NULL));
        return self;
      }
      static inline MK_PTR atomObjCreate (MK_RT_ARGS MK_OBJ obj) {
        return MkSelfCreate(obj,NULL);
      }
 
    public:
 
      typedef void (MkObjectC::*MkObjectDeleteICB) (MK_STRN const,MK_HDL const,MK_HDL const);    
      typedef void (*MkObjectDeleteCCB) (MkObjectC*,MK_STRN const,MK_HDL const,MK_HDL const);    
      
      virtual ~MkObjectC  () {
        if (hdl) {
          MkRtSetup_NULL;
          // important: every item deleted with destructor… the "self" object
          // is already destroyed… set NULL in MkObjectS
          hdl = MkRefDecrWithoutSelf(hdl);
        }
      }
 
      inline MK_MNG getMNG() const {
        MK_MNG ret = reinterpret_cast<MK_MNG>(hdl);
        if (unlikely(ret == NULL)) throw std::runtime_error("MkObjectC* is NULL");
        return ret;
      };
 
      inline MK_STRN ToNativeNameOfClass() const {
        const char * str = typeid(*this).name();
        return str ? abi::__cxa_demangle(str,0,0,NULL) : "*unknown*";
      }
 
 
      inline MK_STR SysStrDup (MK_STRN str)          { return MkSysStrDup(hdl, str); }
      inline void SysFree (MK_PTR tgt)              { (*MkLal.SysFree)((MK_PTR)tgt); }
      inline void Sleep (unsigned int const sec)    { ErrorCheck (MkSysSleep(hdl, sec)); }
      inline void USleep (unsigned int const usec)  { ErrorCheck (MkSysUSleep(hdl, usec)); }
    
 
 
    public:
 
      #define ErrorCC(errnum,message) \
          MkErrorSetV(hdl,__func__,MK_ERROR,errnum,message)
 
 
    //   BEGIN-MkObjectC - created by 'cc_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Class-Export,sc_,public
 
      static MkObjectC* HandleResolve (MK_HDL netHdl);
 
      // doc-key: MkObjectC,MkObjectC-Class-Export,om_,public
 
      void HandleDelete ();
 
      MK_BOOL HandleExists ();
 
      MK_HDL HandleGet ();
 
      MK_HDL HandleGetOfType ();
 
      MK_HDL HandleGetOr0 ();
 
      // doc-key: MkObjectC,MkObjectC-Class-Export,sm_,public
 
      static void HandleDeleteByNetHdl (MK_HDL netHdl);
 
    // MkObjectC_Class_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Class-Introspection,oc_,public
 
      MkObjectC* Next ();
 
      MkObjectC* Prev ();
 
      // doc-key: MkObjectC,MkObjectC-Class-Introspection,sc_,public
 
      static MkObjectC* Instances ();
 
    // MkObjectC_Class_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Class-Misc,sc_,public
 
      static MkObjectC* GetNull ();
 
    // MkObjectC_Class_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Dbg,om_,public
 
      void DbgDump (MK_STRN message = "var", MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      void DbgL (MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void DbgL (const std::string& message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void DbgLogC (MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      void DbgO (MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      void DbgSTACK (MK_I32 skip = 0, MK_I32 num = -1, MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      // doc-key: MkObjectC,MkObjectC-Dbg,sm_,public
 
      static void DbgM (MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0);
 
      static void DbgM (const std::string& message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0);
 
    // MkObjectC_Dbg_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Log,om_,public
 
      void LogC (MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      void LogC (const std::string& message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      void LogHEX (MK_STRN callfunc, MK_BNP data) const;
 
      void LogHEX (const std::string& callfunc, MK_BNP data) const;
 
      void LogV (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, ... ) const __attribute__ ((format (printf, 4, 5)));
 
      void LogV (const std::string& callfunc, MK_DBG debug, MK_FST printfmt, ... ) const __attribute__ ((format (printf, 4, 5)));
 
      void LogVL (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const;
 
      void LogVL (const std::string& callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const;
 
      void Log (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void Log (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogLong (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogLong (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogShort (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogShort (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogType (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogType (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
    // MkObjectC_Log_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Misc,oc_,public
 
      MkErrorC* ErrorCatch (std::exception* exception = NULL, MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      MkErrorC* ErrorCatch (const std::exception& exception, MK_STRN callfunc = __builtin_FUNCTION()) const;
 
      MkErrorC* ToError ();
 
      // doc-key: MkObjectC,MkObjectC-Misc,om_,public
 
      MK_BOOL IsNull ();
 
      MK_STRN ToName () const;
 
      MK_STRN ToNameOfClass ();
 
      MK_STRN ToNameOfType () const;
 
      MK_STRN ToString () const;
 
    // MkObjectC_Misc_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Obj,om_,public
 
      MK_I32 RefGet ();
 
    // MkObjectC_Obj_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-Sys,om_,public
 
      void SysKill (MK_I32 pid, MK_I32 signal) const;
 
      // doc-key: MkObjectC,MkObjectC-Sys,omo,public
 
      MK_I32 SysGetPid () const;
 
      // doc-key: MkObjectC,MkObjectC-Sys,sm_,public
 
      static MK_I32 SysHashI32 (MK_STRN key, MK_NUM length = -1);
 
      static MK_I32 SysHashI32 (const std::string& key, MK_NUM length = -1);
 
      static MK_STRN SysHashSTR (MK_STRN key, MK_NUM length = -1);
 
      static MK_STRN SysHashSTR (const std::string& key, MK_NUM length = -1);
 
    // MkObjectC_Sys_CC_API
 
 
    public:
 
      // doc-key: MkObjectC,MkObjectC-TOR,oD_,public
 
      void Delete ();
 
      // doc-key: MkObjectC,MkObjectC-TOR,od_,public
 
      void Dispose ();
 
      // doc-key: MkObjectC,MkObjectC-TOR,sm_,public
 
      static void DeleteCallbackCleanup (MK_STRN ident);
 
      static void DeleteCallbackCleanup (const std::string& ident);
 
      void DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteCCB callback = NULL, MK_STRN filter = NULL);
 
      void DeleteCallbackSetup (const std::string& ident, MkObjectDeleteCCB callback = NULL, MK_STRN filter = NULL);
 
      void DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteICB callback = NULL, MK_STRN filter = NULL);
 
      void DeleteCallbackSetup (const std::string& ident, MkObjectDeleteICB callback = NULL, MK_STRN filter = NULL);
 
      static void DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL);
 
      static void DeleteCallbackSetup (const std::string& ident, MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL);
 
    // MkObjectC_TOR_CC_API
 
    //   END-MkObjectC - created by 'cc_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  }; // class
}   // namespace ccmkkernel
 
// vim: nowrap