boostorg/exception
1
0
Fork 1
mirror of https://github.com/boostorg/exception.git synced 2025-07-22 16:47:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Boost Exception now works with BOOST_NO_RTTI and/or BOOST_NO_TYPEID.

Browse Source 
[SVN r48429]
This commit is contained in:
Emil Dotchevski
2008-08-28 23:49:55 +00:00
parent 14765312e2
commit 850b7d9618
20 changed files with 369 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
include/boost/exception/detail/error_info_base.hpp Normal file
View File

@ -0,0 +1,38 @@
//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
//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 UUID_CE6983AC753411DDA764247956D89593
#define UUID_CE6983AC753411DDA764247956D89593
#include <boost/detail/workaround.hpp>
#include <string>
namespace
boost
{
namespace
exception_detail
{
class
error_info_base
{
public:
virtual char const * tag_typeid_name() const = 0;
virtual std::string value_as_string() const = 0;
protected:
#if BOOST_WORKAROUND( __GNUC__, BOOST_TESTED_AT(4) )
virtual //Disable bogus GCC warning.
#endif
~error_info_base()
{
}
};
}
}
#endif

47
include/boost/exception/detail/get_boost_exception.hpp Normal file
View File

@ -0,0 +1,47 @@
//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
//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 UUID_B9A8291074CA11DD94BFC77156D89593
#define UUID_B9A8291074CA11DD94BFC77156D89593
#include <boost/exception/exception.hpp>
namespace
boost
{
namespace
exception_detail
{
#ifdef BOOST_NO_RTTI
template <class T>
exception const *
get_boost_exception( T const * )
{
try
{
throw;
}
catch(
exception & x )
{
return &x;
}
catch(...)
{
return 0;
}
}
#else
template <class T>
exception const *
get_boost_exception( T const * x )
{
return dynamic_cast<exception const *>(x);
}
#endif
}
}
#endif

3
include/boost/exception/detail/object_hex_dump.hpp
View File

@ -6,6 +6,7 @@
#ifndef UUID_6F463AC838DF11DDA3E6909F56D89593
#define UUID_6F463AC838DF11DDA3E6909F56D89593
#include <boost/exception/detail/type_info.hpp>
#include <iomanip>
#include <typeinfo>
#include <ios>
@ -24,7 +25,7 @@ boost
object_hex_dump( T const & x, size_t max_size=16 )
{
std::ostringstream s;
s << "type: " << typeid(x).name() << ", size: " << sizeof(T) << ", dump: ";
s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: ";
size_t n=sizeof(T)>max_size?max_size:sizeof(T);
s.fill('0');
s.width(2);

62
include/boost/exception/detail/type_info.hpp Normal file
View File

@ -0,0 +1,62 @@
//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
//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 UUID_C3E1741C754311DDB2834CCA55D89593
#define UUID_C3E1741C754311DDB2834CCA55D89593
#include <boost/detail/sp_typeinfo.hpp>
#include <boost/current_function.hpp>
namespace
boost
{
template <class ErrorInfoTag>
inline
char const *
error_info_value()
{
return BOOST_CURRENT_FUNCTION;
}
namespace
exception_detail
{
typedef detail::sp_typeinfo type_info_;
#ifdef BOOST_NO_TYPEID
typedef type_info_ type_info_wrapper;
#else
struct
type_info_wrapper
{
type_info_ const * type;
explicit
type_info_wrapper( type_info_ const & t ):
type(&t)
{
}
bool
operator<( type_info_wrapper const & b ) const
{
return 0!=(type->before(*b.type));
}
};
#endif
template <class ErrorInfoTag>
inline
char const *
type_name()
{
return error_info_value<ErrorInfoTag>();
}
}
}
#define BOOST_EXCEPTION_STATIC_TYPEID(T) BOOST_SP_TYPEID(T)
#endif

12
include/boost/exception/diagnostic_information.hpp
View File

@ -6,7 +6,7 @@
#ifndef UUID_0552D49838DD11DD90146B8956D89593
#define UUID_0552D49838DD11DD90146B8956D89593
#include <boost/exception/exception.hpp>
#include <boost/exception/detail/get_boost_exception.hpp>
#include <exception>
#include <string>
@ -17,10 +17,16 @@ boost
std::string
diagnostic_information( std::exception const & x )
{
if( exception const * be = dynamic_cast<exception const *>(&x) )
if( exception const * be = exception_detail::get_boost_exception(&x) )
return be->diagnostic_information();
else
return std::string("[ what: ") + x.what() + ", type: " + typeid(x).name() + " ]";
return std::string("[ what: ") + x.what() + ", type: "
#if defined(BOOST_NO_RTTI) || defined(BOOST_NO_TYPEID)
"Unknown type deriving from std::exception"
#else
+ typeid(x).name() +
#endif
" ]";
}
}

21
include/boost/exception/enable_current_exception.hpp
View File

@ -18,6 +18,19 @@ boost
namespace
exception_detail
{
inline
void
copy_boost_exception( exception * a, exception const * b )
{
*a = *b;
}
inline
void
copy_boost_exception( void *, void const * )
{
}
class
clone_base:
public counted_base
@ -64,9 +77,7 @@ boost
clone_impl( T const & x ):
T(x)
{
if( boost::exception * be1=dynamic_cast<boost::exception *>(this) )
if( boost::exception const * be2=dynamic_cast<boost::exception const *>(&x) )
*be1 = *be2;
copy_boost_exception(this,&x);
}
private:
@ -91,9 +102,7 @@ boost
T(x),
count_(0)
{
if( boost::exception * be1=dynamic_cast<boost::exception *>(this) )
if( boost::exception const * be2=dynamic_cast<boost::exception const *>(&x) )
*be1 = *be2;
copy_boost_exception(this,&x);
}
private:

50
include/boost/exception/exception.hpp
View File

@ -6,7 +6,7 @@
#ifndef UUID_274DA366004E11DCB1DDFE2E56D89593
#define UUID_274DA366004E11DCB1DDFE2E56D89593
#include <boost/config.hpp>
#include <boost/exception/detail/type_info.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/exception/detail/counted_base.hpp>
#include <boost/intrusive_ptr.hpp>
@ -15,6 +15,8 @@
namespace
boost
{
class exception;
template <class T>
class shared_ptr;
@ -27,21 +29,17 @@ boost
error_info_container:
public exception_detail::counted_base
{
virtual char const * diagnostic_information( char const *, std::type_info const & ) const = 0;
virtual shared_ptr<error_info_base const> get( std::type_info const & ) const = 0;
virtual void set( shared_ptr<error_info_base const> const & ) = 0;
virtual char const * diagnostic_information( char const *, char const * ) const = 0;
virtual shared_ptr<error_info_base const> get( type_info_ const & ) const = 0;
virtual void set( shared_ptr<error_info_base const> const &, type_info_ const & ) = 0;
};
template <class ErrorInfo>
shared_ptr<typename ErrorInfo::value_type const> get_data( exception const & );
void set_data( exception const *, shared_ptr<exception_detail::error_info_base const> const &, exception_detail::type_info_ const & );
}
template <class Tag,class T>
class error_info;
template <class E,class Tag,class T>
E const & operator<<( E const &, error_info<Tag,T> const & );
template <class ErrorInfo,class E>
shared_ptr<typename ErrorInfo::value_type const> get_error_info( E const & );
class
exception
{
@ -71,14 +69,14 @@ boost
if( data_ )
try
{
char const * w = data_->diagnostic_information(std_what,typeid(*this));
BOOST_ASSERT(0!=w);
char const * w = data_->diagnostic_information(std_what,dynamic_type_name());
BOOST_ASSERT(w!=0);
return w;
}
catch(...)
{
}
return std_what ? std_what : typeid(*this).name();
return std_what ? std_what : dynamic_type_name();
}
#if BOOST_WORKAROUND( BOOST_MSVC, BOOST_TESTED_AT(1500) )
@ -96,14 +94,22 @@ boost
private:
shared_ptr<exception_detail::error_info_base const> get( std::type_info const & ) const;
void set( shared_ptr<exception_detail::error_info_base const> const & ) const;
friend void exception_detail::set_data( exception const *, shared_ptr<exception_detail::error_info_base const> const &, exception_detail::type_info_ const & );
template <class E,class Tag,class T>
friend E const & operator<<( E const &, error_info<Tag,T> const & );
template <class ErrorInfo>
friend shared_ptr<typename ErrorInfo::value_type const> exception_detail::get_data( exception const & );
template <class ErrorInfo,class E>
friend shared_ptr<typename ErrorInfo::value_type const> get_error_info( E const & );
char const *
dynamic_type_name() const
{
return
#if defined(BOOST_NO_RTTI) || defined(BOOST_NO_TYPEID)
"Unknown type deriving from boost::exception"
#else
typeid(*this).name()
#endif
;
}
mutable intrusive_ptr<exception_detail::error_info_container> data_;
};

49
include/boost/exception/get_error_info.hpp Normal file
View File

@ -0,0 +1,49 @@
//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
//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 UUID_1A590226753311DD9E4CCF6156D89593
#define UUID_1A590226753311DD9E4CCF6156D89593
#include <boost/shared_ptr.hpp>
#include <boost/exception/detail/get_boost_exception.hpp>
#include <boost/exception/detail/error_info_base.hpp>
namespace
boost
{
namespace
exception_detail
{
template <class ErrorInfo>
inline
shared_ptr<typename ErrorInfo::value_type const>
get_data( exception const & x )
{
if( x.data_ )
if( shared_ptr<exception_detail::error_info_base const> eib = x.data_->get(BOOST_EXCEPTION_STATIC_TYPEID(ErrorInfo)) )
{
#ifndef BOOST_NO_RTTI
BOOST_ASSERT( 0!=dynamic_cast<ErrorInfo const *>(eib.get()) );
#endif
ErrorInfo const * w = static_cast<ErrorInfo const *>(eib.get());
return shared_ptr<typename ErrorInfo::value_type const>(eib,&w->value());
}
return shared_ptr<typename ErrorInfo::value_type const>();
}
}
template <class ErrorInfo,class E>
inline
shared_ptr<typename ErrorInfo::value_type const>
get_error_info( E const & some_exception )
{
if( exception const * x = exception_detail::get_boost_exception(&some_exception) )
return exception_detail::get_data<ErrorInfo>(*x);
else
return shared_ptr<typename ErrorInfo::value_type const>();
}
}
#endif

146
include/boost/exception/info.hpp
View File

@ -6,11 +6,10 @@
#ifndef UUID_8D22C4CA9CC811DCAA9133D256D89593
#define UUID_8D22C4CA9CC811DCAA9133D256D89593
#include <boost/type.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/detail/error_info_base.hpp>
#include <boost/exception/error_info.hpp>
#include <boost/exception/to_string_stub.hpp>
#include <boost/current_function.hpp>
#include <boost/shared_ptr.hpp>
#include <map>
@ -26,28 +25,6 @@ boost
typedef error_info<struct tag_throw_file,char const *> throw_file;
typedef error_info<struct tag_throw_line,int> throw_line;
namespace
exception_detail
{
class
error_info_base
{
public:
virtual std::type_info const & tag_typeid() const = 0;
virtual std::string value_as_string() const = 0;
protected:
#if BOOST_WORKAROUND( __GNUC__, BOOST_TESTED_AT(4) )
virtual //Disable bogus GCC warning.
#endif
~error_info_base()
{
}
};
}
template <class Tag,class T>
class
error_info:
@ -70,10 +47,10 @@ virtual //Disable bogus GCC warning.
private:
std::type_info const &
tag_typeid() const
char const *
tag_typeid_name() const
{
return typeid(type<Tag>);
return exception_detail::type_name<Tag>();
}
std::string
@ -85,31 +62,6 @@ virtual //Disable bogus GCC warning.
value_type const value_;
};
template <class E,class Tag,class T>
inline
E const &
operator<<( E const & x, error_info<Tag,T> const & v )
{
shared_ptr< error_info<Tag,T> > p( new error_info<Tag,T>(v) );
x.set(p);
return x;
}
template <class ErrorInfo,class E>
inline
shared_ptr<typename ErrorInfo::value_type const>
get_error_info( E const & some_exception )
{
if( exception const * x = dynamic_cast<exception const *>(&some_exception) )
if( shared_ptr<exception_detail::error_info_base const> eib = x->get(typeid(ErrorInfo)) )
{
BOOST_ASSERT( 0!=dynamic_cast<ErrorInfo const *>(eib.get()) );
ErrorInfo const * w = static_cast<ErrorInfo const *>(eib.get());
return shared_ptr<typename ErrorInfo::value_type const>(eib,&w->value());
}
return shared_ptr<typename ErrorInfo::value_type const>();
}
namespace
exception_detail
{
@ -128,30 +80,33 @@ virtual //Disable bogus GCC warning.
{
}
shared_ptr<error_info_base const>
get( std::type_info const & ti ) const
void
set( shared_ptr<error_info_base const> const & x, type_info_ const & typeid_ )
{
error_info_map::const_iterator i=info_.find(typeinfo(ti));
BOOST_ASSERT(x);
info_[type_info_wrapper(typeid_)] = x;
what_.clear();
}
shared_ptr<error_info_base const>
get( type_info_ const & ti ) const
{
error_info_map::const_iterator i=info_.find(type_info_wrapper(ti));
if( info_.end()!=i )
{
shared_ptr<error_info_base const> const & p = i->second;
#ifndef BOOST_NO_RTTI
BOOST_ASSERT( typeid(*p)==ti );
#endif
return p;
}
return shared_ptr<error_info_base const>();
}
void
set( shared_ptr<error_info_base const> const & x )
{
BOOST_ASSERT(x);
info_[typeinfo(typeid(*x))] = x;
what_.clear();
}
char const *
diagnostic_information( char const * std_what, std::type_info const & exception_type ) const
diagnostic_information( char const * std_what, char const * exception_type_name ) const
{
BOOST_ASSERT(exception_type_name!=0 && *exception_type_name );
if( what_.empty() )
{
std::string tmp;
@ -161,13 +116,13 @@ virtual //Disable bogus GCC warning.
tmp += '\n';
}
tmp += "Dynamic exception type: ";
tmp += exception_type.name();
tmp += exception_type_name;
tmp += '\n';
for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
{
shared_ptr<error_info_base const> const & x = i->second;
tmp += '[';
tmp += x->tag_typeid().name();
tmp += x->tag_typeid_name();
tmp += "] = ";
tmp += x->value_as_string();
tmp += '\n';
@ -181,25 +136,7 @@ virtual //Disable bogus GCC warning.
friend class exception;
struct
typeinfo
{
std::type_info const * type;
explicit
typeinfo( std::type_info const & t ):
type(&t)
{
}
bool
operator<( typeinfo const & b ) const
{
return 0!=(type->before(*b.type));
}
};
typedef std::map< typeinfo, shared_ptr<error_info_base const> > error_info_map;
typedef std::map< type_info_wrapper, shared_ptr<error_info_base const> > error_info_map;
error_info_map info_;
mutable std::string what_;
mutable int count_;
@ -217,27 +154,32 @@ virtual //Disable bogus GCC warning.
delete this;
}
};
inline
void
set_data( exception const * e, shared_ptr<exception_detail::error_info_base const> const & x, exception_detail::type_info_ const & typeid_ )
{
if( !e->data_ )
e->data_ = intrusive_ptr<exception_detail::error_info_container>(new exception_detail::error_info_container_impl);
e->data_->set(x,typeid_);
}
inline
void
set_data( void const *, shared_ptr<exception_detail::error_info_base const> const &, exception_detail::type_info_ const & )
{
}
}
template <class E,class Tag,class T>
inline
void
exception::
set( shared_ptr<exception_detail::error_info_base const> const & x ) const
E const &
operator<<( E const & x, error_info<Tag,T> const & v )
{
if( !data_ )
data_ = intrusive_ptr<exception_detail::error_info_container>(new exception_detail::error_info_container_impl);
data_->set(x);
}
inline
shared_ptr<exception_detail::error_info_base const>
exception::
get( std::type_info const & ti ) const
{
if( data_ )
return data_->get(ti);
else
return shared_ptr<exception_detail::error_info_base const>();
typedef error_info<Tag,T> error_info_tag_t;
shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
exception_detail::set_data(&x,p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
return x;
}
}

6
include/boost/exception_ptr.hpp
View File

@ -7,7 +7,7 @@
#define UUID_FA5836A2CADA11DC8CD47C8555D89593
#include <boost/exception/enable_current_exception.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/detail/get_boost_exception.hpp>
#include <boost/exception/detail/cloning_base.hpp>
#include <stdexcept>
#include <new>
@ -72,7 +72,7 @@ boost
exception_ptr
current_exception_std_exception( T const & e1 )
{
if( boost::exception const * e2 = dynamic_cast<boost::exception const *>(&e1) )
if( boost::exception const * e2 = get_boost_exception(&e1) )
return exception_ptr(exception_detail::make_clone(current_exception_std_exception_wrapper<T>(e1,*e2)));
else
return exception_ptr(exception_detail::make_clone(current_exception_std_exception_wrapper<T>(e1)));
@ -89,7 +89,7 @@ boost
exception_ptr
current_exception_unknown_std_exception( std::exception const & e )
{
if( boost::exception const * be = dynamic_cast<boost::exception const *>(&e) )
if( boost::exception const * be = get_boost_exception(&e) )
return exception_ptr(exception_detail::make_clone(unknown_exception(*be)));
else
return current_exception_unknown_exception();

4
include/boost/throw_exception.hpp
View File

@ -24,8 +24,8 @@
#include <boost/detail/workaround.hpp>
#include <exception>
#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( BOOST_NO_TYPEID )
# define BOOST_EXCEPTION_DISABLE
#if !defined( BOOST_EXCEPTION_DISABLE )
#define BOOST_EXCEPTION_DISABLE
#endif
#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, < 0x590 )