cexception.h

//==========================================================================
//  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 "simtime_t.h"
#include "errmsg.h"
 
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,...);
 
    cException(const cException&) = default;
 
    virtual cException *dup() const {return new cException(*this);}
 
    virtual ~cException() throw() {}
 
    virtual void setMessage(const char *txt) {msg = txt;}
 
    virtual void prependMessage(const char *txt) {msg = std::string(txt) + ": " + msg;}
 
    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,...);
 
    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,...);
 
    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