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 saga dependencies
#include <saga/saga/base.hpp>
#include <saga/saga/util.hpp>
#include <saga/saga/error.hpp>
#include <saga/saga/object.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 
{
    class SAGA_EXCEPTION_EXPORT exception : public std::exception
    {
    private:
        TR1::shared_ptr<saga::impl::exception> impl_;
        saga::impl::exception* get_impl() const { return impl_.get(); }
        friend struct saga::impl::runtime;

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

        exception (saga::object obj, std::string const& m, error e = NoSuccess);

        exception (saga::object obj, std::vector<saga::exception> const& l);

        exception (saga::object obj, std::vector<saga::exception> const& l, error e);

        explicit exception (std::string const& m, error e = NoSuccess);

        explicit exception (std::vector<saga::exception> const& l);

        ~exception() throw() {}

        char const* what() const throw();

        char const* get_message() const throw();

        saga::error get_error () const throw();

        saga::object get_object () const throw();

        std::vector<saga::exception> const& get_all_exceptions() const throw();

        std::vector<std::string> get_all_messages() const;
    }; 

    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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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<saga::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