MkExceptionC_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
#pragma once
 
#include <exception>
#include <stdexcept>
 
#define InstHdlIsNullError()      throw HdlIsNullError(ToNativeNameOfClass())
#define ClassHdlIsNullError(cls)  throw HdlIsNullError(#cls)
 
namespace ccmkkernel {
 
  class MkExceptionC : public std::exception
  { 
    friend class MkErrorC;
 
 
    protected:
      MK_ERR          hdl;
 
      MkExceptionC    (MK_ERR        err, MK_STRN const caller, MK_I32 const line);
      MkExceptionC    (MK_MNGN const mng, MK_STRN const caller, MK_I32 const line);
 
    public:
 
      MkExceptionC(const MkExceptionC& e);
 
      virtual ~MkExceptionC() throw();
 
      inline virtual MK_STRN what() const throw() {
        return MkBUF_R(&hdl->text).storage.first.C;
      }
 
      inline void Log(
        MK_DBG debug = 0, 
        MK_STRN callfunc = __builtin_FUNCTION(), 
        MK_I32 lvl = 0
      ) const {
        MkRtSetup_X(hdl);
        MkErrorLog(hdl, NULL, debug, callfunc, lvl);
      }
 
    public:
 
      static void           Raise (
          MK_MNGN         const expobj, 
          MK_STRN         const callfunc      = __builtin_FUNCTION(), 
          MK_I32          const callline      = __builtin_LINE()
      );
 
      static MK_ERR         Catch   (
          MK_MNGN         const expobj, 
          std::exception  const *exception,  
          MK_STRN         const callfunc      = __builtin_FUNCTION()
      );
      static inline MK_ERR  Catch   (
          MK_MNGN         const expobj, 
          std::exception  const &exception,  
          MK_STRN         const callfunc      = __builtin_FUNCTION()
      ) {
        return Catch(expobj, &exception, callfunc);
      }
      static MK_ERR  Catch   (
          MK_MNGN         const expobj, 
          const std::string&    msg,
          MK_STRN         const callfunc      = __builtin_FUNCTION()
      );
 
    // MkExceptionC_CC_API
  };
 
  class MkKernelException : public std::runtime_error
  {
    public:
      std::string func;
      std::string file;
      int    line;
    MkKernelException(const std::string& what, 
      std::string func = __builtin_FUNCTION(), std::string file = __builtin_FILE(), int line = __builtin_LINE()) 
        : runtime_error(what), func(func), file(file), line(line) {}
  };
 
  class MkReferenceNullExceptionC : public MkKernelException
  { 
    public:
      inline MkReferenceNullExceptionC(const std::string& what,
        std::string func = __builtin_FUNCTION(), std::string file = __builtin_FILE(), int line = __builtin_LINE()) 
          : MkKernelException("the reference of '" + what + "' is NULL", func, file, line) {}
  };
 
  class MkConstructorNullExceptionC : public MkKernelException
  { 
    public:
      inline MkConstructorNullExceptionC(const std::string& what,
        std::string func = __builtin_FUNCTION(), std::string file = __builtin_FILE(), int line = __builtin_LINE()) 
          : MkKernelException("the constructor '" + what + "' has a NULL pointer", func, file, line) {}
  };
 
  class MkInitError : public MkKernelException
  { 
    public:
      inline MkInitError(const std::string& what,
        std::string func = __builtin_FUNCTION(), std::string file = __builtin_FILE(), int line = __builtin_LINE()) 
          : MkKernelException("InitError: '" + what + "' constructor return 'NULL' pointer", func, file, line) {}
  };
 
  class MkInitSoftError : public MkKernelException
  { 
    public:
      inline MkInitSoftError(const std::string& what,
        std::string func = __builtin_FUNCTION(), std::string file = __builtin_FILE(), int line = __builtin_LINE()) 
          : MkKernelException("InitSoftError: '" + what + "' soft constructor return 'NULL' pointer", func, file, line) {}
  };
 
  class HdlIsNullError : public MkKernelException
  { 
    public:
      inline HdlIsNullError(const std::string& what, 
        std::string func = __builtin_FUNCTION(), std::string file = __builtin_FILE(), int line = __builtin_LINE()) 
          : MkKernelException(std::string("'") + what + "' hdl is NULL", func, file, line) {}
 
      inline HdlIsNullError(const char* what,
        std::string func = __builtin_FUNCTION(), std::string file = __builtin_FILE(), int line = __builtin_LINE())
          : HdlIsNullError(std::string(what), func, file, line) {}
  };
 
}