cexception.h Source File¶

API: cexception.h Source File
API
//==========================================================================
//  CEXCEPTION.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_CEXCEPTION_H
#define __OMNETPP_CEXCEPTION_H
 
#include <cstdarg>
#include <exception>
#include <stdexcept>
#include "simkerneldefs.h"
#include "simutil.h"
#include "simtime_t.h"
#include "errmsg.h"
 
#if __cplusplus >= 202002L // only with C++20 or later
#include <format>
#endif
 
namespace omnetpp {
 
class cObject;
class cComponent;
class cModule;
typedef int ErrorCodeInt;
class SIM_API cException : public std::exception
{
  protected:
    ErrorCode errorCode;
    std::string msg;
 
    int simulationStage;
    eventnumber_t eventNumber;
    simtime_t simtime;
 
    bool hasContext_;
    std::string contextClassName;
    std::string contextFullPath;
    int contextComponentId;
    int contextComponentKind; // actually cComponent::ComponentKind
    void init(const cObject *obj, ErrorCode errorcode, const std::string& msg);
 
    // helper for init()
    void storeContext();
 
    // default constructor, for subclasses only.
    cException();
 
    //
    // Helper, called from cException constructors.
    //
    // If an exception occurs in initialization code (during construction of
    // global objects, before main() is called), there is nobody who could
    // catch the error, so it would just cause a program abort.
    // Here we handle this case manually: if cException ctor is invoked before
    // main() has started, we print the error message and call exit(1).
    //
    void exitIfStartupError();
 
  public:
    cException(ErrorCodeInt errcode,...);
    _OPP_GNU_ATTRIBUTE(format(printf, 2, 3))
    cException(const char *msg,...);
    cException(const cObject *where, ErrorCodeInt errcode,...);
    _OPP_GNU_ATTRIBUTE(format(printf, 3, 4))
    cException(const cObject *where, const char *msg,...);
 
#if __cplusplus >= 202002L // only with C++20 or later
    template<typename... Args>
    cException(opp_fmtstr fmt, Args&&... args) {
        init(nullptr, E_CUSTOM, std::vformat(fmt.str, std::make_format_args(args...)));
    }
    template<typename... Args>
    cException(const cObject *where, opp_fmtstr fmt, Args&&... args) {
        init(where, E_CUSTOM, std::vformat(fmt.str, std::make_format_args(args...)));
    }
 
#endif // C++20
    cException(const cException&) = default;
    virtual cException *dup() const {return new cException(*this);}
    virtual ~cException() throw() {}
    virtual void setMessage(const char *txt) {msg = txt;}
    _OPP_GNU_ATTRIBUTE(format(printf, 2, 3))
    virtual void prependMessage(const char *fmt, ...);
    _OPP_GNU_ATTRIBUTE(format(printf, 2, 3))
    virtual void appendMessage(const char *fmt, ...);
    virtual bool isError() const {return true;}
    virtual int getErrorCode() const {return errorCode;}
    virtual const char *what() const throw() override {return msg.c_str();}
    virtual std::string getFormattedMessage() const;
    virtual int getSimulationStage() const {return simulationStage;}
    virtual eventnumber_t getEventNumber() const {return eventNumber;}
    virtual simtime_t getSimtime() const {return simtime;}
    virtual bool hasContext() const {return hasContext_;}
    virtual const char *getContextClassName() const {return contextClassName.c_str();}
    virtual const char *getContextFullPath() const {return contextFullPath.c_str();}
    virtual int getContextComponentId() const {return contextComponentId;}
    virtual int getContextComponentKind() const {return contextComponentKind;}
};
class SIM_API cTerminationException : public cException
{
  public:
    cTerminationException(ErrorCodeInt errcode,...);
    _OPP_GNU_ATTRIBUTE(format(printf, 2, 3))
    cTerminationException(const char *msg,...);
 
#if __cplusplus >= 202002L // only with C++20 or later
    template<typename... Args>
    cTerminationException(opp_fmtstr fmt, Args&&... args) {
        init(nullptr, E_CUSTOM, std::vformat(fmt.str, std::make_format_args(args...)));
    }
 
#endif
    cTerminationException(const cTerminationException& e)  = default;
    virtual cTerminationException *dup() const override {return new cTerminationException(*this);}
    virtual bool isError() const override {return false;}
};
 
// The debugger needs to check if the exception that is being thrown is a termination exception or not,
// because the user mostly doesn't want to break into the debugger when the simulation terminates.
// Unfortunately, the std::type_info structure can't easily be used in the breakpoint conditional expression,
// so we provide this function that returns a pointer to the type_info of cTerminationException.
extern const std::type_info *getTerminationExceptionTypeInfoPointer();
class SIM_API cRuntimeError : public cException
{
  public:
    // internal
    bool displayed = false;
  protected:
    // internal
    void notifyEnvir();
 
  public:
    cRuntimeError(ErrorCodeInt errcode,...);
    _OPP_GNU_ATTRIBUTE(format(printf, 2, 3))
    cRuntimeError(const char *msg,...);
    cRuntimeError(const cObject *where, ErrorCodeInt errcode,...);
    _OPP_GNU_ATTRIBUTE(format(printf, 3, 4))
    cRuntimeError(const cObject *where, const char *msg,...);
 
#if __cplusplus >= 202002L // only with C++20 or later
    template<typename... Args>
    cRuntimeError(opp_fmtstr fmt, Args&&... args) {
        init(nullptr, E_CUSTOM, std::vformat(fmt.str, std::make_format_args(args...)));
        notifyEnvir();
    }
    template<typename... Args>
    cRuntimeError(const cObject *where, opp_fmtstr fmt, Args&&... args) {
        init(where, E_CUSTOM, std::vformat(fmt.str, std::make_format_args(args...)));
        notifyEnvir();
    }
 
#endif
    cRuntimeError(const std::exception& e, const char *location);
    cRuntimeError(const cRuntimeError& e) : cException(e) {}
    virtual cRuntimeError *dup() const override {return new cRuntimeError(*this);}
};
class SIM_API cDeleteModuleException : public cException
{
  protected:
    cModule *toDelete;
 
  public:
    cDeleteModuleException(cModule *toDelete) : cException(), toDelete(toDelete) {}
    cDeleteModuleException(const cDeleteModuleException& e)  = default;
    virtual cDeleteModuleException *dup() const override {return new cDeleteModuleException(*this);}
    virtual cModule *getModuleToDelete() const {return toDelete;}
    virtual bool isError() const override {return false;}
};
class SIM_API cStackCleanupException : public cException
{
  public:
    cStackCleanupException() : cException() {}
    cStackCleanupException(const cStackCleanupException& e)  = default;
    virtual cStackCleanupException *dup() const override {return new cStackCleanupException(*this);}
    virtual bool isError() const override {return false;}
};
 
}  // namespace omnetpp
 
 
#endif
 
 