# Boost Exception

## Synopsis

List of documented definitions, declarations and includes by header file:

#include <boost/exception/exception.hpp>

    namespace
    boost
        {
        class
        exception
            {
            protected:

            exception();
            exception( exception const & x );
            ~exception();
            };

        template <class Tag,class T>
        class error_info;

        typedef error_info<struct tag_throw_function,char const *> throw_function;
        typedef error_info<struct tag_throw_file,char const *> throw_file;
        typedef error_info<struct tag_throw_line,int> throw_line;
        }

#include <boost/exception/error_info.hpp>

    namespace
    boost
        {
        template <class Tag,class T>
        class error_info;
        }

#include <boost/exception/info.hpp>

    #include <boost/exception/exception.hpp>

    namespace
    boost
        {
        template <class Tag,class T>
        class
        error_info
            {
            public:

            typedef T value_type;

            error_info( value_type const & v );
            value_type const & value() const;
            };

        template <class E, class Tag, class T>
        E const & operator<<( E const & x, error_info<Tag,T> const & v );
        }

#include <boost/exception/info_tuple.hpp>

    #include <boost/exception/info.hpp>
    #include <boost/tuple/tuple.hpp>

    namespace
    boost
        {
        template <class E, class Tag1, class T1, ..., class TagN, class TN>
        E const & operator<<( E const & x,
            tuple<
                error_info<Tag1,T1>,
                ...,
                error_info<TagN,TN> > const & v );
        }

#include <boost/exception/enable_error_info.hpp>

    #include <boost/exception/exception.hpp>

    namespace
    boost
        {
        template <class T>
        ---unspecified--- enable_error_info( T const & x );
        }

#include <boost/exception/diagnostic_information.hpp>

    #include <string>

    namespace
    boost
        {
        class exception;

        template <class E>
        std::string diagnostic_information( E const & e );

        std::string current_exception_diagnostic_information();
        }

#include <boost/exception/current_exception_cast.hpp>

    namespace
    boost
        {
        template <class E>
        E * current_exception_cast();
        }

#include <boost/exception_ptr.hpp>

    #include <boost/exception/exception.hpp>

    namespace
    boost
        {
        class
        unknown_exception:
            public std::exception
            public boost::exception
            {
            ---unspecified---
            };

        typedef ---unspecified--- exception_ptr;

        template <class T>
        exception_ptr copy_exception( T const & e );

        exception_ptr current_exception();

        void rethrow_exception( exception_ptr const & ep );
        }

#include <boost/exception/enable_current_exception.hpp>

    #include <boost/exception/exception.hpp>

    namespace
    boost
        {
        template <class T>
        ---unspecified--- enable_current_exception( T const & e );
        }

#include <boost/throw_exception.hpp>

    #if !defined( BOOST_EXCEPTION_DISABLE )
        #include <boost/exception/exception.hpp>
        #include <boost/current_function.hpp>
        #define BOOST_THROW_EXCEPTION(x)\
            ::boost::throw_exception( ::boost::enable_error_info(x) <<\
            ::boost::throw_function(BOOST_CURRENT_FUNCTION) <<\
            ::boost::throw_file(__FILE__) <<\
            ::boost::throw_line((int)__LINE__) )
    #else
        #define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x)
    #endif

    namespace
    boost
        {
    #ifdef BOOST_NO_EXCEPTIONS
        void throw_exception( std::exception const & e ); // user defined
    #else
        template <class E>
        void throw_exception( E const & e );
    #endif
        }

#include <boost/exception.hpp>

    #include <boost/exception/diagnostic_information.hpp>
    #include <boost/exception/error_info.hpp>
    #include <boost/exception/exception.hpp>
    #include <boost/exception/get_error_info.hpp>
    #include <boost/exception/info.hpp>
    #include <boost/exception/info_tuple.hpp>
    #include <boost/exception_ptr.hpp>

### See Also:

Boost Exception