ceph/src/boost/boost/exception/exception.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 BOOST_EXCEPTION_274DA366004E11DCB1DDFE2E56D89593
   7 #define BOOST_EXCEPTION_274DA366004E11DCB1DDFE2E56D89593
   8
   9 #include <boost/config.hpp>
  10
  11 #ifdef BOOST_EXCEPTION_MINI_BOOST
  12 #include  <memory>
  13 namespace boost { namespace exception_detail { using std::shared_ptr; } }
  14 #else
  15 namespace boost { template <class T> class shared_ptr; }
  16 namespace boost { namespace exception_detail { using boost::shared_ptr; } }
  17 #endif
  18
  19 #if !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
  20 #if __GNUC__*100+__GNUC_MINOR__>301
  21 #pragma GCC system_header
  22 #endif
  23 #ifdef __clang__
  24 #pragma clang system_header
  25 #endif
  26 #ifdef _MSC_VER
  27 #pragma warning(push,1)
  28 #pragma warning(disable: 4265)
  29 #endif
  30 #endif
  31
  32 namespace
  33 boost
  34     {
  35     namespace
  36     exception_detail
  37         {
  38         template <class T>
  39         class
  40         refcount_ptr
  41             {
  42             public:
  43
  44             refcount_ptr():
  45                 px_(0)
  46                 {
  47                 }
  48
  49             ~refcount_ptr()
  50                 {
  51                 release();
  52                 }
  53
  54             refcount_ptr( refcount_ptr const & x ):
  55                 px_(x.px_)
  56                 {
  57                 add_ref();
  58                 }
  59
  60             refcount_ptr &
  61             operator=( refcount_ptr const & x )
  62                 {
  63                 adopt(x.px_);
  64                 return *this;
  65                 }
  66
  67             void
  68             adopt( T * px )
  69                 {
  70                 release();
  71                 px_=px;
  72                 add_ref();
  73                 }
  74
  75             T *
  76             get() const
  77                 {
  78                 return px_;
  79                 }
  80
  81             private:
  82
  83             T * px_;
  84
  85             void
  86             add_ref()
  87                 {
  88                 if( px_ )
  89                     px_->add_ref();
  90                 }
  91
  92             void
  93             release()
  94                 {
  95                 if( px_ && px_->release() )
  96                     px_=0;
  97                 }
  98             };
  99         }
 100
 101     ////////////////////////////////////////////////////////////////////////
 102
 103     template <class Tag,class T>
 104     class error_info;
 105
 106     typedef error_info<struct throw_function_,char const *> throw_function;
 107     typedef error_info<struct throw_file_,char const *> throw_file;
 108     typedef error_info<struct throw_line_,int> throw_line;
 109
 110     template <>
 111     class
 112     error_info<throw_function_,char const *>
 113         {
 114         public:
 115         typedef char const * value_type;
 116         value_type v_;
 117         explicit
 118         error_info( value_type v ):
 119             v_(v)
 120             {
 121             }
 122         };
 123
 124     template <>
 125     class
 126     error_info<throw_file_,char const *>
 127         {
 128         public:
 129         typedef char const * value_type;
 130         value_type v_;
 131         explicit
 132         error_info( value_type v ):
 133             v_(v)
 134             {
 135             }
 136         };
 137
 138     template <>
 139     class
 140     error_info<throw_line_,int>
 141         {
 142         public:
 143         typedef int value_type;
 144         value_type v_;
 145         explicit
 146         error_info( value_type v ):
 147             v_(v)
 148             {
 149             }
 150         };
 151
 152     class
 153     BOOST_SYMBOL_VISIBLE
 154     exception;
 155
 156     namespace
 157     exception_detail
 158         {
 159         class error_info_base;
 160         struct type_info_;
 161
 162         struct
 163         error_info_container
 164             {
 165             virtual char const * diagnostic_information( char const * ) const = 0;
 166             virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
 167             virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
 168             virtual void add_ref() const = 0;
 169             virtual bool release() const = 0;
 170             virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
 171
 172             protected:
 173
 174             ~error_info_container() BOOST_NOEXCEPT_OR_NOTHROW
 175                 {
 176                 }
 177             };
 178
 179         template <class>
 180         struct get_info;
 181
 182         template <>
 183         struct get_info<throw_function>;
 184
 185         template <>
 186         struct get_info<throw_file>;
 187
 188         template <>
 189         struct get_info<throw_line>;
 190
 191         template <class>
 192         struct set_info_rv;
 193
 194         template <>
 195         struct set_info_rv<throw_function>;
 196
 197         template <>
 198         struct set_info_rv<throw_file>;
 199
 200         template <>
 201         struct set_info_rv<throw_line>;
 202
 203         char const * get_diagnostic_information( exception const &, char const * );
 204
 205         void copy_boost_exception( exception *, exception const * );
 206
 207         template <class E,class Tag,class T>
 208         E const & set_info( E const &, error_info<Tag,T> const & );
 209
 210         template <class E>
 211         E const & set_info( E const &, throw_function const & );
 212
 213         template <class E>
 214         E const & set_info( E const &, throw_file const & );
 215
 216         template <class E>
 217         E const & set_info( E const &, throw_line const & );
 218         }
 219
 220     class
 221     BOOST_SYMBOL_VISIBLE
 222     exception
 223         {
 224         //<N3757>
 225         public:
 226         template <class Tag> void set( typename Tag::type const & );
 227         template <class Tag> typename Tag::type const * get() const;
 228         //</N3757>
 229
 230         protected:
 231
 232         exception():
 233             throw_function_(0),
 234             throw_file_(0),
 235             throw_line_(-1)
 236             {
 237             }
 238
 239 #ifdef __HP_aCC
 240         //On HP aCC, this protected copy constructor prevents throwing boost::exception.
 241         //On all other platforms, the same effect is achieved by the pure virtual destructor.
 242         exception( exception const & x ) BOOST_NOEXCEPT_OR_NOTHROW:
 243             data_(x.data_),
 244             throw_function_(x.throw_function_),
 245             throw_file_(x.throw_file_),
 246             throw_line_(x.throw_line_)
 247             {
 248             }
 249 #endif
 250
 251         virtual ~exception() BOOST_NOEXCEPT_OR_NOTHROW
 252 #ifndef __HP_aCC
 253             = 0 //Workaround for HP aCC, =0 incorrectly leads to link errors.
 254 #endif
 255             ;
 256
 257 #if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310)
 258         public:
 259 #else
 260         private:
 261
 262         template <class E>
 263         friend E const & exception_detail::set_info( E const &, throw_function const & );
 264
 265         template <class E>
 266         friend E const & exception_detail::set_info( E const &, throw_file const & );
 267
 268         template <class E>
 269         friend E const & exception_detail::set_info( E const &, throw_line const & );
 270
 271         template <class E,class Tag,class T>
 272         friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
 273
 274         friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
 275
 276         template <class>
 277         friend struct exception_detail::get_info;
 278         friend struct exception_detail::get_info<throw_function>;
 279         friend struct exception_detail::get_info<throw_file>;
 280         friend struct exception_detail::get_info<throw_line>;
 281         template <class>
 282         friend struct exception_detail::set_info_rv;
 283         friend struct exception_detail::set_info_rv<throw_function>;
 284         friend struct exception_detail::set_info_rv<throw_file>;
 285         friend struct exception_detail::set_info_rv<throw_line>;
 286         friend void exception_detail::copy_boost_exception( exception *, exception const * );
 287 #endif
 288         mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
 289         mutable char const * throw_function_;
 290         mutable char const * throw_file_;
 291         mutable int throw_line_;
 292         };
 293
 294     inline
 295     exception::
 296     ~exception() BOOST_NOEXCEPT_OR_NOTHROW
 297         {
 298         }
 299
 300     namespace
 301     exception_detail
 302         {
 303         template <class E>
 304         E const &
 305         set_info( E const & x, throw_function const & y )
 306             {
 307             x.throw_function_=y.v_;
 308             return x;
 309             }
 310
 311         template <class E>
 312         E const &
 313         set_info( E const & x, throw_file const & y )
 314             {
 315             x.throw_file_=y.v_;
 316             return x;
 317             }
 318
 319         template <class E>
 320         E const &
 321         set_info( E const & x, throw_line const & y )
 322             {
 323             x.throw_line_=y.v_;
 324             return x;
 325             }
 326         }
 327
 328     ////////////////////////////////////////////////////////////////////////
 329
 330     namespace
 331     exception_detail
 332         {
 333         template <class T>
 334         struct
 335         BOOST_SYMBOL_VISIBLE
 336         error_info_injector:
 337             public T,
 338             public exception
 339             {
 340             explicit
 341             error_info_injector( T const & x ):
 342                 T(x)
 343                 {
 344                 }
 345
 346             ~error_info_injector() BOOST_NOEXCEPT_OR_NOTHROW
 347                 {
 348                 }
 349             };
 350
 351         struct large_size { char c[256]; };
 352         large_size dispatch_boost_exception( exception const * );
 353
 354         struct small_size { };
 355         small_size dispatch_boost_exception( void const * );
 356
 357         template <class,int>
 358         struct enable_error_info_helper;
 359
 360         template <class T>
 361         struct
 362         enable_error_info_helper<T,sizeof(large_size)>
 363             {
 364             typedef T type;
 365             };
 366
 367         template <class T>
 368         struct
 369         enable_error_info_helper<T,sizeof(small_size)>
 370             {
 371             typedef error_info_injector<T> type;
 372             };
 373
 374         template <class T>
 375         struct
 376         enable_error_info_return_type
 377             {
 378             typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
 379             };
 380         }
 381
 382     template <class T>
 383     inline
 384     typename
 385     exception_detail::enable_error_info_return_type<T>::type
 386     enable_error_info( T const & x )
 387         {
 388         typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
 389         return rt(x);
 390         }
 391
 392     ////////////////////////////////////////////////////////////////////////
 393
 394     namespace
 395     exception_detail
 396         {
 397         class
 398         BOOST_SYMBOL_VISIBLE
 399         clone_base
 400             {
 401             public:
 402
 403             virtual clone_base const * clone() const = 0;
 404             virtual void rethrow() const = 0;
 405
 406             virtual
 407             ~clone_base() BOOST_NOEXCEPT_OR_NOTHROW
 408                 {
 409                 }
 410             };
 411
 412         inline
 413         void
 414         copy_boost_exception( exception * a, exception const * b )
 415             {
 416             refcount_ptr<error_info_container> data;
 417             if( error_info_container * d=b->data_.get() )
 418                 data = d->clone();
 419             a->throw_file_ = b->throw_file_;
 420             a->throw_line_ = b->throw_line_;
 421             a->throw_function_ = b->throw_function_;
 422             a->data_ = data;
 423             }
 424
 425         inline
 426         void
 427         copy_boost_exception( void *, void const * )
 428             {
 429             }
 430
 431         template <class T>
 432         class
 433         BOOST_SYMBOL_VISIBLE
 434         clone_impl:
 435             public T,
 436             public virtual clone_base
 437             {
 438             struct clone_tag { };
 439             clone_impl( clone_impl const & x, clone_tag ):
 440                 T(x)
 441                 {
 442                 copy_boost_exception(this,&x);
 443                 }
 444
 445             public:
 446
 447             explicit
 448             clone_impl( T const & x ):
 449                 T(x)
 450                 {
 451                 copy_boost_exception(this,&x);
 452                 }
 453
 454             ~clone_impl() BOOST_NOEXCEPT_OR_NOTHROW
 455                 {
 456                 }
 457
 458             private:
 459
 460             clone_base const *
 461             clone() const
 462                 {
 463                 return new clone_impl(*this,clone_tag());
 464                 }
 465
 466             void
 467             rethrow() const
 468                 {
 469                 throw*this;
 470                 }
 471             };
 472         }
 473
 474     template <class T>
 475     inline
 476     exception_detail::clone_impl<T>
 477     enable_current_exception( T const & x )
 478         {
 479         return exception_detail::clone_impl<T>(x);
 480         }
 481     }
 482
 483 #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 484 #pragma warning(pop)
 485 #endif
 486
 487 #endif // #ifndef BOOST_EXCEPTION_274DA366004E11DCB1DDFE2E56D89593