Exceptions.h

#ifndef ERIS_EXCEPTIONS_H
#define ERIS_EXCEPTIONS_H

#include <Atlas/Objects/Root.h>

#include <sigc++/signal.h>

#include <string>

#include <stdexcept>

namespace Eris
{

class BaseException : public std::runtime_error
{
public:
        BaseException(const std::string &m) : 
                std::runtime_error(m), _msg(m) {;}
        virtual ~BaseException() throw();
        const std::string _msg;
};      
        
class InvalidOperation : public BaseException
{
public:
        InvalidOperation(const std::string &m) : BaseException(m) {;}
        virtual ~InvalidOperation() throw();
};
        

class IllegalMessage : public BaseException
{
public:
        IllegalMessage(const Atlas::Message::Element &m, const std::string &s) :
                BaseException(s), what(m) {;}
        virtual ~IllegalMessage() throw();
                        
        Atlas::Message::Element what;
};

class IllegalObject : public BaseException
{
public:
        IllegalObject(const Atlas::Objects::Root &o, const std::string &s) :
                BaseException(s), what(o) {;}
        virtual ~IllegalObject() throw();
                        
        Atlas::Objects::Root what;
};

class NetworkFailure : public BaseException
{
public:
        NetworkFailure(const std::string &s) :
                BaseException(s) {;}
        virtual ~NetworkFailure() throw();
};

class UnknownEntity : public BaseException
{
public:
        UnknownEntity(const std::string &msg, const std::string &id) :
                BaseException(msg), _id(id) {;}
        virtual ~UnknownEntity() throw();
        std::string _id;
};

class UnknownProperty : public InvalidOperation
{
public: 
        UnknownProperty(const std::string &p, const std::string &m) :
                InvalidOperation(m), prop(p)
        {;}
        virtual ~UnknownProperty() throw();
        
        const std::string prop;
};


typedef SigC::Signal0<void> Signal;

class OperationBlocked
{
public:
        OperationBlocked(Signal &rsig) : 
                _continue(rsig)
        {;}
        
        Signal& _continue;
};


}

#endif

---