exception.hpp

Go to the documentation of this file.

//  Copyright (c) 2005-2007 Andre Merzky (andre@merzky.net)
//  Copyright (c) 2005-2009 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 <vector>

#include <boost/assert.hpp>

// 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>

// suppress warnings about dependent classes not being exported from the dll
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable: 4251 4231 4660)
#endif

//
namespace saga 
{
    namespace detail
    {
        // return the most significant error from the list
        SAGA_EXPORT error get_error(std::vector<exception> const&);

        // return the full hierarchy of messages corresponding to the exception 
        // in the list
        SAGA_EXPORT std::string get_message(std::vector<exception> const&);

        // return the message associated with the most significant error in 
        // the list
        SAGA_EXPORT std::string get_top_message(std::vector<exception> const&);

        // return a list of (fully hierachical) messages for all errors in the
        // list
        SAGA_EXPORT std::vector<std::string> get_all_messages(std::vector<exception> const&);
    }

    class SAGA_EXCEPTION_EXPORT exception : public std::exception
    {
    private:
        std::string msg_;
        std::string fullmsg_;
        mutable saga::error err_;
        saga::object object_;
        std::vector<exception> exceptions_;

        friend class saga::impl::exception_list;

    public:
        // default constructor
        //       exception() {}

        exception (saga::object obj, std::string const& m, error e = NoSuccess) 
          : msg_(""), fullmsg_(""), 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 << "Created exception: " << msg_ << std::endl;
            }
        }

        exception (saga::object obj, std::vector<exception> const& l) 
          : msg_(detail::get_top_message(l)), fullmsg_(detail::get_message(l)), 
            err_(detail::get_error(l)), object_(obj), 
            exceptions_(l)
        {
            BOOST_ASSERT(err_ >= (saga::error)saga::adaptors::Success && 
                         err_ <= (saga::error)saga::adaptors::Unexpected);

            SAGA_VERBOSE(SAGA_VERBOSE_LEVEL_INFO) 
            {
                if (err_ != (saga::error)saga::adaptors::Success)
                    std::cerr << "Created exception: " << fullmsg_ << 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 << "Created exception: " << msg_ << std::endl;
            }
        }

        explicit exception (std::vector<exception> const& l) 
          : msg_(detail::get_top_message(l)), fullmsg_(detail::get_message(l)), 
            err_(detail::get_error(l)), exceptions_(l)
        {
            BOOST_ASSERT(err_ >= (saga::error)saga::adaptors::Success && 
                         err_ <= (saga::error)saga::adaptors::Unexpected);

            SAGA_VERBOSE(SAGA_VERBOSE_LEVEL_INFO) 
            {
                if (err_ != (saga::error)saga::adaptors::Success)
                    std::cerr << "Created exception: " << fullmsg_ << std::endl;
            }
        }

        ~exception() throw() {}

        char const* what() const throw() 
        { 
            return fullmsg_.empty() ? msg_.c_str() : fullmsg_.c_str();
        }

        char const* get_message() const throw() 
        { 
            return msg_.c_str();    // top level message only
        }

        saga::error get_error () const throw() 
        { 
            return err_; 
        }

        saga::object get_object () const throw() 
        { 
            return object_; 
        }

        std::vector<exception> const& get_all_exceptions() const throw()
        {
            return exceptions_;
        }

        std::vector<std::string> get_all_messages() const
        {
            return detail::get_all_messages(exceptions_);
        }
    }; 

    class SAGA_EXCEPTION_EXPORT not_implemented : public saga::exception
    {
    public:
        not_implemented (saga::object obj, std::string const& m) 
          : saga::exception(obj, m, NotImplemented)
        {}

        not_implemented (saga::object obj, std::vector<exception> const& l) 
          : saga::exception(obj, l)
        {}

        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 (saga::object obj, std::vector<exception> const& l) 
          : saga::exception(obj, l)
        {}

        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)
        {}

        incorrect_url (saga::object obj, std::vector<exception> const& l) 
          : saga::parameter_exception(obj, l)
        {}

        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)
        {}

        bad_parameter (saga::object obj, std::vector<exception> const& l) 
          : saga::parameter_exception(obj, l)
        {}

        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 (saga::object obj, std::vector<exception> const& l) 
          : saga::exception(obj, l)
        {}

        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)
        {}

        already_exists (saga::object obj, std::vector<exception> const& l) 
          : saga::state_exception(obj, l)
        {}

        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)
        {}

        does_not_exist (saga::object obj, std::vector<exception> const& l) 
          : saga::state_exception(obj, l)
        {}

        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)
        {}

        incorrect_state (saga::object obj, std::vector<exception> const& l) 
          : saga::state_exception(obj, l)
        {}

        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 (saga::object obj, std::vector<exception> const& l) 
          : saga::exception(obj, l)
        {}

        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)
        {}

        permission_denied (saga::object obj, std::vector<exception> const& l) 
          : saga::security_exception(obj, l)
        {}

        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)
        {}

        authorization_failed (saga::object obj, std::vector<exception> const& l) 
          : saga::security_exception(obj, l)
        {}

        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)
        {}

        authentication_failed (saga::object obj, std::vector<exception> const& l) 
          : saga::security_exception(obj, l)
        {}

        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)
        {}

        timeout (saga::object obj, std::vector<exception> const& l) 
          : saga::state_exception(obj, l)
        {}

        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)
        {}

        no_success (saga::object obj, std::vector<exception> const& l) 
          : saga::exception(obj, l)
        {}

        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 (saga::object obj, std::vector<saga::exception> const& l)
              : saga::exception (obj, l)
            {
            }

            ~exception (void) throw () {}
        };

    }   // namespace adaptors

} // namespace saga

// re-enable warnings about dependent classes not being exported from the dll
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif

#endif // SAGA_EXCEPTION_HPP

---