Boost Exception

Transporting of Exceptions between Threads

Boost Exception supports transporting of exception objects between threads through cloning. This system is similar to N2179, but because Boost Exception can not rely on language support, the use of enable_exception_cloning() at the time of the throw is required in order to use cloning.

Note:

All exceptions emitted by the familiar function boost::throw_exception() are guaranteed to derive from boost::exception and to support cloning.

Using enable_exception_cloning() at the Time of the Throw

Here is how cloning can be enabled in a throw-expression (15.1):

#include <boost/exception/enable_exception_cloning.hpp>
#include <boost/exception/info.hpp>
#include <stdio.h>
#include <errno.h>

typedef boost::error_info<struct tag_errno,int> errno_info;

class file_read_error: public boost::exception { };

void
file_read( FILE * f, void * buffer, size_t size )
    {
    if( size!=fread(buffer,1,size,f) )
        throw boost::enable_exception_cloning(file_read_error()) <<
            errno_info(errno);
    }

Cloning and Re-throwing an Exception

When you catch a boost::exception, you can call clone_exception() to get an exception_ptr object:

#include <boost/exception/cloning.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>

void do_work(); //throws cloning-enabled boost::exceptions

void
worker_thread( boost::exception_ptr & error )
    {
    try
        {
        do_work();
        error = boost::exception_ptr();
        }
    catch(
    boost::exception & e )
        {
        error = boost::clone_exception(e);
        }
    }

In the above example, note that clone_exception() captures the original type of the exception object, even though e refers to the base type boost::exception. This original type can be thrown again using the rethrow_exception() function:

// ...continued

void
work()
    {
    boost::exception_ptr error;
    boost::thread t( boost::bind(worker_thread,boost::ref(error)) );
    t.join();
    if( error )
        boost::rethrow_exception(error);
    }

Clone_exception() could fail to copy the original exception object in the following cases:

if there is not enough memory, in which case the returned exception_ptr points to an instance of std::bad_alloc, or
if enable_exception_cloning() was not used in the throw-expression passed to the original throw statement, in which case the returned exception_ptr points to an instance of unknown_exception.

Regardless, the use of clone_exception() and rethrow_exception() in the above examples is well-formed.

Boost Exception

Transporting of Exceptions between Threads

Note:

Using enable_exception_cloning() at the Time of the Throw

Cloning and Re-throwing an Exception

See also: