Boost logo

Boost :

From: Emil Dotchevski (emildotchevski_at_[hidden])
Date: 2006-06-21 15:33:43

> I was reading this and thinking, is this necessary? But it is. Quite an
> interesting approach that I've never thought of.
> How does the catch handler actually process this information?
> Could you write an example that would show how you could give detailed
> information? I think I can see it, but I'm not quite sure.

The main issue for me was to decouple the context information from the type
of the exception, and the main reason for this is that the same exception
could be thrown in different contexts (by the same throw statement), and
require different information attached to it.

So the question then was how to store the attachments.

As I mentioned in my previous post, in my implementation I wrote a class
called info, which stores the attachments in a map of boost::any objects,
associated by their type_info. Then I wrote a simple "info wrapper" class
template, something along the following lines:

template <class T,class Tag>
class info_wrapper //value type
    info_wrapper( T const & v ): value_(v) { }
    T const & get() const { return value_; }
    T value_;

template <class Tag,class T>
info_wrapper<T,Tag> wrap_info( T const & v )
    return info_wrapper<T,Tag>(v);

template <class Tag,class T>
T const * get_info( info const & xi )
    if( info_wrapper<T,Tag> const * w=xi->get< info_wrapper<T,Tag> >() )
        return &w->get();
        return 0;

The xi->get<> member function template returns a pointer to the attachment
of the specified type stored in the info object, or null if the info object
doesn't store an attachment of the specified type.

Then I have two other function templates:

template <class Tag>
info_wrapper<std::string,Tag> wrap_string( char const * s )
    return wrap_info<Tag>( std::string(s) );

template <class Tag>
char const * get_string( info const & xi )
    if( std::string const * s = get_info<Tag,std::string>(xi) )
        return s.c_str();
        return 0;

Now, with this setup I can attach strings to exceptions, and access them by
their tags, like so:

class tag_file_name; //incomplete
info & xi = ....;
xi.add( wrap_string<tag_file_name>("filename.txt") );

At the catch site, I can extract the file name like this:

catch( read_error & x )
    if( info * xi = dynamic_cast<info *>(&x) )
        if( char const * file_name = get_string<tag_file_name>(*xi) )
        //file_name is the file name attached to the read_error exception.

Here is an example which demonstrates the necessity of this system. Consider
the situation when you copy one file to another, by repeatedly calling a
"read" function and a "write" function, each of which could throw. Clearly,
in the context of this copy operation, an exception should have both the
source and the target file name (in a more typical context you only need one
file name attached.) This is how you can accomplish this with the presented

class tag_src_file_name;
class tag_dst_file_name;

boost::shared_ptr<FILE> src = io::fopen(src_name,"rb");
boost::shared_ptr<FILE> dst = io::fopen(dst_name,"wb");
    while( !done )
        read(src,buffer); //throws by throw failed<read_error>()
        write(dst,buffer); //throws by throw failed<write_error>()
catch( info & xi )
    xi.add( wrap_string<tag_src_file_name>(src_name) );
    xi.add( wrap_string<tag_dst_file_name>(dst_name) );

Assuming both read_error and write_error derive from io_error, here's what
the catch could look like:

catch( io_error & x )
    if( info * xi = dynamic_cast<info *>(&x) )
        if( char const * file_name = get_string<tag_file_name>(*xi) )
            ....; //we've got a file name
        if( char const * src_name = get_string<tag_src_file_name>(*xi) )
            ....; //we've got a source file name
        if( char const * dst_name = get_string<tag_dst_file_name>(*xi) )
            ....; //we've got a destination file name

Of course, read_error and write_error exceptions could be processed
separately, if necessary.

And finally, I indicated in my previous post that attachments can be added
directly in the throw-statement. Please don't flame me for the operator<<
overload, it is necessary to allow composition of attachments.

The simplest form of throwing would be this:

throw failed<read_error>();

The above throw-expression throws an exception with no attachments (but with
the ability to have stuff attached to it later.)

You can also do this:

throw failed<read_error>() << wrap_errno();

Here, wrap_errno is a function that captures the current errno value, and
returns it as an object of some type, which is then stored in the info
sub-object of the exception being thrown. Of course, you can attach more
stuff directly in the throw-expression, by following with more calls to

Here is another example from my own code:

namespace file
    size_t fread( void * buffer, size_t size, size_t count,
boost::shared_ptr<FILE> const & f )
    assert( f );
    size_t nr = ::fread(buffer,size,count,f.get());
    if( !ferror(f.get()) )
        return nr;
        throw failed<fread_error>()
            << wrap_errno()
            << wrap_function("fread")
            << boost::weak_ptr<FILE>(f);


Boost list run by bdawes at, gregod at, cpdaniel at, john at