cexception.h

//==========================================================================
//  CEXCEPTION.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Exception class
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CEXCEPTION_H
#define __CEXCEPTION_H

#include <stdarg.h>
#include <exception>
#include <stdexcept>
#include "simkerneldefs.h"
#include "simtime_t.h"
#include "errmsg.h"
#include "opp_string.h"

NAMESPACE_BEGIN

class cObject;
class cComponent;

class SIM_API cException : public std::exception
{
  protected:
    int errorcode;
    std::string msg;

    int simulationstage;
    eventnumber_t eventnumber;
    simtime_t simtime;

    bool hascontext;
    std::string contextclassname;
    std::string contextfullpath;
    int moduleid;

    void init(const cObject *obj, OppErrorCode errorcode, const char *fmt, va_list va);

    // helper for init()
    void storeCtx();

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

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

    cException(const cObject *where, OppErrorCode 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() {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 getModuleID() const {return moduleid;}
};

class SIM_API cTerminationException : public cException
{
  public:
    cTerminationException(OppErrorCode errcode,...);

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

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

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

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

class SIM_API cRuntimeError : public cException
{
  protected:
    // internal
    void breakIntoDebuggerIfRequested();

  public:
    cRuntimeError(OppErrorCode errcode,...);

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

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

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

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

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

class SIM_API cDeleteModuleException : public cException
{
  public:
    cDeleteModuleException() : cException() {}

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

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

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

class SIM_API cStackCleanupException : public cException
{
  public:
    cStackCleanupException() : cException() {}

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

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

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

NAMESPACE_END


#endif