MkErrorC_cc.hh

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#pragma once
 
namespace ccmkkernel {
 
  typedef struct {
    MK_NUM   size;
    MkErrorC **data;
  } MkErrorC_A;
 
  class MkErrorC : public MkObjectC
  {
    friend class MkKernel;
 
/* LABEL-START */
 
 
    public:
      static thread_local MkErrorC MK_NULL_REF;
 
    private:
 
      static MkErrorC* MkErrorC_GetSelf (MK_ERR hdl) {
        return (hdl != NULL ? static_cast<MkErrorC*>((*MkErrorC_X2obj(hdl)).self) : &MK_NULL_REF);
      }
 
    #ifdef MkErrorC_selfCreate_overload
      static MK_PTR MkErrorC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env);
    #else
      static MK_PTR MkErrorC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
        return new MkErrorC(obj);
      }
    #endif
 
      static void MkErrorC_selfDelete (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        delete static_cast<MkErrorC*>(self);
      }
 
      static void MkErrorC_selfUnlink (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        MkErrorC* selfO = static_cast<MkErrorC*>(self);
        selfO->atomUnlink();
      }
 
      void MkErrorC_Init (MK_ERR hdl)   { atomInit(MkErrorC_X2obj(hdl)); };
 
 
      static MkErrorC* MkErrorC_ObjCreate (MK_RT_ARGS MK_ERR hdl) {
        return static_cast<MkErrorC*>(MkObjectC::atomObjCreate(MK_RT_CALL MkErrorC_X2obj(hdl)));
      }
 
#ifndef META_IS_MkObjectC
      MkErrorC   (MK_OBJ obj) : MkObjectC(obj) {};
#endif
 
    public:
 
#ifndef META_IS_MkObjectC
      MkErrorC   (MK_ERR hdl) : MkObjectC(MkErrorC_X2obj(hdl)) {};
#endif
 
      static MkErrorC* MkErrorC_ObjNew (MK_RT_ARGS MK_ERR hdl) {
        return (hdl ? static_cast<MkErrorC*>(MkObjectC::atomObjNew(MK_RT_CALL MkErrorC_X2obj(hdl))) : &MK_NULL_REF);
      }
 
      MK_ERR getERR() const {
        MK_ERR ret = reinterpret_cast<MK_ERR>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MK_ERR getERR__null_allow() const {
        return reinterpret_cast<MK_ERR>(hdl);
      };
 
      MK_ERRN getERRN() const {
        MK_ERRN ret = reinterpret_cast<MK_ERRN>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MK_ERRN getERRN__null_allow() const {
        return reinterpret_cast<MK_ERRN>(hdl);
      };
 
      static MK_ERR getERR(MkErrorC* clsHdl) {
        MK_ERR ret = clsHdl ? reinterpret_cast<MK_ERR>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MkErrorC);
        return ret;
      };
 
      static MK_ERR getERR__null_allow(MkErrorC* clsHdl) {
        return clsHdl ? reinterpret_cast<MK_ERR>(clsHdl->hdl) : NULL;
      };
 
      static MK_ERRN getERRN(const MkErrorC* clsHdl) {
        MK_ERRN ret = clsHdl ? reinterpret_cast<MK_ERRN>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MkErrorC);
        return ret;
      };
 
      static MK_ERRN getERRN__null_allow(const MkErrorC* clsHdl) {
        return clsHdl ? reinterpret_cast<MK_ERRN>(clsHdl->hdl) : NULL;
      };
 
      static MK_ERR getERR(const MkErrorC& clsHdl) {
        return clsHdl.getERR();
      };
 
      static MK_ERR getERR__null_allow(const MkErrorC& clsHdl) {
        return clsHdl.getERR__null_allow();
      };
 
      static MK_ERRN getERRN(const MkErrorC& clsHdl) {
        return clsHdl.getERRN();
      };
 
      static MK_ERRN getERRN__null_allow(const MkErrorC& clsHdl) {
        return clsHdl.getERRN__null_allow();
      };
 
      bool Check() const {
        return (hdl && MkErrCheck(hdl));
      };
 
/* LABEL-END */
 
  public:
 
    MkErrorC(const MkErrorC& e) {
      MkErrorC_Init(MkErrorDup_RT(MK_RT_CALL_NULL MkErrN(e.hdl)));
    }
    MkErrorC(const MkExceptionC &ex) {
      MkErrorC_Init(MkErrorDup_RT(MK_RT_CALL_NULL MkErrN(ex.hdl)));
    }
 
  public:
 
    static inline void Check(MK_MNGN mng, enum MkErrorE err) {
      if (MkErrorCheckI(err)) MkExceptionC::Raise(mng);
    }
 
    static inline void Check(enum MkErrorE err) {
      if (MkErrorCheckI(err)) MkExceptionC::Raise(MK_ERROR_DEFAULT_NULL);
    }
 
  public:
 
    static inline MkErrorC* FORMAT (MK_OBJ const fmtobj);
    
  public:
    
    static bool IsEXIT_DEFAULT   () {return MkErrorIsEXIT    (&MkERROR_NULL); }
    static bool IsSOCKET_DEFAULT () {return MkErrorIsSOCKET  (&MkERROR_NULL); }
 
    //if (errVal > MK_CONTINUE) MkErrorC::Check(error_hdl, errVal);
    
    //   BEGIN-MkErrorC - created by 'cc_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-Class-Export,sc_,public
 
      static MkErrorC* HandleResolve (MK_HDL netHdl);
 
      // doc-key: MkErrorC,MkErrorC-Class-Export,om_,public
 
      // skip class-overload: MK_HDL HandleGet ()
 
    // MkErrorC_Class_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-Class-Introspection,oc_,public
 
      MkErrorC* Next ();
 
      MkErrorC* Prev ();
 
      // doc-key: MkErrorC,MkErrorC-Class-Introspection,sc_,public
 
      static MkErrorC* Instances ();
 
    // MkErrorC_Class_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-Class-Misc,sc_,public
 
      static MkErrorC* GetNull ();
 
    // MkErrorC_Class_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-Get,om_,public
 
      MkErrorE GetCode () const;
 
      MK_I32 GetNum () const;
 
      MK_SIZE GetSize () const;
 
      MK_STRN GetText () const;
 
    // MkErrorC_Get_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-Misc,oc_,public
 
      MkErrorC* Catch (std::exception* exception = NULL, MK_STRN callfunc = __builtin_FUNCTION());
 
      MkErrorC* Catch (const std::exception& exception, MK_STRN callfunc = __builtin_FUNCTION());
 
      // doc-key: MkErrorC,MkErrorC-Misc,om_,public
 
      void Cleanup (MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 callline = __builtin_LINE());
 
      // 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
 
      void Println (MK_STRN msg = "", MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 callline = __builtin_LINE());
 
      void Reset (MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 callline = __builtin_LINE(), MK_BOOL force = false);
 
      MkErrorE Stack (MK_STRN callfunc = __builtin_FUNCTION(), MK_STRN callfile = __builtin_FILE(), MK_I32 callline = __builtin_LINE());
 
      void StackFormat (MK_STRN callfunc = __builtin_FUNCTION(), MK_STRN callfile = __builtin_FILE(), MK_I32 callline = __builtin_LINE());
 
      // skip class-overload: MK_STRN ToString () const
 
    // MkErrorC_Misc_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-Raise,oc_,public
 
      MkErrorC* NoRaise ();
 
      // doc-key: MkErrorC,MkErrorC-Raise,om_,public
 
      void AppendC (MK_STRN message);
 
      void AppendC (const std::string& message);
 
      void AppendV (MK_FST printfmt, ... ) __attribute__ ((format (printf, 2, 3)));
 
      void AppendVL (MK_FST printfmt, va_list var_list);
 
      void Raise () const;
 
      void SetC (MK_STRN message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1);
 
      void SetC (const std::string& message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1);
 
      void SetV (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) __attribute__ ((format (printf, 4, 5)));
 
      void SetV (const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, ... ) __attribute__ ((format (printf, 4, 5)));
 
      void SetVL (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list);
 
      void SetVL (const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list);
 
      // doc-key: MkErrorC,MkErrorC-Raise,sm_,public
 
      static void PanicC (const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message);
 
      static void PanicC (const MkObjectC& fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message);
 
      static void PanicC (const MkObjectC* fmtobj, const std::string& callfunc, MK_I32 errnum, const std::string& message);
 
      static void PanicC (const MkObjectC& fmtobj, const std::string& callfunc, MK_I32 errnum, const std::string& message);
 
      static void PanicDEFAULT (const MkObjectC* fmtobj = NULL, MK_STRN callfunc = __builtin_FUNCTION());
 
      static void PanicDEFAULT (const MkObjectC& fmtobj, MK_STRN callfunc = __builtin_FUNCTION());
 
      static void PanicV (const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) __attribute__ ((format (printf, 4, 5)));
 
      static void PanicV (const MkObjectC& fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) __attribute__ ((format (printf, 4, 5)));
 
      static void PanicV (const MkObjectC* fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, ... ) __attribute__ ((format (printf, 4, 5)));
 
      static void PanicV (const MkObjectC& fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, ... ) __attribute__ ((format (printf, 4, 5)));
 
      static void PanicVL (const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list);
 
      static void PanicVL (const MkObjectC& fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list);
 
      static void PanicVL (const MkObjectC* fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list);
 
      static void PanicVL (const MkObjectC& fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list);
 
    // MkErrorC_Raise_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-Signal,om_,public
 
      MK_BOOL IsABORT () const;
 
      MK_BOOL IsEXIT ();
 
      MK_BOOL IsSOCKET () const;
 
      MK_BOOL IsTIMEOUT () const;
 
      void SetABORT (MK_STRN detail = "UNKNOWN", MK_STRN callfunc = __builtin_FUNCTION());
 
      void SetCONTINUE ();
 
      void SetCode (MkErrorE code);
 
      void SetEXIT (MK_STRN callfunc = __builtin_FUNCTION());
 
      void SetSOCKET (MK_STRN detail = "UNKNOWN", MK_STRN callfunc = __builtin_FUNCTION());
 
    // MkErrorC_Signal_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-System,sc_,public
 
      static MkErrorC* DEFAULT ();
 
      static MkErrorC* FORMAT (const MkObjectC* fmtobj = NULL);
 
      static MkErrorC* FORMAT (const MkObjectC& fmtobj);
 
      static MkErrorC* IGNORE ();
 
      static MkErrorC* PRINT ();
 
    // MkErrorC_System_CC_API
 
 
    public:
 
      // doc-key: MkErrorC,MkErrorC-TOR,oCx,public
 
      MkErrorC* Dup () const;
 
      // doc-key: MkErrorC,MkErrorC-TOR,om_,public
 
      void Copy (const MkErrorC* srce);
 
      void Copy (const MkErrorC& srce);
 
    // MkErrorC_TOR_CC_API
 
    //   END-MkErrorC - created by 'cc_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
  };
}   // namespace ccmkkernel
 
#define MkErrorC_Check(errObj, errVal) \
  if (errVal > MK_CONTINUE) MkErrorC::Check(errObj, errVal)