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 char *fmt, va_list va);

    // 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,...);

    cException(const char *msg,...);

    cException(const cObject *where, ErrorCodeInt errcode,...);

    cException(const cObject *where, const char *msg,...);

    cException(const cException&);

    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,...);

    cTerminationException(const char *msg,...);

    cTerminationException(const cTerminationException& e) : cException(e) {}

    virtual cTerminationException *dup() const override {return new cTerminationException(*this);}

    virtual bool isError() const override {return false;}
};

class SIM_API cRuntimeError : public cException
{
  public:
    // internal
    bool displayed = false;
  protected:
    // internal
    void notifyEnvir();

  public:

    cRuntimeError(ErrorCodeInt errcode,...);

    cRuntimeError(const char *msg,...);

    cRuntimeError(const cObject *where, ErrorCodeInt errcode,...);

    cRuntimeError(const cObject *where, const char *msg,...);

    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) : cException(e), toDelete(e.toDelete) {}

    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) : cException(e) {}

    virtual cStackCleanupException *dup() const override {return new cStackCleanupException(*this);}

    virtual bool isError() const override {return false;}
};

}  // namespace omnetpp


#endif