stc/exp/ml_stc_linux_make_v1.0/include/boost/exception/exception.hpp

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