exception.hpp

Go to the documentation of this file.

//  Copyright (c) 2005-2007 Andre Merzky (andre@merzky.net)
//  Copyright (c) 2005-2008 Hartmut Kaiser
//  Copyright (c) 2007 Ole Weidner (oweidner@cct.lsu.edu)
// 
//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef SAGA_EXCEPTION_HPP
#define SAGA_EXCEPTION_HPP

// include stl
#include <exception>
#include <iostream>
#include <string>

// include saga dependencies
#include <saga/saga/base.hpp>
#include <saga/saga/util.hpp>
#include <saga/saga/error.hpp>
#include <saga/saga/object.hpp>
#include <saga/impl/runtime.hpp>

//
namespace saga {
    
    class SAGA_EXCEPTION_EXPORT exception : public std::exception
    {
    private:
        std::string msg_;
        mutable saga::error err_;
        saga::object object_;
        
        friend class saga::impl::exception_list;
        
    public:
        // default constructor
        //       exception() {}
        
        exception (saga::object obj, std::string const& m, error e = NoSuccess) 
        : msg_(""), err_(e), object_(obj)
        {
            BOOST_ASSERT(err_ >= (saga::error)saga::adaptors::Success && 
                         err_ <= (saga::error)saga::adaptors::Unexpected);
            
            // prefix the message with the SAGA exception name (only if it's not 
            // already there)
            std::string::size_type p = m.find("SAGA(");
            if (std::string::npos == p || 0 != p)
                msg_ = std::string("SAGA(") + error_names[e] + "): ";
            msg_ += m;
            
            SAGA_VERBOSE(SAGA_VERBOSE_LEVEL_INFO) 
            {
                if (err_ != (saga::error)saga::adaptors::Success)
                    std::cerr << msg_ << std::endl;
            }
        }
        
        explicit exception (std::string const& m, error e = NoSuccess) 
        : msg_(""), err_(e)
        {
            BOOST_ASSERT(err_ >= (saga::error)saga::adaptors::Success && 
                         err_ <= (saga::error)saga::adaptors::Unexpected);
            
            // prefix the message with the SAGA exception name (only if it's not 
            // already there)
            std::string::size_type p = m.find("SAGA(");
            if (std::string::npos == p || 0 != p)
                msg_ = std::string("SAGA(") + error_names[e] + "): ";
            msg_ += m;
            
            SAGA_VERBOSE(SAGA_VERBOSE_LEVEL_INFO) 
            {
                if (err_ != (saga::error)saga::adaptors::Success)
                    std::cerr << msg_ << std::endl;
            }
        }
        
        ~exception() throw() {}
        
        char const* what() const throw() 
        { 
            return (msg_.c_str ());
        }
        
        char const* get_message() const throw() 
        { 
            return what();
        }
        
        saga::error get_error () const  
        { 
            return err_; 
        }
        
        saga::object get_object () const throw() 
        { 
            return object_; 
        }
        
    }; 
    
    
    class SAGA_EXCEPTION_EXPORT not_implemented : public saga::exception
    {
    public:
        not_implemented (saga::object obj, std::string const& m) 
        : saga::exception(obj, m, NotImplemented)
        {}
        
        explicit not_implemented (std::string const& m) 
        : saga::exception(m, NotImplemented)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT parameter_exception : public saga::exception
    {
    protected:
        parameter_exception (saga::object obj, std::string const& m, saga::error e) 
        : saga::exception(obj, m, e)
        {}
        
        parameter_exception (std::string const& m, saga::error e) 
        : saga::exception(m, e)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT incorrect_url : public saga::parameter_exception
    {
    public:
        incorrect_url (saga::object obj, std::string const& m) 
        : saga::parameter_exception(obj, m, IncorrectURL)
        {}
        
        explicit incorrect_url (std::string const& m) 
        : saga::parameter_exception(m, IncorrectURL)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT bad_parameter : public saga::parameter_exception
    {
    public:
        bad_parameter (saga::object obj, std::string const& m) 
        : saga::parameter_exception(obj, m, BadParameter)
        {}
        
        explicit bad_parameter (std::string const& m) 
        : saga::parameter_exception(m, BadParameter)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT state_exception : public saga::exception
    {
    protected:
        state_exception (saga::object obj, std::string const& m, saga::error e) 
        : saga::exception(obj, m, e)
        {}
        
        state_exception (std::string const& m, saga::error e) 
        : saga::exception(m, e)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT already_exists : public saga::state_exception
    {
    public:
        already_exists (saga::object obj, std::string const& m) 
        : saga::state_exception(obj, m, AlreadyExists)
        {}
        
        explicit already_exists (std::string const& m) 
        : saga::state_exception(m, AlreadyExists)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT does_not_exist : public saga::state_exception
    {
    public:
        does_not_exist (saga::object obj, std::string const& m) 
        : saga::state_exception(obj, m, DoesNotExist)
        {}
        
        explicit does_not_exist (std::string const& m) 
        : saga::state_exception(m, DoesNotExist)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT incorrect_state : public saga::state_exception
    {
    public:
        incorrect_state (saga::object obj, std::string const& m) 
        : saga::state_exception(obj, m, IncorrectState)
        {}
        
        explicit incorrect_state (std::string const& m) 
        : saga::state_exception(m, IncorrectState)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT security_exception : public saga::exception
    {
    protected:
        security_exception (saga::object obj, std::string const& m, saga::error e) 
        : saga::exception(obj, m, e)
        {}
        
        security_exception (std::string const& m, saga::error e) 
        : saga::exception(m, e)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT permission_denied
    : public saga::security_exception
    {
    public:
        permission_denied (saga::object obj, std::string const& m) 
        : saga::security_exception(obj, m, PermissionDenied)
        {}
        
        explicit permission_denied (std::string const& m) 
        : saga::security_exception(m, PermissionDenied)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT authorization_failed
    : public saga::security_exception
    {
    public:
        authorization_failed (saga::object obj, std::string const& m) 
        : saga::security_exception(obj, m, AuthorizationFailed)
        {}
        
        explicit authorization_failed (std::string const& m) 
        : saga::security_exception(m, AuthorizationFailed)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT authentication_failed
    : public saga::security_exception
    {
    public:
        authentication_failed (saga::object obj, std::string const& m) 
        : saga::security_exception(obj, m, AuthenticationFailed)
        {}
        
        explicit authentication_failed (std::string const& m) 
        : saga::security_exception(m, AuthenticationFailed)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT timeout : public saga::state_exception
    {
    public:
        timeout (saga::object obj, std::string const& m) 
        : saga::state_exception(obj, m, Timeout)
        {}
        
        explicit timeout (std::string const& m) 
        : saga::state_exception(m, Timeout)
        {}
    };
    
    class SAGA_EXCEPTION_EXPORT no_success : public saga::exception
    {
    public:
        no_success (saga::object obj, std::string const& m) 
        : saga::exception(obj, m, NoSuccess)
        {}
        
        explicit no_success (std::string const& m) 
        : saga::exception(m, NoSuccess)
        {}
    };
    
    //  adaptors::exception is not in the spec, but to be used by adaptors

    namespace adaptors 
    {
        class SAGA_EXCEPTION_EXPORT exception : public saga::exception 
        {
        public:
            exception (saga::object obj, 
                       std::string const& name, std::string const& m, 
                       saga::error e = NoSuccess) 
            : saga::exception (obj, name + ": " + m, e)
            {
            }
            
            ~exception (void) throw () { }
        };
        
    }   // namespace adaptors
    
} // namespace saga

#endif // SAGA_EXCEPTION_HPP

---