boost/exception_ptr.hpp

   1 //Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
   2
   3 //Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef UUID_FA5836A2CADA11DC8CD47C8555D89593
   7 #define UUID_FA5836A2CADA11DC8CD47C8555D89593
   8
   9 #include <boost/config.hpp>
  10 #ifdef BOOST_NO_EXCEPTIONS
  11 #error This header requires exception handling to be enabled.
  12 #endif
  13 #include <boost/exception/exception.hpp>
  14 #include <boost/exception/info.hpp>
  15 #include <boost/exception/diagnostic_information.hpp>
  16 #include <boost/exception/detail/type_info.hpp>
  17 #include <boost/shared_ptr.hpp>
  18 #include <stdexcept>
  19 #include <new>
  20 #include <ios>
  21
  22 namespace
  23 boost
  24     {
  25 #ifndef BOOST_NO_RTTI
  26     typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;
  27
  28     inline
  29     std::string
  30     to_string( original_exception_type const & x )
  31         {
  32         return x.value()->name();
  33         }
  34 #endif
  35
  36     class exception_ptr;
  37     exception_ptr current_exception();
  38     void rethrow_exception( exception_ptr const & );
  39
  40     class
  41     exception_ptr:
  42         public exception_detail::exception_ptr_base
  43         {
  44         typedef bool exception_ptr::*unspecified_bool_type;
  45         friend exception_ptr current_exception();
  46         friend void rethrow_exception( exception_ptr const & );
  47
  48         shared_ptr<exception_detail::clone_base const> c_;
  49         bool bad_alloc_;
  50
  51         struct
  52         bad_alloc_tag
  53             {
  54             };
  55
  56         explicit
  57         exception_ptr( bad_alloc_tag ):
  58             bad_alloc_(true)
  59             {
  60             }
  61
  62         explicit
  63         exception_ptr( shared_ptr<exception_detail::clone_base const> const & c ):
  64             c_(c),
  65             bad_alloc_(false)
  66             {
  67             BOOST_ASSERT(c);
  68             }
  69
  70         void
  71         _rethrow() const
  72             {
  73             BOOST_ASSERT(*this);
  74             if( bad_alloc_ )
  75                 throw enable_current_exception(std::bad_alloc());
  76             else
  77                 c_->rethrow();
  78             }
  79
  80         bool
  81         _empty() const
  82             {
  83             return !bad_alloc_ && !c_;
  84             }
  85
  86         public:
  87
  88         exception_ptr():
  89             bad_alloc_(false)
  90             {
  91             }
  92
  93         operator unspecified_bool_type() const
  94             {
  95             return _empty() ? 0 : &exception_ptr::bad_alloc_;
  96             }
  97
  98         friend
  99         bool
 100         operator==( exception_ptr const & a, exception_ptr const & b )
 101             {
 102             return a.c_==b.c_ && a.bad_alloc_==b.bad_alloc_;
 103             }
 104
 105         friend
 106         bool
 107         operator!=( exception_ptr const & a, exception_ptr const & b )
 108             {
 109             return !(a==b);
 110             }
 111         };
 112
 113     class
 114     unknown_exception:
 115         public exception,
 116         public std::exception,
 117         public exception_detail::clone_base
 118         {
 119         public:
 120
 121         unknown_exception()
 122             {
 123             }
 124
 125         explicit
 126         unknown_exception( std::exception const & e )
 127             {
 128             add_original_type(e);
 129             }
 130
 131         explicit
 132         unknown_exception( boost::exception const & e ):
 133             boost::exception(e)
 134             {
 135             add_original_type(e);
 136             }
 137
 138         ~unknown_exception() throw()
 139             {
 140             }
 141
 142         private:
 143
 144         exception_detail::clone_base const *
 145         clone() const
 146             {
 147             return new unknown_exception(*this);
 148             }
 149
 150         void
 151         rethrow() const
 152             {
 153             throw*this;
 154             }
 155
 156         template <class E>
 157         void
 158         add_original_type( E const & e )
 159             {
 160 #ifndef BOOST_NO_RTTI
 161             (*this) << original_exception_type(&typeid(e));
 162 #endif
 163             }
 164         };
 165
 166     namespace
 167     exception_detail
 168         {
 169         template <class T>
 170         class
 171         current_exception_std_exception_wrapper:
 172             public T,
 173             public boost::exception,
 174             public clone_base
 175             {
 176             public:
 177
 178             explicit
 179             current_exception_std_exception_wrapper( T const & e1 ):
 180                 T(e1)
 181                 {
 182                 add_original_type(e1);
 183                 }
 184
 185             current_exception_std_exception_wrapper( T const & e1, boost::exception const & e2 ):
 186                 T(e1),
 187                 boost::exception(e2)
 188                 {
 189                 add_original_type(e1);
 190                 }
 191
 192             ~current_exception_std_exception_wrapper() throw()
 193                 {
 194                 }
 195
 196             private:
 197
 198             clone_base const *
 199             clone() const
 200                 {
 201                 return new current_exception_std_exception_wrapper(*this);
 202                 }
 203
 204             void
 205             rethrow() const
 206                 {
 207                 throw *this;
 208                 }
 209
 210             template <class E>
 211             void
 212             add_original_type( E const & e )
 213                 {
 214 #ifndef BOOST_NO_RTTI
 215                 (*this) << original_exception_type(&typeid(e));
 216 #endif
 217                 }
 218             };
 219
 220 #ifdef BOOST_NO_RTTI
 221         template <class T>
 222         exception const *
 223         get_boost_exception( T const * )
 224             {
 225             try
 226                 {
 227                 throw;
 228                 }
 229             catch(
 230             exception & x )
 231                 {
 232                 return &x;
 233                 }
 234             catch(...)
 235                 {
 236                 return 0;
 237                 }
 238             }
 239 #else
 240         template <class T>
 241         exception const *
 242         get_boost_exception( T const * x )
 243             {
 244             return dynamic_cast<exception const *>(x);
 245             }
 246 #endif
 247
 248         template <class T>
 249         inline
 250         shared_ptr<clone_base const>
 251         current_exception_std_exception( T const & e1 )
 252             {
 253             if( boost::exception const * e2 = get_boost_exception(&e1) )
 254                 return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1,*e2));
 255             else
 256                 return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1));
 257             }
 258
 259         inline
 260         shared_ptr<clone_base const>
 261         current_exception_unknown_exception()
 262             {
 263             return shared_ptr<unknown_exception const>(new unknown_exception());
 264             }
 265
 266         inline
 267         shared_ptr<clone_base const>
 268         current_exception_unknown_boost_exception( boost::exception const & e )
 269             {
 270             return shared_ptr<unknown_exception const>(new unknown_exception(e));
 271             }
 272
 273         inline
 274         shared_ptr<clone_base const>
 275         current_exception_unknown_std_exception( std::exception const & e )
 276             {
 277             if( boost::exception const * be = get_boost_exception(&e) )
 278                 return current_exception_unknown_boost_exception(*be);
 279             else
 280                 return shared_ptr<unknown_exception const>(new unknown_exception(e));
 281             }
 282
 283         inline
 284         shared_ptr<clone_base const>
 285         current_exception_impl()
 286             {
 287             try
 288                 {
 289                 throw;
 290                 }
 291             catch(
 292             exception_detail::clone_base & e )
 293                 {
 294                 return shared_ptr<exception_detail::clone_base const>(e.clone());
 295                 }
 296             catch(
 297             std::domain_error & e )
 298                 {
 299                 return exception_detail::current_exception_std_exception(e);
 300                 }
 301             catch(
 302             std::invalid_argument & e )
 303                 {
 304                 return exception_detail::current_exception_std_exception(e);
 305                 }
 306             catch(
 307             std::length_error & e )
 308                 {
 309                 return exception_detail::current_exception_std_exception(e);
 310                 }
 311             catch(
 312             std::out_of_range & e )
 313                 {
 314                 return exception_detail::current_exception_std_exception(e);
 315                 }
 316             catch(
 317             std::logic_error & e )
 318                 {
 319                 return exception_detail::current_exception_std_exception(e);
 320                 }
 321             catch(
 322             std::range_error & e )
 323                 {
 324                 return exception_detail::current_exception_std_exception(e);
 325                 }
 326             catch(
 327             std::overflow_error & e )
 328                 {
 329                 return exception_detail::current_exception_std_exception(e);
 330                 }
 331             catch(
 332             std::underflow_error & e )
 333                 {
 334                 return exception_detail::current_exception_std_exception(e);
 335                 }
 336             catch(
 337             std::ios_base::failure & e )
 338                 {
 339                 return exception_detail::current_exception_std_exception(e);
 340                 }
 341             catch(
 342             std::runtime_error & e )
 343                 {
 344                 return exception_detail::current_exception_std_exception(e);
 345                 }
 346             catch(
 347             std::bad_alloc & e )
 348                 {
 349                 return exception_detail::current_exception_std_exception(e);
 350                 }
 351 #ifndef BOOST_NO_TYPEID
 352             catch(
 353             std::bad_cast & e )
 354                 {
 355                 return exception_detail::current_exception_std_exception(e);
 356                 }
 357             catch(
 358             std::bad_typeid & e )
 359                 {
 360                 return exception_detail::current_exception_std_exception(e);
 361                 }
 362 #endif
 363             catch(
 364             std::bad_exception & e )
 365                 {
 366                 return exception_detail::current_exception_std_exception(e);
 367                 }
 368             catch(
 369             std::exception & e )
 370                 {
 371                 return exception_detail::current_exception_unknown_std_exception(e);
 372                 }
 373             catch(
 374             boost::exception & e )
 375                 {
 376                 return exception_detail::current_exception_unknown_boost_exception(e);
 377                 }
 378             catch(
 379             ... )
 380                 {
 381                 return exception_detail::current_exception_unknown_exception();
 382                 }
 383             }
 384         }
 385
 386     inline
 387     exception_ptr
 388     current_exception()
 389         {
 390         try
 391             {
 392             return exception_ptr(exception_detail::current_exception_impl());
 393             }
 394         catch(
 395         std::bad_alloc & )
 396             {
 397             }
 398         catch(
 399         ... )
 400             {
 401             try
 402                 {
 403                 return exception_ptr(exception_detail::current_exception_std_exception(std::bad_exception()));
 404                 }
 405             catch(
 406             std::bad_alloc & )
 407                 {
 408                 }
 409             catch(
 410             ... )
 411                 {
 412                 BOOST_ASSERT(0);
 413                 }
 414             }
 415         return exception_ptr(exception_ptr::bad_alloc_tag());
 416         }
 417
 418     template <class T>
 419     inline
 420     exception_ptr
 421     copy_exception( T const & e )
 422         {
 423         try
 424             {
 425             throw enable_current_exception(e);
 426             }
 427         catch(
 428         ... )
 429             {
 430             return current_exception();
 431             }
 432         }
 433
 434     inline
 435     void
 436     rethrow_exception( exception_ptr const & p )
 437         {
 438         p._rethrow();
 439         }
 440
 441     inline
 442     std::string
 443     to_string( exception_ptr const & p )
 444         {
 445         std::string s='\n'+diagnostic_information(p);
 446         std::string padding("  ");
 447         std::string r;
 448         bool f=false;
 449         for( std::string::const_iterator i=s.begin(),e=s.end(); i!=e; ++i )
 450             {
 451             if( f )
 452                 r+=padding;
 453             char c=*i;
 454             r+=c;
 455             f=(c=='\n');
 456             }
 457         return r;
 458         }
 459     }
 460
 461 #endif