BVB Source Codes

mars Show exception_ptr.hpp Source code

Return Download mars: download exception_ptr.hpp Source code - Download mars Source code - Type:.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_618474C2DE1511DEB74A388C56D89593
  7. #define UUID_618474C2DE1511DEB74A388C56D89593
  8. #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
  9. #pragma GCC system_header
  10. #endif
  11. #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
  12. #pragma warning(push,1)
  13. #endif
  14.  
  15. #include <boost/config.hpp>
  16. //#ifdef BOOST_NO_EXCEPTIONS
  17. //#error This header requires exception handling to be enabled.
  18. //#endif
  19. #include <boost/exception/exception.hpp>
  20. #include <boost/exception/info.hpp>
  21. #include <boost/exception/diagnostic_information.hpp>
  22. #include <boost/exception/detail/type_info.hpp>
  23. //#include <boost/exception/detail/clone_current_exception.hpp>
  24. #ifndef BOOST_NO_RTTI
  25. #include <boost/core/demangle.hpp>
  26. #endif
  27. #include <boost/shared_ptr.hpp>
  28. #include <stdexcept>
  29. #include <new>
  30. #include <ios>
  31. #include <stdlib.h>
  32.  
  33. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost
  34.     {
  35.         class exception_ptr {
  36.         public:
  37.             explicit operator bool() const noexcept {return false;}
  38.         };
  39.  
  40.         BOOST_NORETURN
  41.         inline
  42.         void
  43.         rethrow_exception( exception_ptr const & p )
  44.             {
  45.             BOOST_ASSERT(p);
  46.             //p.ptr_->rethrow();
  47.             BOOST_ASSERT(0);
  48.             #if defined(UNDER_CE)
  49.                 // some CE platforms don't define ::abort()
  50.                 exit(-1);
  51.             #else
  52.                 abort();
  53.             #endif
  54.             }
  55.         inline
  56.         exception_ptr
  57.         current_exception()
  58.             {
  59.             exception_ptr ret;
  60.             /*try
  61.                 {
  62.                 ret=exception_detail::current_exception_impl();
  63.                 }
  64.             catch(
  65.             std::bad_alloc & )
  66.                 {
  67.                 ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_alloc_>::e;
  68.                 }
  69.             catch(
  70.             ... )
  71.                 {
  72.                 ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_exception_>::e;
  73.                 }
  74.             BOOST_ASSERT(ret);*/
  75.             return ret;
  76.             }
  77.     /*
  78.     }
  79.     class exception_ptr;
  80.     BOOST_NORETURN void rethrow_exception( exception_ptr const & );
  81.     exception_ptr current_exception();
  82.  
  83.     class
  84.     exception_ptr
  85.         {
  86.         typedef mars_boost::shared_ptr<exception_detail::clone_base const> impl;
  87.         impl ptr_;
  88.         friend void rethrow_exception( exception_ptr const & );
  89.         typedef exception_detail::clone_base const * (impl::*unspecified_bool_type)() const;
  90.         public:
  91.         exception_ptr()
  92.             {
  93.             }
  94.         explicit
  95.         exception_ptr( impl const & ptr ):
  96.             ptr_(ptr)
  97.             {
  98.             }
  99.         bool
  100.         operator==( exception_ptr const & other ) const
  101.             {
  102.             return ptr_==other.ptr_;
  103.             }
  104.         bool
  105.         operator!=( exception_ptr const & other ) const
  106.             {
  107.             return ptr_!=other.ptr_;
  108.             }
  109.         operator unspecified_bool_type() const
  110.             {
  111.             return ptr_?&impl::get:0;
  112.             }
  113.         };
  114.  
  115.     template <class T>
  116.     inline
  117.     exception_ptr
  118.     copy_exception( T const & e )
  119.         {
  120.         try
  121.             {
  122.             throw enable_current_exception(e);
  123.             }
  124.         catch(
  125.         ... )
  126.             {
  127.             return current_exception();
  128.             }
  129.         }
  130.  
  131. #ifndef BOOST_NO_RTTI
  132.     typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;
  133.  
  134.     inline
  135.     std::string
  136.     to_string( original_exception_type const & x )
  137.         {
  138.         return core::demangle(x.value()->name());
  139.         }
  140. #endif
  141.  
  142.     namespace
  143.     exception_detail
  144.         {
  145.         struct
  146.         bad_alloc_:
  147.             mars_boost::exception,
  148.             std::bad_alloc
  149.                 {
  150.                 ~bad_alloc_() throw() { }
  151.                 };
  152.  
  153.         struct
  154.         bad_exception_:
  155.             mars_boost::exception,
  156.             std::bad_exception
  157.                 {
  158.                 ~bad_exception_() throw() { }
  159.                 };
  160.  
  161.         template <class Exception>
  162.         exception_ptr
  163.         get_static_exception_object()
  164.             {
  165.             Exception ba;
  166.             exception_detail::clone_impl<Exception> c(ba);
  167. #ifndef BOOST_EXCEPTION_DISABLE
  168.             c <<
  169.                 throw_function(BOOST_CURRENT_FUNCTION) <<
  170.                 throw_file(__FILE__) <<
  171.                 throw_line(__LINE__);
  172. #endif
  173.             static exception_ptr ep(shared_ptr<exception_detail::clone_base const>(new exception_detail::clone_impl<Exception>(c)));
  174.             return ep;
  175.             }
  176.  
  177.         template <class Exception>
  178.         struct
  179.         exception_ptr_static_exception_object
  180.             {
  181.             static exception_ptr const e;
  182.             };
  183.  
  184.         template <class Exception>
  185.         exception_ptr const
  186.         exception_ptr_static_exception_object<Exception>::
  187.         e = get_static_exception_object<Exception>();
  188.         }
  189.  
  190. #if defined(__GNUC__)
  191. # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
  192. #  pragma GCC visibility push (default)
  193. # endif
  194. #endif
  195.     class
  196.     unknown_exception:
  197.         public mars_boost::exception,
  198.         public std::exception
  199.         {
  200.         public:
  201.  
  202.         unknown_exception()
  203.             {
  204.             }
  205.  
  206.         explicit
  207.         unknown_exception( std::exception const & e )
  208.             {
  209.             add_original_type(e);
  210.             }
  211.  
  212.         explicit
  213.         unknown_exception( mars_boost::exception const & e ):
  214.             mars_boost::exception(e)
  215.             {
  216.             add_original_type(e);
  217.             }
  218.  
  219.         ~unknown_exception() throw()
  220.             {
  221.             }
  222.  
  223.         private:
  224.  
  225.         template <class E>
  226.         void
  227.         add_original_type( E const & e )
  228.             {
  229. #ifndef BOOST_NO_RTTI
  230.             (*this) << original_exception_type(&typeid(e));
  231. #endif
  232.             }
  233.         };
  234. #if defined(__GNUC__)
  235. # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
  236. #  pragma GCC visibility pop
  237. # endif
  238. #endif
  239.  
  240.     namespace
  241.     exception_detail
  242.         {
  243.         template <class T>
  244.         class
  245.         current_exception_std_exception_wrapper:
  246.             public T,
  247.             public mars_boost::exception
  248.             {
  249.             public:
  250.  
  251.             explicit
  252.             current_exception_std_exception_wrapper( T const & e1 ):
  253.                 T(e1)
  254.                 {
  255.                 add_original_type(e1);
  256.                 }
  257.  
  258.             current_exception_std_exception_wrapper( T const & e1, mars_boost::exception const & e2 ):
  259.                 T(e1),
  260.                 mars_boost::exception(e2)
  261.                 {
  262.                 add_original_type(e1);
  263.                 }
  264.  
  265.             ~current_exception_std_exception_wrapper() throw()
  266.                 {
  267.                 }
  268.  
  269.             private:
  270.  
  271.             template <class E>
  272.             void
  273.             add_original_type( E const & e )
  274.                 {
  275. #ifndef BOOST_NO_RTTI
  276.                 (*this) << original_exception_type(&typeid(e));
  277. #endif
  278.                 }
  279.             };
  280.  
  281. #ifdef BOOST_NO_RTTI
  282.         template <class T>
  283.         mars_boost::exception const *
  284.         get_boost_exception( T const * )
  285.             {
  286.             try
  287.                 {
  288.                 throw;
  289.                 }
  290.             catch(
  291.             mars_boost::exception & x )
  292.                 {
  293.                 return &x;
  294.                 }
  295.             catch(...)
  296.                 {
  297.                 return 0;
  298.                 }
  299.             }
  300. #else
  301.         template <class T>
  302.         mars_boost::exception const *
  303.         get_boost_exception( T const * x )
  304.             {
  305.             return dynamic_cast<mars_boost::exception const *>(x);
  306.             }
  307. #endif
  308.  
  309.         template <class T>
  310.         inline
  311.         exception_ptr
  312.         current_exception_std_exception( T const & e1 )
  313.             {
  314.             if( mars_boost::exception const * e2 = get_boost_exception(&e1) )
  315.                 return mars_boost::copy_exception(current_exception_std_exception_wrapper<T>(e1,*e2));
  316.             else
  317.                 return mars_boost::copy_exception(current_exception_std_exception_wrapper<T>(e1));
  318.             }
  319.  
  320.         inline
  321.         exception_ptr
  322.         current_exception_unknown_exception()
  323.             {
  324.             return mars_boost::copy_exception(unknown_exception());
  325.             }
  326.  
  327.         inline
  328.         exception_ptr
  329.         current_exception_unknown_boost_exception( mars_boost::exception const & e )
  330.             {
  331.             return mars_boost::copy_exception(unknown_exception(e));
  332.             }
  333.  
  334.         inline
  335.         exception_ptr
  336.         current_exception_unknown_std_exception( std::exception const & e )
  337.             {
  338.             if( mars_boost::exception const * be = get_boost_exception(&e) )
  339.                 return current_exception_unknown_boost_exception(*be);
  340.             else
  341.                 return mars_boost::copy_exception(unknown_exception(e));
  342.             }
  343.  
  344.         inline
  345.         exception_ptr
  346.         current_exception_impl()
  347.             {
  348.             exception_detail::clone_base const * e=0;
  349.             switch(
  350.             exception_detail::clone_current_exception(e) )
  351.                 {
  352.                 case exception_detail::clone_current_exception_result::
  353.                 success:
  354.                     {
  355.                     BOOST_ASSERT(e!=0);
  356.                     return exception_ptr(shared_ptr<exception_detail::clone_base const>(e));
  357.                     }
  358.                 case exception_detail::clone_current_exception_result::
  359.                 bad_alloc:
  360.                     {
  361.                     BOOST_ASSERT(!e);
  362.                     return exception_detail::exception_ptr_static_exception_object<bad_alloc_>::e;
  363.                     }
  364.                 case exception_detail::clone_current_exception_result::
  365.                 bad_exception:
  366.                     {
  367.                     BOOST_ASSERT(!e);
  368.                     return exception_detail::exception_ptr_static_exception_object<bad_exception_>::e;
  369.                     }
  370.                 default:
  371.                     BOOST_ASSERT(0);
  372.                 case exception_detail::clone_current_exception_result::
  373.                 not_supported:
  374.                     {
  375.                     BOOST_ASSERT(!e);
  376.                     try
  377.                         {
  378.                         throw;
  379.                         }
  380.                     catch(
  381.                     exception_detail::clone_base & e )
  382.                         {
  383.                         return exception_ptr(shared_ptr<exception_detail::clone_base const>(e.clone()));
  384.                         }
  385.                     catch(
  386.                     std::domain_error & e )
  387.                         {
  388.                         return exception_detail::current_exception_std_exception(e);
  389.                         }
  390.                     catch(
  391.                     std::invalid_argument & e )
  392.                         {
  393.                         return exception_detail::current_exception_std_exception(e);
  394.                         }
  395.                     catch(
  396.                     std::length_error & e )
  397.                         {
  398.                         return exception_detail::current_exception_std_exception(e);
  399.                         }
  400.                     catch(
  401.                     std::out_of_range & e )
  402.                         {
  403.                         return exception_detail::current_exception_std_exception(e);
  404.                         }
  405.                     catch(
  406.                     std::logic_error & e )
  407.                         {
  408.                         return exception_detail::current_exception_std_exception(e);
  409.                         }
  410.                     catch(
  411.                     std::range_error & e )
  412.                         {
  413.                         return exception_detail::current_exception_std_exception(e);
  414.                         }
  415.                     catch(
  416.                     std::overflow_error & e )
  417.                         {
  418.                         return exception_detail::current_exception_std_exception(e);
  419.                         }
  420.                     catch(
  421.                     std::underflow_error & e )
  422.                         {
  423.                         return exception_detail::current_exception_std_exception(e);
  424.                         }
  425.                     catch(
  426.                     std::ios_base::failure & e )
  427.                         {
  428.                         return exception_detail::current_exception_std_exception(e);
  429.                         }
  430.                     catch(
  431.                     std::runtime_error & e )
  432.                         {
  433.                         return exception_detail::current_exception_std_exception(e);
  434.                         }
  435.                     catch(
  436.                     std::bad_alloc & e )
  437.                         {
  438.                         return exception_detail::current_exception_std_exception(e);
  439.                         }
  440. #ifndef BOOST_NO_TYPEID
  441.                     catch(
  442.                     std::bad_cast & e )
  443.                         {
  444.                         return exception_detail::current_exception_std_exception(e);
  445.                         }
  446.                     catch(
  447.                     std::bad_typeid & e )
  448.                         {
  449.                         return exception_detail::current_exception_std_exception(e);
  450.                         }
  451. #endif
  452.                     catch(
  453.                     std::bad_exception & e )
  454.                         {
  455.                         return exception_detail::current_exception_std_exception(e);
  456.                         }
  457.                     catch(
  458.                     std::exception & e )
  459.                         {
  460.                         return exception_detail::current_exception_unknown_std_exception(e);
  461.                         }
  462.                     catch(
  463.                     mars_boost::exception & e )
  464.                         {
  465.                         return exception_detail::current_exception_unknown_boost_exception(e);
  466.                         }
  467.                     catch(
  468.                     ... )
  469.                         {
  470.                         return exception_detail::current_exception_unknown_exception();
  471.                         }
  472.                     }
  473.                 }
  474.             }
  475.         }
  476.  
  477.     inline
  478.     exception_ptr
  479.     current_exception()
  480.         {
  481.         exception_ptr ret;
  482.         try
  483.             {
  484.             ret=exception_detail::current_exception_impl();
  485.             }
  486.         catch(
  487.         std::bad_alloc & )
  488.             {
  489.             ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_alloc_>::e;
  490.             }
  491.         catch(
  492.         ... )
  493.             {
  494.             ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_exception_>::e;
  495.             }
  496.         BOOST_ASSERT(ret);
  497.         return ret;
  498.         }
  499.  
  500.     BOOST_NORETURN
  501.     inline
  502.     void
  503.     rethrow_exception( exception_ptr const & p )
  504.         {
  505.         BOOST_ASSERT(p);
  506.         p.ptr_->rethrow();
  507.         BOOST_ASSERT(0);
  508.         #if defined(UNDER_CE)
  509.             // some CE platforms don't define ::abort()
  510.             exit(-1);
  511.         #else
  512.             abort();
  513.         #endif
  514.         }
  515.  
  516.     inline
  517.     std::string
  518.     diagnostic_information( exception_ptr const & p, bool verbose=true )
  519.         {
  520.         if( p )
  521.             try
  522.                 {
  523.                 rethrow_exception(p);
  524.                 }
  525.             catch(
  526.             ... )
  527.                 {
  528.                 return current_exception_diagnostic_information(verbose);
  529.                 }
  530.         return "<empty>";
  531.         }
  532.  
  533.     inline
  534.     std::string
  535.     to_string( exception_ptr const & p )
  536.         {
  537.         std::string s='\n'+diagnostic_information(p);
  538.         std::string padding("  ");
  539.         std::string r;
  540.         bool f=false;
  541.         for( std::string::const_iterator i=s.begin(),e=s.end(); i!=e; ++i )
  542.             {
  543.             if( f )
  544.                 r+=padding;
  545.             char c=*i;
  546.             r+=c;
  547.             f=(c=='\n');
  548.             }
  549.         return r;
  550.         }*/
  551.     }
  552.  
  553. #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
  554. #pragma warning(pop)
  555. #endif
  556. #endif
  557.  
downloadexception_ptr.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top