BVB Source Codes

mars Show pull_coroutine_impl.hpp Source code

Return Download mars: download pull_coroutine_impl.hpp Source code - Download mars Source code - Type:.hpp
  1.  
  2. //          Copyright Oliver Kowalke 2009.
  3. // Distributed under the Boost Software License, Version 1.0.
  4. //    (See accompanying file LICENSE_1_0.txt or copy at
  5. //          http://www.boost.org/LICENSE_1_0.txt)
  6.  
  7. #ifndef BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
  8. #define BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
  9.  
  10. #include <boost/assert.hpp>
  11. #include <boost/config.hpp>
  12. #include <boost/exception_ptr.hpp>
  13. #include <boost/throw_exception.hpp>
  14. #include <boost/utility.hpp>
  15.  
  16. #include <boost/coroutine/detail/config.hpp>
  17. #include <boost/coroutine/detail/coroutine_context.hpp>
  18. #include <boost/coroutine/detail/flags.hpp>
  19. #include <boost/coroutine/detail/parameters.hpp>
  20. #include <boost/coroutine/detail/trampoline_pull.hpp>
  21. #include <boost/coroutine/exceptions.hpp>
  22.  
  23. #ifdef BOOST_HAS_ABI_HEADERS
  24. #  include BOOST_ABI_PREFIX
  25. #endif
  26.  
  27. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  28. namespace coroutines {
  29.  
  30. struct stack_context;
  31.  
  32. namespace detail {
  33.  
  34. template< typename R >
  35. class pull_coroutine_impl : private noncopyable
  36. {
  37. protected:
  38.     int                     flags_;
  39.     exception_ptr           except_;
  40.     coroutine_context   *   caller_;
  41.     coroutine_context   *   callee_;
  42.     R                   *   result_;
  43.  
  44. public:
  45.     typedef parameters< R >                           param_type;
  46.  
  47.     pull_coroutine_impl( coroutine_context * caller,
  48.                          coroutine_context * callee,
  49.                          bool unwind) :
  50.         flags_( 0),
  51.         except_(),
  52.         caller_( caller),
  53.         callee_( callee),
  54.         result_( 0)
  55.     {
  56.         if ( unwind) flags_ |= flag_force_unwind;
  57.     }
  58.  
  59.     pull_coroutine_impl( coroutine_context * caller,
  60.                          coroutine_context * callee,
  61.                          bool unwind,
  62.                          R * result) :
  63.         flags_( 0),
  64.         except_(),
  65.         caller_( caller),
  66.         callee_( callee),
  67.         result_( result)
  68.     {
  69.         if ( unwind) flags_ |= flag_force_unwind;
  70.     }
  71.  
  72.     virtual ~pull_coroutine_impl() {}
  73.  
  74.     bool force_unwind() const BOOST_NOEXCEPT
  75.     { return 0 != ( flags_ & flag_force_unwind); }
  76.  
  77.     bool unwind_requested() const BOOST_NOEXCEPT
  78.     { return 0 != ( flags_ & flag_unwind_stack); }
  79.  
  80.     bool is_started() const BOOST_NOEXCEPT
  81.     { return 0 != ( flags_ & flag_started); }
  82.  
  83.     bool is_running() const BOOST_NOEXCEPT
  84.     { return 0 != ( flags_ & flag_running); }
  85.  
  86.     bool is_complete() const BOOST_NOEXCEPT
  87.     { return 0 != ( flags_ & flag_complete); }
  88.  
  89.     void unwind_stack() BOOST_NOEXCEPT
  90.     {
  91.         if ( is_started() && ! is_complete() && force_unwind() )
  92.         {
  93.             flags_ |= flag_unwind_stack;
  94.             param_type to( unwind_t::force_unwind);
  95.             caller_->jump(
  96.                 * callee_,
  97.                 & to);
  98.             flags_ &= ~flag_unwind_stack;
  99.  
  100.             BOOST_ASSERT( is_complete() );
  101.         }
  102.     }
  103.  
  104.     void pull()
  105.     {
  106.         BOOST_ASSERT( ! is_running() );
  107.         BOOST_ASSERT( ! is_complete() );
  108.  
  109.         flags_ |= flag_running;
  110.         param_type to( this);
  111.         param_type * from(
  112.             static_cast< param_type * >(
  113.                 caller_->jump(
  114.                     * callee_,
  115.                     & to) ) );
  116.         flags_ &= ~flag_running;
  117.         result_ = from->data;
  118.         if ( from->do_unwind) mars_boost::throw_exception(forced_unwind()); //forced_unwind();
  119.         if ( except_) rethrow_exception( except_);
  120.     }
  121.  
  122.     bool has_result() const
  123.     { return 0 != result_; }
  124.  
  125.     R get() const
  126.     {
  127.         if ( ! has_result() )
  128.             mars_boost::throw_exception(
  129.                 invalid_result() );
  130.         return * result_;
  131.     }
  132.  
  133.     R * get_pointer() const
  134.     {
  135.         if ( ! has_result() )
  136.             mars_boost::throw_exception(
  137.                 invalid_result() );
  138.         return result_;
  139.     }
  140.  
  141.     virtual void destroy() = 0;
  142. };
  143.  
  144. template< typename R >
  145. class pull_coroutine_impl< R & > : private noncopyable
  146. {
  147. protected:
  148.     int                     flags_;
  149.     exception_ptr           except_;
  150.     coroutine_context   *   caller_;
  151.     coroutine_context   *   callee_;
  152.     R                   *   result_;
  153.  
  154. public:
  155.     typedef parameters< R & >                           param_type;
  156.  
  157.     pull_coroutine_impl( coroutine_context * caller,
  158.                          coroutine_context * callee,
  159.                          bool unwind) :
  160.         flags_( 0),
  161.         except_(),
  162.         caller_( caller),
  163.         callee_( callee),
  164.         result_( 0)
  165.     {
  166.         if ( unwind) flags_ |= flag_force_unwind;
  167.     }
  168.  
  169.     pull_coroutine_impl( coroutine_context * caller,
  170.                          coroutine_context * callee,
  171.                          bool unwind,
  172.                          R * result) :
  173.         flags_( 0),
  174.         except_(),
  175.         caller_( caller),
  176.         callee_( callee),
  177.         result_( result)
  178.     {
  179.         if ( unwind) flags_ |= flag_force_unwind;
  180.     }
  181.  
  182.     virtual ~pull_coroutine_impl() {}
  183.  
  184.     bool force_unwind() const BOOST_NOEXCEPT
  185.     { return 0 != ( flags_ & flag_force_unwind); }
  186.  
  187.     bool unwind_requested() const BOOST_NOEXCEPT
  188.     { return 0 != ( flags_ & flag_unwind_stack); }
  189.  
  190.     bool is_started() const BOOST_NOEXCEPT
  191.     { return 0 != ( flags_ & flag_started); }
  192.  
  193.     bool is_running() const BOOST_NOEXCEPT
  194.     { return 0 != ( flags_ & flag_running); }
  195.  
  196.     bool is_complete() const BOOST_NOEXCEPT
  197.     { return 0 != ( flags_ & flag_complete); }
  198.  
  199.     void unwind_stack() BOOST_NOEXCEPT
  200.     {
  201.         if ( is_started() && ! is_complete() && force_unwind() )
  202.         {
  203.             flags_ |= flag_unwind_stack;
  204.             param_type to( unwind_t::force_unwind);
  205.             caller_->jump(
  206.                 * callee_,
  207.                 & to);
  208.             flags_ &= ~flag_unwind_stack;
  209.  
  210.             BOOST_ASSERT( is_complete() );
  211.         }
  212.     }
  213.  
  214.     void pull()
  215.     {
  216.         BOOST_ASSERT( ! is_running() );
  217.         BOOST_ASSERT( ! is_complete() );
  218.  
  219.         flags_ |= flag_running;
  220.         param_type to( this);
  221.         param_type * from(
  222.             static_cast< param_type * >(
  223.                 caller_->jump(
  224.                     * callee_,
  225.                     & to) ) );
  226.         flags_ &= ~flag_running;
  227.         result_ = from->data;
  228.         if ( from->do_unwind) mars_boost::throw_exception(forced_unwind());
  229.         if ( except_) rethrow_exception( except_);
  230.     }
  231.  
  232.     bool has_result() const
  233.     { return 0 != result_; }
  234.  
  235.     R & get() const
  236.     {
  237.         if ( ! has_result() )
  238.             mars_boost::throw_exception(
  239.                 invalid_result() );
  240.         return * result_;
  241.     }
  242.  
  243.     R * get_pointer() const
  244.     {
  245.         if ( ! has_result() )
  246.             mars_boost::throw_exception(
  247.                 invalid_result() );
  248.         return result_;
  249.     }
  250.  
  251.     virtual void destroy() = 0;
  252. };
  253.  
  254. template<>
  255. class pull_coroutine_impl< void > : private noncopyable
  256. {
  257. protected:
  258.     int                     flags_;
  259.     exception_ptr           except_;
  260.     coroutine_context   *   caller_;
  261.     coroutine_context   *   callee_;
  262.  
  263. public:
  264.     typedef parameters< void >      param_type;
  265.  
  266.     pull_coroutine_impl( coroutine_context * caller,
  267.                          coroutine_context * callee,
  268.                          bool unwind) :
  269.         flags_( 0),
  270.         except_(),
  271.         caller_( caller),
  272.         callee_( callee)
  273.     {
  274.         if ( unwind) flags_ |= flag_force_unwind;
  275.     }
  276.  
  277.     virtual ~pull_coroutine_impl() {}
  278.  
  279.     inline bool force_unwind() const BOOST_NOEXCEPT
  280.     { return 0 != ( flags_ & flag_force_unwind); }
  281.  
  282.     inline bool unwind_requested() const BOOST_NOEXCEPT
  283.     { return 0 != ( flags_ & flag_unwind_stack); }
  284.  
  285.     inline bool is_started() const BOOST_NOEXCEPT
  286.     { return 0 != ( flags_ & flag_started); }
  287.  
  288.     inline bool is_running() const BOOST_NOEXCEPT
  289.     { return 0 != ( flags_ & flag_running); }
  290.  
  291.     inline bool is_complete() const BOOST_NOEXCEPT
  292.     { return 0 != ( flags_ & flag_complete); }
  293.  
  294.     inline void unwind_stack() BOOST_NOEXCEPT
  295.     {
  296.         if ( is_started() && ! is_complete() && force_unwind() )
  297.         {
  298.             flags_ |= flag_unwind_stack;
  299.             param_type to( unwind_t::force_unwind);
  300.             caller_->jump(
  301.                 * callee_,
  302.                 & to);
  303.             flags_ &= ~flag_unwind_stack;
  304.  
  305.             BOOST_ASSERT( is_complete() );
  306.         }
  307.     }
  308.  
  309.     inline void pull()
  310.     {
  311.         BOOST_ASSERT( ! is_running() );
  312.         BOOST_ASSERT( ! is_complete() );
  313.  
  314.         flags_ |= flag_running;
  315.         param_type to( this);
  316.         param_type * from(
  317.             static_cast< param_type * >(
  318.                 caller_->jump(
  319.                     * callee_,
  320.                     & to) ) );
  321.         flags_ &= ~flag_running;
  322.         if ( from->do_unwind) mars_boost::throw_exception(forced_unwind());
  323.         if ( except_) rethrow_exception( except_);
  324.     }
  325.  
  326.     virtual void destroy() = 0;
  327. };
  328.  
  329. }}}
  330.  
  331. #ifdef BOOST_HAS_ABI_HEADERS
  332. #  include BOOST_ABI_SUFFIX
  333. #endif
  334.  
  335. #endif // BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
  336.  
downloadpull_coroutine_impl.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