?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/coroutine2.zip
???????
PK ϩ!\ M-E pooled_fixedsize_stack.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_POOLED_FIXEDSIZE_H #define BOOST_COROUTINES2_POOLED_FIXEDSIZE_H #include <exception> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/context/pooled_fixedsize_stack.hpp> #include <boost/coroutine2/detail/coroutine.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { using pooled_fixedsize_stack = boost::context::pooled_fixedsize_stack; }} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_POOLED_FIXEDSIZE_H PK ϩ!\��SU U coroutine.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_COROUTINE_H #define BOOST_COROUTINES2_COROUTINE_H #include <exception> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/coroutine2/detail/coroutine.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { template< typename T > struct coroutine { using pull_type = detail::pull_coroutine< T >; using push_type = detail::push_coroutine< T >; }; template< typename T > using asymmetric_coroutine = coroutine< T >; }} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_COROUTINE_H PK ϩ!\«6�4 4 all.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_ALL_H #define BOOST_COROUTINES2_ALL_H #include <boost/coroutine2/coroutine.hpp> #include <boost/coroutine2/fixedsize_stack.hpp> #include <boost/coroutine2/pooled_fixedsize_stack.hpp> #include <boost/coroutine2/protected_fixedsize_stack.hpp> #include <boost/coroutine2/segmented_stack.hpp> #endif // BOOST_COROUTINES2_ALL_H PK ϩ!\R]�1� � detail/state.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_ASYMMETRIC_COROUTINE_HPP #define BOOST_COROUTINES2_DETAIL_ASYMMETRIC_COROUTINE_HPP #include <exception> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/coroutine2/detail/config.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { enum class state_t : unsigned int { none = 0, complete = 1 << 1, unwind = 1 << 2, destroy = 1 << 3 }; inline constexpr state_t operator&( state_t l, state_t r) { return static_cast< state_t >( static_cast< unsigned int >( l) & static_cast< unsigned int >( r) ); } inline constexpr state_t operator|( state_t l, state_t r) { return static_cast< state_t >( static_cast< unsigned int >( l) | static_cast< unsigned int >( r) ); } inline constexpr state_t operator^( state_t l, state_t r) { return static_cast< state_t >( static_cast< unsigned int >( l) ^ static_cast< unsigned int >( r) ); } inline constexpr state_t operator~( state_t l) { return static_cast< state_t >( ~static_cast< unsigned int >( l) ); } inline state_t & operator&=( state_t & l, state_t r) { l = l & r; return l; } inline state_t & operator|=( state_t & l, state_t r) { l = l | r; return l; } inline state_t & operator^=( state_t & l, state_t r) { l = l ^ r; return l; } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_ASYMMETRIC_COROUTINE_HPP PK ϩ!\���� � detail/coroutine.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_COROUTINE_HPP #define BOOST_COROUTINES2_DETAIL_COROUTINE_HPP #include <boost/config.hpp> #include <boost/context/detail/config.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename T > class pull_coroutine; template< typename T > class push_coroutine; }}} #include <boost/coroutine2/detail/pull_coroutine.hpp> #include <boost/coroutine2/detail/push_coroutine.hpp> #include <boost/coroutine2/detail/pull_control_block_cc.hpp> #include <boost/coroutine2/detail/push_control_block_cc.hpp> #include <boost/coroutine2/detail/pull_coroutine.ipp> #include <boost/coroutine2/detail/push_coroutine.ipp> #include <boost/coroutine2/detail/pull_control_block_cc.ipp> #include <boost/coroutine2/detail/push_control_block_cc.ipp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_COROUTINE_HPP PK ϩ!\j��� detail/create_control_block.ippnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_CREATE_CONTROLBLOCK_IPP #define BOOST_COROUTINES2_DETAIL_CREATE_CONTROLBLOCK_IPP #include <cstddef> #include <memory> #include <utility> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/context/preallocated.hpp> #include <boost/context/stack_context.hpp> #include <boost/coroutine2/detail/config.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename ControlBlock, typename StackAllocator, typename Fn > ControlBlock * create_control_block( StackAllocator && salloc, Fn && fn) { auto sctx = salloc.allocate(); // reserve space for control structure #if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_STD_ALIGN) void * sp = static_cast< char * >( sctx.sp) - sizeof( ControlBlock); const std::size_t size = sctx.size - sizeof( ControlBlock); #else constexpr std::size_t func_alignment = 64; // alignof( ControlBlock); constexpr std::size_t func_size = sizeof( ControlBlock); // reserve space on stack void * sp = static_cast< char * >( sctx.sp) - func_size - func_alignment; // align sp pointer std::size_t space = func_size + func_alignment; sp = std::align( func_alignment, func_size, sp, space); BOOST_ASSERT( nullptr != sp); // calculate remaining size const std::size_t size = sctx.size - ( static_cast< char * >( sctx.sp) - static_cast< char * >( sp) ); #endif // placment new for control structure on coroutine stack return new ( sp) ControlBlock{ context::preallocated( sp, size, sctx), std::forward< StackAllocator >( salloc), std::forward< Fn >( fn) }; } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_CREATE_CONTROLBLOCK_IPP PK ϩ!\}� [v v detail/config.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_CONFIG_H #define BOOST_COROUTINES2_DETAIL_CONFIG_H #include <boost/config.hpp> #include <boost/context/detail/config.hpp> #include <boost/detail/workaround.hpp> #ifdef BOOST_COROUTINES2_DECL # undef BOOST_COROUTINES2_DECL #endif #if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_COROUTINES2_DYN_LINK) ) && ! defined(BOOST_COROUTINES2_STATIC_LINK) # if defined(BOOST_COROUTINES2_SOURCE) # define BOOST_COROUTINES2_DECL BOOST_SYMBOL_EXPORT # else # define BOOST_COROUTINES2_DECL BOOST_SYMBOL_IMPORT # endif #endif #if ! defined(BOOST_COROUTINES2_DECL) # define BOOST_COROUTINES2_DECL #endif #endif // BOOST_COROUTINES2_DETAIL_CONFIG_H PK ϩ!\�\�X X detail/wrap.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINE2_DETAIL_WRAP_H #define BOOST_COROUTINE2_DETAIL_WRAP_H #include <type_traits> #include <boost/config.hpp> #include <boost/context/detail/invoke.hpp> #include <boost/context/fiber.hpp> #include <boost/coroutine2/detail/config.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename Fn1, typename Fn2 > class wrapper { private: typename std::decay< Fn1 >::type fn1_; typename std::decay< Fn2 >::type fn2_; public: wrapper( Fn1 && fn1, Fn2 && fn2) : fn1_( std::move( fn1) ), fn2_( std::move( fn2) ) { } wrapper( wrapper const&) = delete; wrapper & operator=( wrapper const&) = delete; wrapper( wrapper && other) = default; wrapper & operator=( wrapper && other) = default; boost::context::fiber operator()( boost::context::fiber && c) { return boost::context::detail::invoke( std::move( fn1_), fn2_, std::forward< boost::context::fiber >( c) ); } }; template< typename Fn1, typename Fn2 > wrapper< Fn1, Fn2 > wrap( Fn1 && fn1, Fn2 && fn2) { return wrapper< Fn1, Fn2 >( std::forward< Fn1 >( fn1), std::forward< Fn2 >( fn2) ); } }}} #ifdef BOOST_HAS_ABI_HEADERS #include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINE2_DETAIL_WRAP_H PK ϩ!\I��u� � detail/decay_copy.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_DECAY_COPY_H #define BOOST_COROUTINES2_DETAIL_DECAY_COPY_H #include <type_traits> #include <boost/config.hpp> #include <boost/context/detail/config.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename T > typename std::decay< T >::type decay_copy( T && t) { return std::forward< T >( t); } }}} #ifdef BOOST_HAS_ABI_HEADERS #include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_DECAY_COPY_H PK ϩ!\.[O�6 �6 detail/push_control_block_cc.ippnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PUSH_CONTROL_BLOCK_IPP #define BOOST_COROUTINES2_DETAIL_PUSH_CONTROL_BLOCK_IPP #include <algorithm> #include <exception> #include <memory> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/context/detail/config.hpp> #include <boost/context/fiber.hpp> #include <boost/coroutine2/detail/config.hpp> #include <boost/coroutine2/detail/wrap.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { // push_coroutine< T > template< typename T > void push_coroutine< T >::control_block::destroy( control_block * cb) noexcept { boost::context::fiber c = std::move( cb->c); // destroy control structure cb->~control_block(); // destroy coroutine's stack cb->state |= state_t::destroy; } template< typename T > template< typename StackAllocator, typename Fn > push_coroutine< T >::control_block::control_block( context::preallocated palloc, StackAllocator && salloc, Fn && fn) : #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS) c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), wrap( [this](typename std::decay< Fn >::type & fn_,boost::context::fiber && c) mutable { // create synthesized pull_coroutine< T > typename pull_coroutine< T >::control_block synthesized_cb{ this, c }; pull_coroutine< T > synthesized{ & synthesized_cb }; other = & synthesized_cb; other->c = std::move( other->c).resume(); if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized pull_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back other->c = std::move( other->c).resume(); return std::move( other->c); }, std::forward< Fn >( fn) ) }, #else c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), [this,fn_=std::forward< Fn >( fn)](boost::context::fiber && c) mutable { // create synthesized pull_coroutine< T > typename pull_coroutine< T >::control_block synthesized_cb{ this, c }; pull_coroutine< T > synthesized{ & synthesized_cb }; other = & synthesized_cb; other->c = std::move( other->c).resume(); if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized pull_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back return std::move( other->c).resume(); } }, #endif other{ nullptr }, state{ state_t::unwind }, except{} { c = std::move( c).resume(); } template< typename T > push_coroutine< T >::control_block::control_block( typename pull_coroutine< T >::control_block * cb, boost::context::fiber & c_) noexcept : c{ std::move( c_) }, other{ cb }, state{ state_t::none }, except{} { } template< typename T > void push_coroutine< T >::control_block::deallocate() noexcept { if ( state_t::none != ( state & state_t::unwind) ) { destroy( this); } } template< typename T > void push_coroutine< T >::control_block::resume( T const& data) { // pass data to other context other->set( data); // resume other context c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } template< typename T > void push_coroutine< T >::control_block::resume( T && data) { // pass data to other context other->set( std::move( data) ); // resume other context c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } template< typename T > bool push_coroutine< T >::control_block::valid() const noexcept { return state_t::none == ( state & state_t::complete ); } // push_coroutine< T & > template< typename T > void push_coroutine< T & >::control_block::destroy( control_block * cb) noexcept { boost::context::fiber c = std::move( cb->c); // destroy control structure cb->~control_block(); // destroy coroutine's stack cb->state |= state_t::destroy; } template< typename T > template< typename StackAllocator, typename Fn > push_coroutine< T & >::control_block::control_block( context::preallocated palloc, StackAllocator && salloc, Fn && fn) : #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS) c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), wrap( [this](typename std::decay< Fn >::type & fn_,boost::context::fiber && c) mutable { // create synthesized pull_coroutine< T & > typename pull_coroutine< T & >::control_block synthesized_cb{ this, c }; pull_coroutine< T & > synthesized{ & synthesized_cb }; other = & synthesized_cb; other->c = std::move( other->c).resume(); if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized pull_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back other->c = std::move( other->c).resume(); return std::move( other->c); }, std::forward< Fn >( fn) ) }, #else c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), [this,fn_=std::forward< Fn >( fn)](boost::context::fiber && c) mutable { // create synthesized pull_coroutine< T & > typename pull_coroutine< T & >::control_block synthesized_cb{ this, c }; pull_coroutine< T & > synthesized{ & synthesized_cb }; other = & synthesized_cb; other->c = std::move( other->c).resume(); if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized pull_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back other->c = std::move( other->c).resume(); return std::move( other->c); } }, #endif other{ nullptr }, state{ state_t::unwind }, except{} { c = std::move( c).resume(); } template< typename T > push_coroutine< T & >::control_block::control_block( typename pull_coroutine< T & >::control_block * cb, boost::context::fiber & c_) noexcept : c{ std::move( c_) }, other{ cb }, state{ state_t::none }, except{} { } template< typename T > void push_coroutine< T & >::control_block::deallocate() noexcept { if ( state_t::none != ( state & state_t::unwind) ) { destroy( this); } } template< typename T > void push_coroutine< T & >::control_block::resume( T & data) { // pass data to other context other->set( data); // resume other context c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } template< typename T > bool push_coroutine< T & >::control_block::valid() const noexcept { return state_t::none == ( state & state_t::complete ); } // push_coroutine< void > inline void push_coroutine< void >::control_block::destroy( control_block * cb) noexcept { boost::context::fiber c = std::move( cb->c); // destroy control structure cb->~control_block(); // destroy coroutine's stack cb->state |= state_t::destroy; } template< typename StackAllocator, typename Fn > push_coroutine< void >::control_block::control_block( context::preallocated palloc, StackAllocator && salloc, Fn && fn) : #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS) c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), wrap( [this](typename std::decay< Fn >::type & fn_,boost::context::fiber && c) mutable { // create synthesized pull_coroutine< void > typename pull_coroutine< void >::control_block synthesized_cb{ this, c }; pull_coroutine< void > synthesized{ & synthesized_cb }; other = & synthesized_cb; other->c = std::move( other->c).resume(); if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized pull_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back other->c = std::move( other->c).resume(); return std::move( other->c); }, std::forward< Fn >( fn) ) }, #else c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), [this,fn_=std::forward< Fn >( fn)](boost::context::fiber && c) mutable { // create synthesized pull_coroutine< void > typename pull_coroutine< void >::control_block synthesized_cb{ this, c}; pull_coroutine< void > synthesized{ & synthesized_cb }; other = & synthesized_cb; other->c = std::move( other->c).resume(); if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized pull_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back other->c = std::move( other->c).resume(); return std::move( other->c); } }, #endif other{ nullptr }, state{ state_t::unwind }, except{} { c = std::move( c).resume(); } inline push_coroutine< void >::control_block::control_block( pull_coroutine< void >::control_block * cb, boost::context::fiber & c_) noexcept : c{ std::move( c_) }, other{ cb }, state{ state_t::none }, except{} { } inline void push_coroutine< void >::control_block::deallocate() noexcept { if ( state_t::none != ( state & state_t::unwind) ) { destroy( this); } } inline void push_coroutine< void >::control_block::resume() { c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } inline bool push_coroutine< void >::control_block::valid() const noexcept { return state_t::none == ( state & state_t::complete ); } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PUSH_CONTROL_BLOCK_IPP PK ϩ!\-c��[ [ detail/push_coroutine.ippnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PUSH_COROUTINE_IPP #define BOOST_COROUTINES2_DETAIL_PUSH_COROUTINE_IPP #include <utility> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/coroutine2/detail/config.hpp> #include <boost/coroutine2/detail/create_control_block.ipp> #include <boost/coroutine2/detail/disable_overload.hpp> #include <boost/coroutine2/fixedsize_stack.hpp> #include <boost/coroutine2/segmented_stack.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { // push_coroutine< T > template< typename T > push_coroutine< T >::push_coroutine( control_block * cb) noexcept : cb_{ cb } { } template< typename T > template< typename Fn, typename > push_coroutine< T >::push_coroutine( Fn && fn) : push_coroutine{ default_stack(), std::forward< Fn >( fn) } { } template< typename T > template< typename StackAllocator, typename Fn > push_coroutine< T >::push_coroutine( StackAllocator && salloc, Fn && fn) : cb_{ create_control_block< control_block >( std::forward< StackAllocator >( salloc), std::forward< Fn >( fn) ) } { } template< typename T > push_coroutine< T >::~push_coroutine() { if ( nullptr != cb_) { cb_->deallocate(); } } template< typename T > push_coroutine< T >::push_coroutine( push_coroutine && other) noexcept : cb_{ nullptr } { std::swap( cb_, other.cb_); } template< typename T > push_coroutine< T > & push_coroutine< T >::operator()( T const& t) { cb_->resume( t); return * this; } template< typename T > push_coroutine< T > & push_coroutine< T >::operator()( T && t) { cb_->resume( std::forward< T >( t) ); return * this; } template< typename T > push_coroutine< T >::operator bool() const noexcept { return nullptr != cb_ && cb_->valid(); } template< typename T > bool push_coroutine< T >::operator!() const noexcept { return nullptr == cb_ || ! cb_->valid(); } // push_coroutine< T & > template< typename T > push_coroutine< T & >::push_coroutine( control_block * cb) noexcept : cb_{ cb } { } template< typename T > template< typename Fn, typename > push_coroutine< T & >::push_coroutine( Fn && fn) : push_coroutine{ default_stack(), std::forward< Fn >( fn) } { } template< typename T > template< typename StackAllocator, typename Fn > push_coroutine< T & >::push_coroutine( StackAllocator && salloc, Fn && fn) : cb_{ create_control_block< control_block >( std::forward< StackAllocator >( salloc), std::forward< Fn >( fn) ) } { } template< typename T > push_coroutine< T & >::~push_coroutine() { if ( nullptr != cb_) { cb_->deallocate(); } } template< typename T > push_coroutine< T & >::push_coroutine( push_coroutine && other) noexcept : cb_{ nullptr } { std::swap( cb_, other.cb_); } template< typename T > push_coroutine< T & > & push_coroutine< T & >::operator()( T & t) { cb_->resume( t); return * this; } template< typename T > push_coroutine< T & >::operator bool() const noexcept { return nullptr != cb_ && cb_->valid(); } template< typename T > bool push_coroutine< T & >::operator!() const noexcept { return nullptr == cb_ || ! cb_->valid(); } // push_coroutine< void > inline push_coroutine< void >::push_coroutine( control_block * cb) noexcept : cb_{ cb } { } template< typename Fn, typename > push_coroutine< void >::push_coroutine( Fn && fn) : push_coroutine{ default_stack(), std::forward< Fn >( fn) } { } template< typename StackAllocator, typename Fn > push_coroutine< void >::push_coroutine( StackAllocator && salloc, Fn && fn) : cb_{ create_control_block< control_block >( std::forward< StackAllocator >( salloc), std::forward< Fn >( fn) ) } { } inline push_coroutine< void >::~push_coroutine() { if ( nullptr != cb_) { cb_->deallocate(); } } inline push_coroutine< void >::push_coroutine( push_coroutine && other) noexcept : cb_{ nullptr } { std::swap( cb_, other.cb_); } inline push_coroutine< void > & push_coroutine< void >::operator()() { cb_->resume(); return * this; } inline push_coroutine< void >::operator bool() const noexcept { return nullptr != cb_ && cb_->valid(); } inline bool push_coroutine< void >::operator!() const noexcept { return nullptr == cb_ || ! cb_->valid(); } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PUSH_COROUTINE_IPP PK ϩ!\z�*�� � detail/pull_coroutine.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PULL_COROUTINE_HPP #define BOOST_COROUTINES2_DETAIL_PULL_COROUTINE_HPP #include <iterator> #include <type_traits> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/coroutine2/detail/config.hpp> #include <boost/coroutine2/detail/disable_overload.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename T > class pull_coroutine { private: template< typename X > friend class push_coroutine; struct control_block; control_block * cb_; explicit pull_coroutine( control_block *) noexcept; bool has_result_() const noexcept; public: template< typename Fn, typename = detail::disable_overload< pull_coroutine, Fn > > explicit pull_coroutine( Fn &&); template< typename StackAllocator, typename Fn > pull_coroutine( StackAllocator &&, Fn &&); ~pull_coroutine(); pull_coroutine( pull_coroutine const&) = delete; pull_coroutine & operator=( pull_coroutine const&) = delete; pull_coroutine( pull_coroutine &&) noexcept; pull_coroutine & operator=( pull_coroutine && other) noexcept { std::swap( cb_, other.cb_); return * this; } pull_coroutine & operator()(); explicit operator bool() const noexcept; bool operator!() const noexcept; T get() noexcept; class iterator { private: pull_coroutine< T > * c_{ nullptr }; void fetch_() noexcept { BOOST_ASSERT( nullptr != c_); if ( ! ( * c_) ) { c_ = nullptr; return; } } void increment_() { BOOST_ASSERT( nullptr != c_); BOOST_ASSERT( * c_); ( * c_)(); fetch_(); } public: typedef std::input_iterator_tag iterator_category; typedef typename std::remove_reference< T >::type value_type; typedef std::ptrdiff_t difference_type; typedef value_type * pointer; typedef value_type & reference; typedef pointer pointer_t; typedef reference reference_t; iterator() noexcept = default; explicit iterator( pull_coroutine< T > * c) noexcept : c_{ c } { fetch_(); } bool operator==( iterator const& other) const noexcept { return other.c_ == c_; } bool operator!=( iterator const& other) const noexcept { return other.c_ != c_; } iterator & operator++() { increment_(); return * this; } void operator++( int) { increment_(); } reference_t operator*() const noexcept { return c_->cb_->get(); } pointer_t operator->() const noexcept { return std::addressof( c_->cb_->get() ); } }; friend class iterator; }; template< typename T > class pull_coroutine< T & > { private: template< typename X > friend class push_coroutine; struct control_block; control_block * cb_; explicit pull_coroutine( control_block *) noexcept; bool has_result_() const noexcept; public: template< typename Fn, typename = detail::disable_overload< pull_coroutine, Fn > > explicit pull_coroutine( Fn &&); template< typename StackAllocator, typename Fn > pull_coroutine( StackAllocator &&, Fn &&); ~pull_coroutine(); pull_coroutine( pull_coroutine const&) = delete; pull_coroutine & operator=( pull_coroutine const&) = delete; pull_coroutine( pull_coroutine &&) noexcept; pull_coroutine & operator=( pull_coroutine && other) noexcept { std::swap( cb_, other.cb_); return * this; } pull_coroutine & operator()(); explicit operator bool() const noexcept; bool operator!() const noexcept; T & get() noexcept; class iterator { private: pull_coroutine< T & > * c_{ nullptr }; void fetch_() noexcept { BOOST_ASSERT( nullptr != c_); if ( ! ( * c_) ) { c_ = nullptr; return; } } void increment_() { BOOST_ASSERT( nullptr != c_); BOOST_ASSERT( * c_); ( * c_)(); fetch_(); } public: typedef std::input_iterator_tag iterator_category; typedef typename std::remove_reference< T >::type value_type; typedef std::ptrdiff_t difference_type; typedef value_type * pointer; typedef value_type & reference; typedef pointer pointer_t; typedef reference reference_t; iterator() noexcept = default; explicit iterator( pull_coroutine< T & > * c) noexcept : c_{ c } { fetch_(); } bool operator==( iterator const& other) const noexcept { return other.c_ == c_; } bool operator!=( iterator const& other) const noexcept { return other.c_ != c_; } iterator & operator++() { increment_(); return * this; } void operator++( int) { increment_(); } reference_t operator*() const noexcept { return c_->cb_->get(); } pointer_t operator->() const noexcept { return std::addressof( c_->cb_->get() ); } }; friend class iterator; }; template<> class pull_coroutine< void > { private: template< typename X > friend class push_coroutine; struct control_block; control_block * cb_; explicit pull_coroutine( control_block *) noexcept; public: template< typename Fn, typename = detail::disable_overload< pull_coroutine, Fn > > explicit pull_coroutine( Fn &&); template< typename StackAllocator, typename Fn > pull_coroutine( StackAllocator &&, Fn &&); ~pull_coroutine(); pull_coroutine( pull_coroutine const&) = delete; pull_coroutine & operator=( pull_coroutine const&) = delete; pull_coroutine( pull_coroutine &&) noexcept; pull_coroutine & operator=( pull_coroutine && other) noexcept { std::swap( cb_, other.cb_); return * this; } pull_coroutine & operator()(); explicit operator bool() const noexcept; bool operator!() const noexcept; }; template< typename T > typename pull_coroutine< T >::iterator begin( pull_coroutine< T > & c) { return typename pull_coroutine< T >::iterator( & c); } template< typename T > typename pull_coroutine< T >::iterator end( pull_coroutine< T > &) { return typename pull_coroutine< T >::iterator(); } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PULL_COROUTINE_HPP PK ϩ!\ ��� � detail/push_coroutine.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PUSH_COROUTINE_HPP #define BOOST_COROUTINES2_DETAIL_PUSH_COROUTINE_HPP #include <iterator> #include <type_traits> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/coroutine2/detail/config.hpp> #include <boost/coroutine2/detail/disable_overload.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename T > class push_coroutine { private: template< typename X > friend class pull_coroutine; struct control_block; control_block * cb_; explicit push_coroutine( control_block *) noexcept; public: template< typename Fn, typename = detail::disable_overload< push_coroutine, Fn > > explicit push_coroutine( Fn &&); template< typename StackAllocator, typename Fn > push_coroutine( StackAllocator &&, Fn &&); ~push_coroutine(); push_coroutine( push_coroutine const&) = delete; push_coroutine & operator=( push_coroutine const&) = delete; push_coroutine( push_coroutine &&) noexcept; push_coroutine & operator=( push_coroutine && other) noexcept { if ( this == & other) return * this; std::swap( cb_, other.cb_); return * this; } push_coroutine & operator()( T const&); push_coroutine & operator()( T &&); explicit operator bool() const noexcept; bool operator!() const noexcept; class iterator { private: push_coroutine< T > * c_{ nullptr }; public: typedef std::output_iterator_tag iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; iterator() noexcept = default; explicit iterator( push_coroutine< T > * c) noexcept : c_{ c } { } iterator & operator=( T t) { BOOST_ASSERT( nullptr != c_); if ( ! ( * c_)( t) ) { c_ = nullptr; } return * this; } bool operator==( iterator const& other) const noexcept { return other.c_ == c_; } bool operator!=( iterator const& other) const noexcept { return other.c_ != c_; } iterator & operator*() noexcept { return * this; } iterator & operator++() noexcept { return * this; } }; }; template< typename T > class push_coroutine< T & > { private: template< typename X > friend class pull_coroutine; struct control_block; control_block * cb_; explicit push_coroutine( control_block *) noexcept; public: template< typename Fn, typename = detail::disable_overload< push_coroutine, Fn > > explicit push_coroutine( Fn &&); template< typename StackAllocator, typename Fn > push_coroutine( StackAllocator &&, Fn &&); ~push_coroutine(); push_coroutine( push_coroutine const&) = delete; push_coroutine & operator=( push_coroutine const&) = delete; push_coroutine( push_coroutine &&) noexcept; push_coroutine & operator=( push_coroutine && other) noexcept { if ( this == & other) return * this; std::swap( cb_, other.cb_); return * this; } push_coroutine & operator()( T &); explicit operator bool() const noexcept; bool operator!() const noexcept; class iterator { private: push_coroutine< T & > * c_{ nullptr }; public: typedef std::output_iterator_tag iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; iterator() noexcept = default; explicit iterator( push_coroutine< T & > * c) noexcept : c_{ c } { } iterator & operator=( T & t) { BOOST_ASSERT( nullptr != c_); if ( ! ( * c_)( t) ) { c_ = nullptr; } return * this; } bool operator==( iterator const& other) const noexcept { return other.c_ == c_; } bool operator!=( iterator const& other) const noexcept { return other.c_ != c_; } iterator & operator*() noexcept { return * this; } iterator & operator++() noexcept { return * this; } }; }; template<> class push_coroutine< void > { private: template< typename X > friend class pull_coroutine; struct control_block; control_block * cb_; explicit push_coroutine( control_block *) noexcept; public: template< typename Fn, typename = detail::disable_overload< push_coroutine, Fn > > explicit push_coroutine( Fn &&); template< typename StackAllocator, typename Fn > push_coroutine( StackAllocator &&, Fn &&); ~push_coroutine(); push_coroutine( push_coroutine const&) = delete; push_coroutine & operator=( push_coroutine const&) = delete; push_coroutine( push_coroutine &&) noexcept; push_coroutine & operator=( push_coroutine && other) noexcept { if ( this == & other) return * this; std::swap( cb_, other.cb_); return * this; } push_coroutine & operator()(); explicit operator bool() const noexcept; bool operator!() const noexcept; }; template< typename T > typename push_coroutine< T >::iterator begin( push_coroutine< T > & c) { return typename push_coroutine< T >::iterator( & c); } template< typename T > typename push_coroutine< T >::iterator end( push_coroutine< T > &) { return typename push_coroutine< T >::iterator(); } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PUSH_COROUTINE_HPP PK ϩ!\Qq� � � detail/pull_control_block_cc.hppnu �[��� // Copyright Oliver Kowalke 2016. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_HPP #define BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_HPP #include <exception> #include <type_traits> #include <boost/config.hpp> #include <boost/context/fiber.hpp> #include <boost/coroutine2/detail/state.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename T > struct pull_coroutine< T >::control_block { boost::context::fiber c; typename push_coroutine< T >::control_block * other; state_t state; std::exception_ptr except; bool bvalid; typename std::aligned_storage< sizeof( T), alignof( T) >::type storage; static void destroy( control_block * cb) noexcept; template< typename StackAllocator, typename Fn > control_block( context::preallocated, StackAllocator &&, Fn &&); control_block( typename push_coroutine< T >::control_block *, boost::context::fiber &) noexcept; ~control_block(); control_block( control_block &) = delete; control_block & operator=( control_block &) = delete; void deallocate() noexcept; void resume(); void set( T const&); void set( T &&); T & get() noexcept; bool valid() const noexcept; }; template< typename T > struct pull_coroutine< T & >::control_block { struct holder { T & t; holder( T & t_) : t{ t_ } { } }; boost::context::fiber c; typename push_coroutine< T & >::control_block * other; state_t state; std::exception_ptr except; bool bvalid; typename std::aligned_storage< sizeof( holder), alignof( holder) >::type storage; static void destroy( control_block * cb) noexcept; template< typename StackAllocator, typename Fn > control_block( context::preallocated, StackAllocator &&, Fn &&); control_block( typename push_coroutine< T & >::control_block *, boost::context::fiber &) noexcept; control_block( control_block &) = delete; control_block & operator=( control_block &) = delete; void deallocate() noexcept; void resume(); void set( T &); T & get() noexcept; bool valid() const noexcept; }; struct pull_coroutine< void >::control_block { boost::context::fiber c; push_coroutine< void >::control_block * other; state_t state; std::exception_ptr except; static void destroy( control_block * cb) noexcept; template< typename StackAllocator, typename Fn > control_block( context::preallocated, StackAllocator &&, Fn &&); control_block( push_coroutine< void >::control_block *, boost::context::fiber &) noexcept; control_block( control_block &) = delete; control_block & operator=( control_block &) = delete; void deallocate() noexcept; void resume(); bool valid() const noexcept; }; }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_HPP PK ϩ!\H��\� � detail/push_control_block_cc.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PUSH_CONTROL_BLOCK_HPP #define BOOST_COROUTINES2_DETAIL_PUSH_CONTROL_BLOCK_HPP #include <exception> #include <boost/config.hpp> #include <boost/context/fiber.hpp> #include <boost/coroutine2/detail/state.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename T > struct push_coroutine< T >::control_block { boost::context::fiber c; typename pull_coroutine< T >::control_block * other; state_t state; std::exception_ptr except; static void destroy( control_block * cb) noexcept; template< typename StackAllocator, typename Fn > control_block( context::preallocated, StackAllocator &&, Fn &&); control_block( typename pull_coroutine< T >::control_block *, boost::context::fiber &) noexcept; control_block( control_block &) = delete; control_block & operator=( control_block &) = delete; void deallocate() noexcept; void resume( T const&); void resume( T &&); bool valid() const noexcept; }; template< typename T > struct push_coroutine< T & >::control_block { boost::context::fiber c; typename pull_coroutine< T & >::control_block * other; state_t state; std::exception_ptr except; static void destroy( control_block * cb) noexcept; template< typename StackAllocator, typename Fn > control_block( context::preallocated, StackAllocator &&, Fn &&); control_block( typename pull_coroutine< T & >::control_block *, boost::context::fiber &) noexcept; control_block( control_block &) = delete; control_block & operator=( control_block &) = delete; void deallocate() noexcept; void resume( T &); bool valid() const noexcept; }; struct push_coroutine< void >::control_block { boost::context::fiber c; pull_coroutine< void >::control_block * other; state_t state; std::exception_ptr except; static void destroy( control_block * cb) noexcept; template< typename StackAllocator, typename Fn > control_block( context::preallocated, StackAllocator &&, Fn &&); control_block( pull_coroutine< void >::control_block *, boost::context::fiber &) noexcept; control_block( control_block &) = delete; control_block & operator=( control_block &) = delete; void deallocate() noexcept; void resume(); bool valid() const noexcept; }; }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PUSH_CONTROL_BLOCK_HPP PK ϩ!\'(��u u detail/pull_coroutine.ippnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PULL_COROUTINE_IPP #define BOOST_COROUTINES2_DETAIL_PULL_COROUTINE_IPP #include <algorithm> #include <utility> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/coroutine2/detail/config.hpp> #include <boost/coroutine2/detail/create_control_block.ipp> #include <boost/coroutine2/detail/disable_overload.hpp> #include <boost/coroutine2/fixedsize_stack.hpp> #include <boost/coroutine2/segmented_stack.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { // pull_coroutine< T > template< typename T > pull_coroutine< T >::pull_coroutine( control_block * cb) noexcept : cb_{ cb } { } template< typename T > bool pull_coroutine< T >::has_result_() const noexcept { return nullptr != cb_->other->t; } template< typename T > template< typename Fn, typename > pull_coroutine< T >::pull_coroutine( Fn && fn) : pull_coroutine{ default_stack(), std::forward< Fn >( fn) } { } template< typename T > template< typename StackAllocator, typename Fn > pull_coroutine< T >::pull_coroutine( StackAllocator && salloc, Fn && fn) : cb_{ create_control_block< control_block >( std::forward< StackAllocator >( salloc), std::forward< Fn >( fn) ) } { if ( ! cb_->valid() ) { cb_->deallocate(); cb_ = nullptr; } } template< typename T > pull_coroutine< T >::~pull_coroutine() { if ( nullptr != cb_) { cb_->deallocate(); } } template< typename T > pull_coroutine< T >::pull_coroutine( pull_coroutine && other) noexcept : cb_{ nullptr } { std::swap( cb_, other.cb_); } template< typename T > pull_coroutine< T > & pull_coroutine< T >::operator()() { cb_->resume(); return * this; } template< typename T > pull_coroutine< T >::operator bool() const noexcept { return nullptr != cb_ && cb_->valid(); } template< typename T > bool pull_coroutine< T >::operator!() const noexcept { return nullptr == cb_ || ! cb_->valid(); } template< typename T > T pull_coroutine< T >::get() noexcept { return std::move( cb_->get() ); } // pull_coroutine< T & > template< typename T > pull_coroutine< T & >::pull_coroutine( control_block * cb) noexcept : cb_{ cb } { } template< typename T > bool pull_coroutine< T & >::has_result_() const noexcept { return nullptr != cb_->other->t; } template< typename T > template< typename Fn, typename > pull_coroutine< T & >::pull_coroutine( Fn && fn) : pull_coroutine{ default_stack(), std::forward< Fn >( fn) } { } template< typename T > template< typename StackAllocator, typename Fn > pull_coroutine< T & >::pull_coroutine( StackAllocator && salloc, Fn && fn) : cb_{ create_control_block< control_block >( std::forward< StackAllocator >( salloc), std::forward< Fn >( fn) ) } { if ( ! cb_->valid() ) { cb_->deallocate(); cb_ = nullptr; } } template< typename T > pull_coroutine< T & >::~pull_coroutine() { if ( nullptr != cb_) { cb_->deallocate(); } } template< typename T > pull_coroutine< T & >::pull_coroutine( pull_coroutine && other) noexcept : cb_{ nullptr } { std::swap( cb_, other.cb_); } template< typename T > pull_coroutine< T & > & pull_coroutine< T & >::operator()() { cb_->resume(); return * this; } template< typename T > pull_coroutine< T & >::operator bool() const noexcept { return nullptr != cb_ && cb_->valid(); } template< typename T > bool pull_coroutine< T & >::operator!() const noexcept { return nullptr == cb_ || ! cb_->valid(); } template< typename T > T & pull_coroutine< T & >::get() noexcept { return cb_->get(); } // pull_coroutine< void > inline pull_coroutine< void >::pull_coroutine( control_block * cb) noexcept : cb_{ cb } { } template< typename Fn, typename > pull_coroutine< void >::pull_coroutine( Fn && fn) : pull_coroutine{ default_stack(), std::forward< Fn >( fn) } { } template< typename StackAllocator, typename Fn > pull_coroutine< void >::pull_coroutine( StackAllocator && salloc, Fn && fn) : cb_{ create_control_block< control_block >( std::forward< StackAllocator >( salloc), std::forward< Fn >( fn) ) } { if ( ! cb_->valid() ) { cb_->deallocate(); cb_ = nullptr; } } inline pull_coroutine< void >::~pull_coroutine() { if ( nullptr != cb_) { cb_->deallocate(); } } inline pull_coroutine< void >::pull_coroutine( pull_coroutine && other) noexcept : cb_{ nullptr } { std::swap( cb_, other.cb_); } inline pull_coroutine< void > & pull_coroutine< void >::operator()() { cb_->resume(); return * this; } inline pull_coroutine< void >::operator bool() const noexcept { return nullptr != cb_ && cb_->valid(); } inline bool pull_coroutine< void >::operator!() const noexcept { return nullptr == cb_ || ! cb_->valid(); } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PULL_COROUTINE_IPP PK ϩ!\�`�.�9 �9 detail/pull_control_block_cc.ippnu �[��� // Copyright Oliver Kowalke 2016. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP #define BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP #include <algorithm> #include <exception> #include <memory> #include <tuple> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/context/detail/config.hpp> #include <boost/context/fiber.hpp> #include <boost/coroutine2/detail/config.hpp> #include <boost/coroutine2/detail/wrap.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { // pull_coroutine< T > template< typename T > void pull_coroutine< T >::control_block::destroy( control_block * cb) noexcept { boost::context::fiber c = std::move( cb->c); // destroy control structure cb->~control_block(); // destroy coroutine's stack cb->state |= state_t::destroy; } template< typename T > template< typename StackAllocator, typename Fn > pull_coroutine< T >::control_block::control_block( context::preallocated palloc, StackAllocator && salloc, Fn && fn) : #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS) c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), wrap( [this](typename std::decay< Fn >::type & fn_,boost::context::fiber && c) mutable { // create synthesized push_coroutine< T > typename push_coroutine< T >::control_block synthesized_cb{ this, c }; push_coroutine< T > synthesized{ & synthesized_cb }; other = & synthesized_cb; if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized push_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back return std::move( other->c).resume(); }, std::forward< Fn >( fn) ) }, #else c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), [this,fn_=std::forward< Fn >( fn)](boost::context::fiber && c) mutable { // create synthesized push_coroutine< T > typename push_coroutine< T >::control_block synthesized_cb{ this, c }; push_coroutine< T > synthesized{ & synthesized_cb }; other = & synthesized_cb; if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized push_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back return std::move( other->c).resume(); } }, #endif other{ nullptr }, state{ state_t::unwind }, except{}, bvalid{ false }, storage{} { c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } template< typename T > pull_coroutine< T >::control_block::control_block( typename push_coroutine< T >::control_block * cb, boost::context::fiber & c_) noexcept : c{ std::move( c_) }, other{ cb }, state{ state_t::none }, except{}, bvalid{ false }, storage{} { } template< typename T > pull_coroutine< T >::control_block::~control_block() { // destroy data if set if ( bvalid) { reinterpret_cast< T * >( std::addressof( storage) )->~T(); } } template< typename T > void pull_coroutine< T >::control_block::deallocate() noexcept { if ( state_t::none != ( state & state_t::unwind) ) { destroy( this); } } template< typename T > void pull_coroutine< T >::control_block::resume() { c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } template< typename T > void pull_coroutine< T >::control_block::set( T const& t) { // destroy data if set if ( bvalid) { reinterpret_cast< T * >( std::addressof( storage) )->~T(); } ::new ( static_cast< void * >( std::addressof( storage) ) ) T( t); bvalid = true; } template< typename T > void pull_coroutine< T >::control_block::set( T && t) { // destroy data if set if ( bvalid) { reinterpret_cast< T * >( std::addressof( storage) )->~T(); } ::new ( static_cast< void * >( std::addressof( storage) ) ) T( std::move( t) ); bvalid = true; } template< typename T > T & pull_coroutine< T >::control_block::get() noexcept { return * reinterpret_cast< T * >( std::addressof( storage) ); } template< typename T > bool pull_coroutine< T >::control_block::valid() const noexcept { return nullptr != other && state_t::none == ( state & state_t::complete) && bvalid; } // pull_coroutine< T & > template< typename T > void pull_coroutine< T & >::control_block::destroy( control_block * cb) noexcept { boost::context::fiber c = std::move( cb->c); // destroy control structure cb->~control_block(); // destroy coroutine's stack cb->state |= state_t::destroy; } template< typename T > template< typename StackAllocator, typename Fn > pull_coroutine< T & >::control_block::control_block( context::preallocated palloc, StackAllocator && salloc, Fn && fn) : #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS) c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), wrap( [this](typename std::decay< Fn >::type & fn_,boost::context::fiber && c) mutable { // create synthesized push_coroutine< T & > typename push_coroutine< T & >::control_block synthesized_cb{ this, c }; push_coroutine< T & > synthesized{ & synthesized_cb }; other = & synthesized_cb; if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized push_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back return std::move( other->c).resume(); }, std::forward< Fn >( fn) ) }, #else c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), [this,fn_=std::forward< Fn >( fn)](boost::context::fiber && c) mutable { // create synthesized push_coroutine< T & > typename push_coroutine< T & >::control_block synthesized_cb{ this, c }; push_coroutine< T & > synthesized{ & synthesized_cb }; other = & synthesized_cb; if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized push_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back return std::move( other->c).resume(); } }, #endif other{ nullptr }, state{ state_t::unwind }, except{}, bvalid{ false }, storage{} { c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } template< typename T > pull_coroutine< T & >::control_block::control_block( typename push_coroutine< T & >::control_block * cb, boost::context::fiber & c_) noexcept : c{ std::move( c_) }, other{ cb }, state{ state_t::none }, except{}, bvalid{ false }, storage{} { } template< typename T > void pull_coroutine< T & >::control_block::deallocate() noexcept { if ( state_t::none != ( state & state_t::unwind) ) { destroy( this); } } template< typename T > void pull_coroutine< T & >::control_block::resume() { c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } template< typename T > void pull_coroutine< T & >::control_block::set( T & t) { ::new ( static_cast< void * >( std::addressof( storage) ) ) holder{ t }; bvalid = true; } template< typename T > T & pull_coroutine< T & >::control_block::get() noexcept { return reinterpret_cast< holder * >( std::addressof( storage) )->t; } template< typename T > bool pull_coroutine< T & >::control_block::valid() const noexcept { return nullptr != other && state_t::none == ( state & state_t::complete) && bvalid; } // pull_coroutine< void > inline void pull_coroutine< void >::control_block::destroy( control_block * cb) noexcept { boost::context::fiber c = std::move( cb->c); // destroy control structure cb->~control_block(); // destroy coroutine's stack cb->state |= state_t::destroy; } template< typename StackAllocator, typename Fn > pull_coroutine< void >::control_block::control_block( context::preallocated palloc, StackAllocator && salloc, Fn && fn) : #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS) c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), wrap( [this](typename std::decay< Fn >::type & fn_,boost::context::fiber && c) mutable { // create synthesized push_coroutine< void > typename push_coroutine< void >::control_block synthesized_cb{ this, c }; push_coroutine< void > synthesized{ & synthesized_cb }; other = & synthesized_cb; if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized push_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back return std::move( other->c).resume(); }, std::forward< Fn >( fn) ) }, #else c{ std::allocator_arg, palloc, std::forward< StackAllocator >( salloc), [this,fn_=std::forward< Fn >( fn)]( boost::context::fiber && c) mutable { // create synthesized push_coroutine< void > typename push_coroutine< void >::control_block synthesized_cb{ this, c }; push_coroutine< void > synthesized{ & synthesized_cb }; other = & synthesized_cb; if ( state_t::none == ( state & state_t::destroy) ) { try { auto fn = std::move( fn_); // call coroutine-fn with synthesized push_coroutine as argument fn( synthesized); } catch ( boost::context::detail::forced_unwind const&) { throw; #if defined( BOOST_CONTEXT_HAS_CXXABI_H ) } catch ( abi::__forced_unwind const&) { throw; #endif } catch (...) { // store other exceptions in exception-pointer except = std::current_exception(); } } // set termination flags state |= state_t::complete; // jump back to ctx return std::move( other->c).resume(); } }, #endif other{ nullptr }, state{ state_t::unwind }, except{} { c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } inline pull_coroutine< void >::control_block::control_block( push_coroutine< void >::control_block * cb, boost::context::fiber & c_) noexcept : c{ std::move( c_) }, other{ cb }, state{ state_t::none }, except{} { } inline void pull_coroutine< void >::control_block::deallocate() noexcept { if ( state_t::none != ( state & state_t::unwind) ) { destroy( this); } } inline void pull_coroutine< void >::control_block::resume() { c = std::move( c).resume(); if ( except) { std::rethrow_exception( except); } } inline bool pull_coroutine< void >::control_block::valid() const noexcept { return nullptr != other && state_t::none == ( state & state_t::complete); } }}} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP PK ϩ!\�or�> > detail/disable_overload.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_DETAIL_DISABLE_OVERLOAD_H #define BOOST_COROUTINES2_DETAIL_DISABLE_OVERLOAD_H #include <type_traits> #include <boost/config.hpp> #include <boost/context/detail/disable_overload.hpp> #include <boost/coroutine2/detail/config.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { namespace detail { template< typename X, typename Y > using disable_overload = boost::context::detail::disable_overload< X, Y >; }}} #ifdef BOOST_HAS_ABI_HEADERS #include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_DETAIL_DISABLE_OVERLOAD_H PK ϩ!\rPlGm m segmented_stack.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_SEGMENTED_H #define BOOST_COROUTINES2_SEGMENTED_H #include <exception> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/context/segmented_stack.hpp> #include <boost/coroutine2/detail/coroutine.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { #if defined(BOOST_USE_SEGMENTED_STACKS) # if ! defined(BOOST_WINDOWS) using segmented_stack = boost::context::segmented_stack; using default_stack = boost::context::default_stack; # endif #endif }} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_SEGMENTED_H PK ϩ!\y lH H fixedsize_stack.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_FIXEDSIZE_H #define BOOST_COROUTINES2_FIXEDSIZE_H #include <exception> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/context/fixedsize_stack.hpp> #include <boost/coroutine2/detail/coroutine.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { using fixedsize_stack = boost::context::fixedsize_stack; #if !defined(BOOST_USE_SEGMENTED_STACKS) using default_stack = boost::context::default_stack; #endif }} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_FIXEDSIZE_H PK ϩ!\ӏ* protected_fixedsize_stack.hppnu �[��� // Copyright Oliver Kowalke 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_COROUTINES2_PROTECTED_FIXEDSIZE_H #define BOOST_COROUTINES2_PROTECTED_FIXEDSIZE_H #include <exception> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/context/protected_fixedsize_stack.hpp> #include <boost/coroutine2/detail/coroutine.hpp> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace coroutines2 { using protected_fixedsize_stack = boost::context::protected_fixedsize_stack; }} #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_COROUTINES2_PROTECTED_FIXEDSIZE_H PK ϩ!\ M-E pooled_fixedsize_stack.hppnu �[��� PK ϩ!\��SU U W coroutine.hppnu �[��� PK ϩ!\«6�4 4 � all.hppnu �[��� PK ϩ!\R]�1� � T detail/state.hppnu �[��� PK ϩ!\���� � } detail/coroutine.hppnu �[��� PK ϩ!\j��� _ detail/create_control_block.ippnu �[��� PK ϩ!\}� [v v � detail/config.hppnu �[��� PK ϩ!\�\�X X �! detail/wrap.hppnu �[��� PK ϩ!\I��u� � ( detail/decay_copy.hppnu �[��� PK ϩ!\.[O�6 �6 R+ detail/push_control_block_cc.ippnu �[��� PK ϩ!\-c��[ [ �b detail/push_coroutine.ippnu �[��� PK ϩ!\z�*�� � %u detail/pull_coroutine.hppnu �[��� PK ϩ!\ ��� � F� detail/push_coroutine.hppnu �[��� PK ϩ!\Qq� � � \� detail/pull_control_block_cc.hppnu �[��� PK ϩ!\H��\� � r� detail/push_control_block_cc.hppnu �[��� PK ϩ!\'(��u u �� detail/pull_coroutine.ippnu �[��� PK ϩ!\�`�.�9 �9 t� detail/pull_control_block_cc.ippnu �[��� PK ϩ!\�or�> > � detail/disable_overload.hppnu �[��� PK ϩ!\rPlGm m ? segmented_stack.hppnu �[��� PK ϩ!\y lH H � fixedsize_stack.hppnu �[��� PK ϩ!\ӏ* z protected_fixedsize_stack.hppnu �[��� PK ( �!
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0 |
proxy
|
phpinfo
|
???????????