passenger 6.0.11 → 6.0.12
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHANGELOG +24 -1
- data/CONTRIBUTORS +3 -0
- data/src/agent/Core/Config.h +1 -1
- data/src/agent/Core/Controller/CheckoutSession.cpp +24 -13
- data/src/agent/Core/Controller/Config.h +1 -1
- data/src/agent/Core/Controller/InternalUtils.cpp +32 -6
- data/src/agent/Core/Controller.h +4 -1
- data/src/agent/Watchdog/Config.h +1 -1
- data/src/cxx_supportlib/Constants.h +1 -1
- data/src/cxx_supportlib/IOTools/IOUtils.cpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/align/aligned_alloc.hpp +47 -0
- data/src/cxx_supportlib/vendor-modified/boost/align/detail/aligned_alloc_posix.hpp +41 -0
- data/src/cxx_supportlib/vendor-modified/boost/align/detail/is_alignment.hpp +28 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/associated_allocator.hpp +53 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/associated_cancellation_slot.hpp +179 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/associated_executor.hpp +57 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/associator.hpp +37 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/async_result.hpp +789 -106
- data/src/cxx_supportlib/vendor-modified/boost/asio/awaitable.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_datagram_socket.hpp +80 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_deadline_timer.hpp +10 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_raw_socket.hpp +80 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_seq_packet_socket.hpp +30 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_socket.hpp +20 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_socket_acceptor.hpp +90 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_stream_socket.hpp +60 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/basic_waitable_timer.hpp +10 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/bind_cancellation_slot.hpp +723 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/bind_executor.hpp +191 -12
- data/src/cxx_supportlib/vendor-modified/boost/asio/cancellation_signal.hpp +361 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/cancellation_state.hpp +237 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/cancellation_type.hpp +176 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/co_spawn.hpp +30 -2
- data/src/cxx_supportlib/vendor-modified/boost/asio/connect.hpp +60 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/base_from_cancellation_state.hpp +165 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/bind_handler.hpp +209 -76
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/config.hpp +149 -60
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/deadline_timer_service.hpp +40 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/dev_poll_reactor.hpp +8 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/epoll_reactor.hpp +14 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/functional.hpp +6 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/handler_alloc_helpers.hpp +14 -10
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/handler_type_requirements.hpp +21 -18
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/handler_work.hpp +30 -19
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/dev_poll_reactor.hpp +8 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/dev_poll_reactor.ipp +14 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/epoll_reactor.hpp +20 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/epoll_reactor.ipp +30 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/kqueue_reactor.hpp +20 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/kqueue_reactor.ipp +29 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/select_reactor.hpp +24 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/select_reactor.ipp +19 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/strand_executor_service.hpp +3 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/timer_queue_ptime.ipp +6 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/kqueue_reactor.hpp +15 -5
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/memory.hpp +60 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/pop_options.hpp +8 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/push_options.hpp +27 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/reactive_descriptor_service.hpp +93 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/reactive_socket_service.hpp +77 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/reactive_socket_service_base.hpp +111 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/reactor_op.hpp +4 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/reactor_op_queue.hpp +44 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/recycling_allocator.hpp +2 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/resolve_endpoint_op.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/select_reactor.hpp +14 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/thread_info_base.hpp +90 -24
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/timer_queue.hpp +30 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/timer_queue_ptime.hpp +4 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/wait_op.hpp +5 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/detail/work_dispatcher.hpp +5 -2
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/any_executor.hpp +12 -12
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/bulk_execute.hpp +10 -8
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/connect.hpp +8 -8
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/execute.hpp +7 -7
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/schedule.hpp +7 -7
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/set_done.hpp +7 -7
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/set_error.hpp +7 -7
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/set_value.hpp +13 -13
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/start.hpp +7 -7
- data/src/cxx_supportlib/vendor-modified/boost/asio/execution/submit.hpp +8 -8
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/append.hpp +73 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/as_tuple.hpp +133 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/awaitable_operators.hpp +538 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/cancellation_condition.hpp +157 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/coro.hpp +1057 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/deferred.hpp +607 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/detail/completion_handler_erasure.hpp +160 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/detail/coro_promise_allocator.hpp +120 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/detail/coro_traits.hpp +185 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/detail/partial_promise.hpp +181 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/append.hpp +219 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/as_single.hpp +14 -28
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/as_tuple.hpp +248 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/deferred.hpp +106 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/parallel_group.hpp +434 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/prepend.hpp +219 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/promise.hpp +100 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/parallel_group.hpp +217 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/prepend.hpp +73 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/promise.hpp +608 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/use_coro.hpp +284 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/awaitable.hpp +344 -20
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/buffered_read_stream.hpp +23 -54
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/buffered_write_stream.hpp +23 -54
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/co_spawn.hpp +66 -18
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/compose.hpp +55 -5
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/connect.hpp +68 -80
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/defer.hpp +8 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/dispatch.hpp +8 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/handler_alloc_hook.ipp +3 -2
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/post.hpp +8 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/read.hpp +98 -113
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/read_at.hpp +71 -82
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/read_until.hpp +210 -266
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/redirect_error.hpp +248 -30
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/spawn.hpp +11 -21
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/use_awaitable.hpp +15 -3
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/write.hpp +71 -87
- data/src/cxx_supportlib/vendor-modified/boost/asio/impl/write_at.hpp +46 -68
- data/src/cxx_supportlib/vendor-modified/boost/asio/io_context.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/local/detail/impl/endpoint.ipp +2 -7
- data/src/cxx_supportlib/vendor-modified/boost/asio/posix/basic_descriptor.hpp +10 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/posix/basic_stream_descriptor.hpp +23 -3
- data/src/cxx_supportlib/vendor-modified/boost/asio/prefer.hpp +21 -21
- data/src/cxx_supportlib/vendor-modified/boost/asio/query.hpp +9 -9
- data/src/cxx_supportlib/vendor-modified/boost/asio/read.hpp +88 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/read_at.hpp +44 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/read_until.hpp +132 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/require.hpp +21 -21
- data/src/cxx_supportlib/vendor-modified/boost/asio/require_concept.hpp +9 -9
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/buffered_handshake_op.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/engine.hpp +5 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/handshake_op.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/impl/engine.ipp +14 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/io.hpp +36 -27
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/read_op.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/shutdown_op.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/stream_core.hpp +37 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/write_op.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/impl/context.ipp +14 -7
- data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/stream.hpp +73 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/system_executor.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/this_coro.hpp +235 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/thread_pool.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/asio/use_awaitable.hpp +7 -10
- data/src/cxx_supportlib/vendor-modified/boost/asio/version.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/asio/windows/basic_random_access_handle.hpp +20 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/windows/basic_stream_handle.hpp +20 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/write.hpp +88 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio/write_at.hpp +44 -0
- data/src/cxx_supportlib/vendor-modified/boost/asio.hpp +6 -0
- data/src/cxx_supportlib/vendor-modified/boost/atomic/atomic_ref.hpp +14 -1
- data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/config.hpp +17 -13
- data/src/cxx_supportlib/vendor-modified/boost/atomic/ipc_atomic_ref.hpp +14 -1
- data/src/cxx_supportlib/vendor-modified/boost/config/assert_cxx03.hpp +2 -5
- data/src/cxx_supportlib/vendor-modified/boost/config/assert_cxx11.hpp +2 -5
- data/src/cxx_supportlib/vendor-modified/boost/config/assert_cxx14.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/config/assert_cxx17.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/config/assert_cxx20.hpp +56 -0
- data/src/cxx_supportlib/vendor-modified/boost/config/auto_link.hpp +1 -5
- data/src/cxx_supportlib/vendor-modified/boost/config/compiler/common_edg.hpp +31 -11
- data/src/cxx_supportlib/vendor-modified/boost/config/detail/cxx_composite.hpp +20 -4
- data/src/cxx_supportlib/vendor-modified/boost/config/detail/select_platform_config.hpp +5 -0
- data/src/cxx_supportlib/vendor-modified/boost/config/detail/suffix.hpp +81 -0
- data/src/cxx_supportlib/vendor-modified/boost/config/platform/bsd.hpp +5 -8
- data/src/cxx_supportlib/vendor-modified/boost/config/platform/wasm.hpp +17 -0
- data/src/cxx_supportlib/vendor-modified/boost/config/stdlib/dinkumware.hpp +26 -0
- data/src/cxx_supportlib/vendor-modified/boost/config/stdlib/libcpp.hpp +49 -0
- data/src/cxx_supportlib/vendor-modified/boost/config/stdlib/libstdcpp3.hpp +46 -4
- data/src/cxx_supportlib/vendor-modified/boost/container/adaptive_pool.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/container/allocator.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/container/detail/adaptive_node_pool.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/container/detail/node_pool.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/container/detail/std_fwd.hpp +3 -0
- data/src/cxx_supportlib/vendor-modified/boost/container/devector.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/container/new_allocator.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/container/node_allocator.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/container/pmr/polymorphic_allocator.hpp +6 -6
- data/src/cxx_supportlib/vendor-modified/boost/container/static_vector.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/container/throw_exception.hpp +45 -38
- data/src/cxx_supportlib/vendor-modified/boost/container/vector.hpp +24 -0
- data/src/cxx_supportlib/vendor-modified/boost/core/ignore_unused.hpp +32 -2
- data/src/cxx_supportlib/vendor-modified/boost/core/uncaught_exceptions.hpp +7 -7
- data/src/cxx_supportlib/vendor-modified/boost/date_time/compiler_config.hpp +0 -24
- data/src/cxx_supportlib/vendor-modified/boost/date_time/posix_time/time_parsers.hpp +4 -0
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/any_hook.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/avl_set.hpp +83 -83
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/avltree.hpp +43 -43
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/avltree_algorithms.hpp +31 -31
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/bs_set.hpp +85 -85
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/bstree.hpp +68 -68
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/bstree_algorithms.hpp +72 -62
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/circular_list_algorithms.hpp +19 -20
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/circular_slist_algorithms.hpp +19 -19
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/derivation_value_traits.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/any_node_and_algorithms.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/bstree_algorithms_base.hpp +3 -3
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/common_slist_algorithms.hpp +5 -5
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/config_begin.hpp +1 -0
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/generic_hook.hpp +8 -8
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/hash_combine.hpp +2 -4
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/hashtable_node.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/math.hpp +2 -50
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/node_cloner_disposer.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/hashtable.hpp +71 -70
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/linear_slist_algorithms.hpp +15 -14
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/list.hpp +84 -82
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/list_hook.hpp +10 -10
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/member_value_traits.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/parent_from_member.hpp +2 -2
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/pointer_plus_bits.hpp +4 -4
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/pointer_traits.hpp +18 -18
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/rbtree.hpp +43 -43
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/rbtree_algorithms.hpp +26 -26
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/set.hpp +85 -85
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/set_hook.hpp +12 -12
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/sg_set.hpp +93 -93
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/sgtree.hpp +51 -51
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/sgtree_algorithms.hpp +24 -24
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/slist.hpp +104 -104
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/slist_hook.hpp +8 -6
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/splay_set.hpp +91 -91
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/splaytree.hpp +46 -46
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/splaytree_algorithms.hpp +31 -31
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/treap.hpp +51 -51
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/treap_algorithms.hpp +18 -18
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/treap_set.hpp +97 -97
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/trivial_value_traits.hpp +6 -4
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/unordered_set.hpp +63 -63
- data/src/cxx_supportlib/vendor-modified/boost/intrusive/unordered_set_hook.hpp +15 -15
- data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_numeric.hpp +4 -1
- data/src/cxx_supportlib/vendor-modified/boost/move/detail/config_begin.hpp +1 -0
- data/src/cxx_supportlib/vendor-modified/boost/move/detail/iterator_traits.hpp +1 -0
- data/src/cxx_supportlib/vendor-modified/boost/move/detail/nsec_clock.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/operators.hpp +2 -0
- data/src/cxx_supportlib/vendor-modified/boost/regex/concepts.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/regex/v4/basic_regex_parser.hpp +3 -0
- data/src/cxx_supportlib/vendor-modified/boost/regex/v4/unicode_iterator.hpp +112 -31
- data/src/cxx_supportlib/vendor-modified/boost/regex/v5/basic_regex_parser.hpp +3 -0
- data/src/cxx_supportlib/vendor-modified/boost/regex/v5/mem_block_cache.hpp +4 -8
- data/src/cxx_supportlib/vendor-modified/boost/regex/v5/unicode_iterator.hpp +0 -2
- data/src/cxx_supportlib/vendor-modified/boost/regex/v5/w32_regex_traits.hpp +6 -2
- data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/shared_count.hpp +1 -1
- data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/sp_counted_impl.hpp +22 -2
- data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/shared_ptr.hpp +59 -1
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/config.hpp +9 -11
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/error_category.hpp +27 -21
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/error_category_impl.hpp +34 -3
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/error_code.hpp +378 -36
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/error_condition.hpp +97 -21
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/interop_category.hpp +107 -0
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/is_same.hpp +33 -0
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/snprintf.hpp +70 -0
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/{to_std_category.hpp → std_category.hpp} +5 -55
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/system_category_impl.hpp +2 -12
- data/src/cxx_supportlib/vendor-modified/boost/system/error_code.hpp +0 -33
- data/src/cxx_supportlib/vendor-modified/boost/utility/detail/result_of_variadic.hpp +190 -0
- data/src/cxx_supportlib/vendor-modified/boost/utility/result_of.hpp +20 -9
- data/src/cxx_supportlib/vendor-modified/boost/utility/string_view.hpp +3 -1
- data/src/cxx_supportlib/vendor-modified/boost/version.hpp +2 -2
- data/src/nginx_module/ConfigGeneral/AutoGeneratedDefinitions.c +8 -0
- data/src/nginx_module/ConfigGeneral/AutoGeneratedManifestDefaultsInitialization.c +6 -0
- data/src/nginx_module/ConfigGeneral/AutoGeneratedSetterFuncs.c +12 -0
- data/src/nginx_module/LocationConfig/AutoGeneratedCreateFunction.c +5 -0
- data/src/nginx_module/LocationConfig/AutoGeneratedHeaderSerialization.c +21 -0
- data/src/nginx_module/LocationConfig/AutoGeneratedManifestGeneration.c +13 -0
- data/src/nginx_module/LocationConfig/AutoGeneratedMergeFunction.c +3 -0
- data/src/nginx_module/LocationConfig/AutoGeneratedStruct.h +4 -0
- data/src/ruby_supportlib/phusion_passenger/admin_tools/instance_registry.rb +3 -2
- data/src/ruby_supportlib/phusion_passenger/loader_shared_helpers.rb +8 -1
- data/src/ruby_supportlib/phusion_passenger/nginx/config_options.rb +6 -0
- data/src/ruby_supportlib/phusion_passenger/packaging.rb +1 -0
- data/src/ruby_supportlib/phusion_passenger/platform_info/openssl.rb +1 -1
- data/src/ruby_supportlib/phusion_passenger/platform_info/operating_system.rb +8 -0
- data/src/ruby_supportlib/phusion_passenger/request_handler.rb +4 -1
- data/src/ruby_supportlib/phusion_passenger.rb +1 -1
- metadata +39 -4
- data/src/cxx_supportlib/vendor-modified/boost/system/detail/is_generic_value.hpp +0 -125
@@ -0,0 +1,1057 @@
|
|
1
|
+
//
|
2
|
+
// experimental/coro.hpp
|
3
|
+
// ~~~~~~~~~~~~~~~~~~~~~
|
4
|
+
//
|
5
|
+
// Copyright (c) 2021 Klemens D. Morgenstern
|
6
|
+
// (klemens dot morgenstern at gmx dot net)
|
7
|
+
//
|
8
|
+
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
9
|
+
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
10
|
+
//
|
11
|
+
|
12
|
+
#ifndef BOOST_ASIO_EXPERIMENTAL_CORO_HPP
|
13
|
+
#define BOOST_ASIO_EXPERIMENTAL_CORO_HPP
|
14
|
+
|
15
|
+
#include <boost/asio/detail/config.hpp>
|
16
|
+
#include <boost/asio/dispatch.hpp>
|
17
|
+
#include <boost/asio/experimental/detail/coro_promise_allocator.hpp>
|
18
|
+
#include <boost/asio/experimental/detail/partial_promise.hpp>
|
19
|
+
#include <boost/asio/experimental/detail/coro_traits.hpp>
|
20
|
+
#include <boost/asio/error.hpp>
|
21
|
+
#include <boost/system/error_code.hpp>
|
22
|
+
#include <boost/asio/experimental/use_coro.hpp>
|
23
|
+
#include <boost/asio/post.hpp>
|
24
|
+
|
25
|
+
#include <boost/asio/detail/push_options.hpp>
|
26
|
+
|
27
|
+
namespace boost {
|
28
|
+
namespace asio {
|
29
|
+
namespace experimental {
|
30
|
+
|
31
|
+
template <typename Yield, typename Return, typename Executor>
|
32
|
+
struct coro;
|
33
|
+
|
34
|
+
namespace detail {
|
35
|
+
|
36
|
+
template <typename Signature, typename Return, typename Executor>
|
37
|
+
struct coro_promise;
|
38
|
+
|
39
|
+
template <typename T>
|
40
|
+
struct is_noexcept : std::false_type
|
41
|
+
{
|
42
|
+
};
|
43
|
+
|
44
|
+
template <typename Return, typename... Args>
|
45
|
+
struct is_noexcept<Return(Args...)> : std::false_type
|
46
|
+
{
|
47
|
+
};
|
48
|
+
|
49
|
+
template <typename Return, typename... Args>
|
50
|
+
struct is_noexcept<Return(Args...) noexcept> : std::true_type
|
51
|
+
{
|
52
|
+
};
|
53
|
+
|
54
|
+
template <typename T>
|
55
|
+
constexpr bool is_noexcept_v = is_noexcept<T>::value;
|
56
|
+
|
57
|
+
template <typename T>
|
58
|
+
struct coro_error;
|
59
|
+
|
60
|
+
template <>
|
61
|
+
struct coro_error<boost::system::error_code>
|
62
|
+
{
|
63
|
+
static boost::system::error_code invalid()
|
64
|
+
{
|
65
|
+
return error::fault;
|
66
|
+
}
|
67
|
+
|
68
|
+
static boost::system::error_code cancelled()
|
69
|
+
{
|
70
|
+
return error::operation_aborted;
|
71
|
+
}
|
72
|
+
|
73
|
+
static boost::system::error_code interrupted()
|
74
|
+
{
|
75
|
+
return error::interrupted;
|
76
|
+
}
|
77
|
+
|
78
|
+
static boost::system::error_code done()
|
79
|
+
{
|
80
|
+
return error::broken_pipe;
|
81
|
+
}
|
82
|
+
};
|
83
|
+
|
84
|
+
template <>
|
85
|
+
struct coro_error<std::exception_ptr>
|
86
|
+
{
|
87
|
+
static std::exception_ptr invalid()
|
88
|
+
{
|
89
|
+
return std::make_exception_ptr(
|
90
|
+
boost::system::system_error(
|
91
|
+
coro_error<boost::system::error_code>::invalid()));
|
92
|
+
}
|
93
|
+
|
94
|
+
static std::exception_ptr cancelled()
|
95
|
+
{
|
96
|
+
return std::make_exception_ptr(
|
97
|
+
boost::system::system_error(
|
98
|
+
coro_error<boost::system::error_code>::cancelled()));
|
99
|
+
}
|
100
|
+
|
101
|
+
static std::exception_ptr interrupted()
|
102
|
+
{
|
103
|
+
return std::make_exception_ptr(
|
104
|
+
boost::system::system_error(
|
105
|
+
coro_error<boost::system::error_code>::interrupted()));
|
106
|
+
}
|
107
|
+
|
108
|
+
static std::exception_ptr done()
|
109
|
+
{
|
110
|
+
return std::make_exception_ptr(
|
111
|
+
boost::system::system_error(
|
112
|
+
coro_error<boost::system::error_code>::done()));
|
113
|
+
}
|
114
|
+
};
|
115
|
+
|
116
|
+
template <typename T, typename Coroutine, typename = void>
|
117
|
+
struct coro_with_arg
|
118
|
+
{
|
119
|
+
using coro_t = Coroutine;
|
120
|
+
T value;
|
121
|
+
coro_t& coro;
|
122
|
+
|
123
|
+
struct awaitable_t
|
124
|
+
{
|
125
|
+
T value;
|
126
|
+
coro_t& coro;
|
127
|
+
|
128
|
+
constexpr static bool await_ready() { return false; }
|
129
|
+
|
130
|
+
template <typename Y, typename R, typename E>
|
131
|
+
auto await_suspend(coroutine_handle<coro_promise<Y, R, E>> h)
|
132
|
+
-> coroutine_handle<>
|
133
|
+
{
|
134
|
+
auto& hp = h.promise();
|
135
|
+
if (hp.get_executor() == coro.get_executor())
|
136
|
+
{
|
137
|
+
coro.coro_->awaited_from = h;
|
138
|
+
coro.coro_->reset_error();
|
139
|
+
coro.coro_->input_ = std::move(value);
|
140
|
+
struct cancel_handler
|
141
|
+
{
|
142
|
+
cancel_handler(coro_t& coro) : coro(coro.coro_) {}
|
143
|
+
|
144
|
+
typename coro_t::promise_type* coro;
|
145
|
+
|
146
|
+
void operator()(cancellation_type ct)
|
147
|
+
{
|
148
|
+
coro->cancel.signal.emit(ct);
|
149
|
+
}
|
150
|
+
};
|
151
|
+
|
152
|
+
hp.cancel.state.slot().template emplace<cancel_handler>(coro);
|
153
|
+
return coro.coro_->get_handle();
|
154
|
+
} else
|
155
|
+
{
|
156
|
+
coro.coro_->awaited_from =
|
157
|
+
dispatch_coroutine(hp.get_executor(), [h]() mutable
|
158
|
+
{ h.resume(); });
|
159
|
+
coro.coro_->reset_error();
|
160
|
+
coro.coro_->input_ = std::move(value);
|
161
|
+
|
162
|
+
struct cancel_handler
|
163
|
+
{
|
164
|
+
cancel_handler(E e, coro_t& coro) : e(e), coro(coro.coro_) {}
|
165
|
+
|
166
|
+
E e;
|
167
|
+
typename coro_t::promise_type* coro;
|
168
|
+
|
169
|
+
void operator()(cancellation_type ct)
|
170
|
+
{
|
171
|
+
boost::asio::dispatch(e,
|
172
|
+
[ct, p = coro]() mutable
|
173
|
+
{
|
174
|
+
p->cancel.signal.emit(ct);
|
175
|
+
});
|
176
|
+
}
|
177
|
+
};
|
178
|
+
|
179
|
+
hp.cancel.state.slot().template emplace<cancel_handler>(
|
180
|
+
coro.get_executor(), coro);
|
181
|
+
|
182
|
+
return dispatch_coroutine(
|
183
|
+
hp.get_executor(), [h]() mutable { h.resume(); });
|
184
|
+
}
|
185
|
+
|
186
|
+
}
|
187
|
+
|
188
|
+
auto await_resume() -> typename coro_t::result_type
|
189
|
+
{
|
190
|
+
coro.coro_->cancel.state.slot().clear();
|
191
|
+
coro.coro_->rethrow_if();
|
192
|
+
return std::move(coro.coro_->result_);
|
193
|
+
}
|
194
|
+
};
|
195
|
+
|
196
|
+
template <typename CompletionToken>
|
197
|
+
auto async_resume(CompletionToken&& token) &&
|
198
|
+
{
|
199
|
+
return coro.async_resume(std::move(value),
|
200
|
+
std::forward<CompletionToken>(token));
|
201
|
+
}
|
202
|
+
|
203
|
+
auto operator co_await() &&
|
204
|
+
{
|
205
|
+
return awaitable_t{std::move(value), coro};
|
206
|
+
}
|
207
|
+
};
|
208
|
+
|
209
|
+
} // namespace detail
|
210
|
+
|
211
|
+
template <typename Yield = void, typename Return = void,
|
212
|
+
typename Executor = any_io_executor>
|
213
|
+
struct coro
|
214
|
+
{
|
215
|
+
using traits = detail::coro_traits<Yield, Return, Executor>;
|
216
|
+
|
217
|
+
using input_type = typename traits::input_type;
|
218
|
+
using yield_type = typename traits::yield_type;
|
219
|
+
using return_type = typename traits::return_type;
|
220
|
+
using error_type = typename traits::error_type;
|
221
|
+
using result_type = typename traits::result_type;
|
222
|
+
constexpr static bool is_noexcept = traits::is_noexcept;
|
223
|
+
|
224
|
+
using promise_type = detail::coro_promise<Yield, Return, Executor>;
|
225
|
+
|
226
|
+
#if !defined(GENERATING_DOCUMENTATION)
|
227
|
+
template <typename T, typename Coroutine, typename>
|
228
|
+
friend struct detail::coro_with_arg;
|
229
|
+
#endif // !defined(GENERATING_DOCUMENTATION)
|
230
|
+
|
231
|
+
using executor_type = Executor;
|
232
|
+
|
233
|
+
#if !defined(GENERATING_DOCUMENTATION)
|
234
|
+
friend struct detail::coro_promise<Yield, Return, Executor>;
|
235
|
+
#endif // !defined(GENERATING_DOCUMENTATION)
|
236
|
+
|
237
|
+
coro() = default;
|
238
|
+
|
239
|
+
coro(coro&& lhs) noexcept
|
240
|
+
: coro_(std::exchange(lhs.coro_, nullptr))
|
241
|
+
{
|
242
|
+
}
|
243
|
+
|
244
|
+
coro(const coro &) = delete;
|
245
|
+
|
246
|
+
coro& operator=(coro&& lhs) noexcept
|
247
|
+
{
|
248
|
+
std::swap(coro_, lhs.coro_);
|
249
|
+
return *this;
|
250
|
+
}
|
251
|
+
|
252
|
+
coro& operator=(const coro&) = delete;
|
253
|
+
|
254
|
+
~coro()
|
255
|
+
{
|
256
|
+
if (coro_ != nullptr)
|
257
|
+
{
|
258
|
+
struct destroyer
|
259
|
+
{
|
260
|
+
detail::coroutine_handle<promise_type> handle;
|
261
|
+
|
262
|
+
destroyer(const detail::coroutine_handle<promise_type>& handle)
|
263
|
+
: handle(handle)
|
264
|
+
{
|
265
|
+
}
|
266
|
+
|
267
|
+
destroyer(destroyer&& lhs)
|
268
|
+
: handle(std::exchange(lhs.handle, nullptr))
|
269
|
+
{
|
270
|
+
}
|
271
|
+
|
272
|
+
destroyer(const destroyer&) = delete;
|
273
|
+
|
274
|
+
void operator()() {}
|
275
|
+
|
276
|
+
~destroyer()
|
277
|
+
{
|
278
|
+
if (handle)
|
279
|
+
handle.destroy();
|
280
|
+
}
|
281
|
+
};
|
282
|
+
|
283
|
+
auto handle =
|
284
|
+
detail::coroutine_handle<promise_type>::from_promise(*coro_);
|
285
|
+
if (handle)
|
286
|
+
boost::asio::dispatch(coro_->get_executor(), destroyer{handle});
|
287
|
+
}
|
288
|
+
}
|
289
|
+
|
290
|
+
executor_type get_executor() const
|
291
|
+
{
|
292
|
+
if (coro_)
|
293
|
+
return coro_->get_executor();
|
294
|
+
|
295
|
+
if constexpr (std::is_default_constructible_v<Executor>)
|
296
|
+
return Executor{};
|
297
|
+
else
|
298
|
+
throw std::logic_error("Coroutine has no executor");
|
299
|
+
}
|
300
|
+
|
301
|
+
template <typename CompletionToken>
|
302
|
+
requires std::is_void_v<input_type>
|
303
|
+
auto async_resume(CompletionToken&& token)
|
304
|
+
{
|
305
|
+
return async_initiate<CompletionToken,
|
306
|
+
typename traits::completion_handler>(
|
307
|
+
initiate_async_resume(this), token);
|
308
|
+
}
|
309
|
+
|
310
|
+
|
311
|
+
template <typename CompletionToken, detail::convertible_to<input_type> T>
|
312
|
+
auto async_resume(T&& ip, CompletionToken&& token)
|
313
|
+
{
|
314
|
+
return async_initiate<CompletionToken,
|
315
|
+
typename traits::completion_handler>(
|
316
|
+
initiate_async_resume(this), token, std::forward<T>(ip));
|
317
|
+
}
|
318
|
+
|
319
|
+
auto operator co_await() requires (std::is_void_v<input_type>)
|
320
|
+
{
|
321
|
+
return awaitable_t{*this};
|
322
|
+
}
|
323
|
+
|
324
|
+
template <detail::convertible_to<input_type> T>
|
325
|
+
auto operator()(T&& ip)
|
326
|
+
{
|
327
|
+
return detail::coro_with_arg<std::decay_t<T>, coro>{
|
328
|
+
std::forward<T>(ip), *this};
|
329
|
+
}
|
330
|
+
|
331
|
+
bool is_open() const
|
332
|
+
{
|
333
|
+
if (coro_)
|
334
|
+
{
|
335
|
+
auto handle =
|
336
|
+
detail::coroutine_handle<promise_type>::from_promise(*coro_);
|
337
|
+
return handle && !handle.done();
|
338
|
+
}
|
339
|
+
else
|
340
|
+
return false;
|
341
|
+
}
|
342
|
+
|
343
|
+
explicit operator bool() const { return is_open(); }
|
344
|
+
|
345
|
+
void cancel(cancellation_type ct = cancellation_type::all)
|
346
|
+
{
|
347
|
+
if (is_open() && !coro_->cancel.state.cancelled())
|
348
|
+
boost::asio::dispatch(get_executor(),
|
349
|
+
[ct, coro = coro_] { coro->cancel.signal.emit(ct); });
|
350
|
+
}
|
351
|
+
|
352
|
+
private:
|
353
|
+
struct awaitable_t
|
354
|
+
{
|
355
|
+
coro& coro_;
|
356
|
+
|
357
|
+
constexpr static bool await_ready() { return false; }
|
358
|
+
|
359
|
+
template <typename Y, typename R, typename E>
|
360
|
+
auto await_suspend(
|
361
|
+
detail::coroutine_handle<detail::coro_promise<Y, R, E>> h)
|
362
|
+
-> detail::coroutine_handle<>
|
363
|
+
{
|
364
|
+
auto& hp = h.promise();
|
365
|
+
if (hp.get_executor() == coro_.get_executor())
|
366
|
+
{
|
367
|
+
coro_.coro_->awaited_from = h;
|
368
|
+
coro_.coro_->reset_error();
|
369
|
+
|
370
|
+
struct cancel_handler
|
371
|
+
{
|
372
|
+
cancel_handler(coro& coro_) : coro_(coro_.coro_) {}
|
373
|
+
|
374
|
+
typename coro::promise_type* coro_;
|
375
|
+
|
376
|
+
void operator()(cancellation_type ct)
|
377
|
+
{
|
378
|
+
coro_->cancel.signal.emit(ct);
|
379
|
+
}
|
380
|
+
};
|
381
|
+
|
382
|
+
hp.cancel.state.slot().template emplace<cancel_handler>(coro_);
|
383
|
+
return coro_.coro_->get_handle();
|
384
|
+
}
|
385
|
+
else
|
386
|
+
{
|
387
|
+
coro_.coro_->awaited_from = detail::dispatch_coroutine(
|
388
|
+
hp.get_executor(), [h]() mutable { h.resume(); });
|
389
|
+
coro_.coro_->reset_error();
|
390
|
+
|
391
|
+
struct cancel_handler
|
392
|
+
{
|
393
|
+
cancel_handler(E e, coro& coro) : e(e), coro_(coro.coro_) {}
|
394
|
+
|
395
|
+
E e;
|
396
|
+
typename coro::promise_type* coro_;
|
397
|
+
|
398
|
+
void operator()(cancellation_type ct)
|
399
|
+
{
|
400
|
+
boost::asio::dispatch(e,
|
401
|
+
[ct, p = coro_]() mutable
|
402
|
+
{
|
403
|
+
p->cancel.signal.emit(ct);
|
404
|
+
});
|
405
|
+
}
|
406
|
+
};
|
407
|
+
|
408
|
+
hp.cancel.state.slot().template emplace<cancel_handler>(
|
409
|
+
coro_.get_executor(), coro_);
|
410
|
+
|
411
|
+
return detail::dispatch_coroutine(
|
412
|
+
hp.get_executor(), [h]() mutable { h.resume(); });
|
413
|
+
}
|
414
|
+
}
|
415
|
+
|
416
|
+
auto await_resume() -> result_type
|
417
|
+
{
|
418
|
+
coro_.coro_->cancel.state.slot().clear();
|
419
|
+
coro_.coro_->rethrow_if();
|
420
|
+
if constexpr (!std::is_void_v<result_type>)
|
421
|
+
return std::move(coro_.coro_->result_);
|
422
|
+
}
|
423
|
+
};
|
424
|
+
|
425
|
+
class initiate_async_resume
|
426
|
+
{
|
427
|
+
public:
|
428
|
+
typedef Executor executor_type;
|
429
|
+
|
430
|
+
explicit initiate_async_resume(coro* self)
|
431
|
+
: self_(self)
|
432
|
+
{
|
433
|
+
}
|
434
|
+
|
435
|
+
executor_type get_executor() const noexcept
|
436
|
+
{
|
437
|
+
return self_->get_executor();
|
438
|
+
}
|
439
|
+
|
440
|
+
template <typename E, typename WaitHandler>
|
441
|
+
auto handle(E exec, WaitHandler&& handler,
|
442
|
+
std::true_type /* error is noexcept */,
|
443
|
+
std::true_type /* result is void */) const //noexcept
|
444
|
+
{
|
445
|
+
return [self = self_,
|
446
|
+
h = std::forward<WaitHandler>(handler),
|
447
|
+
exec = std::move(exec)]() mutable
|
448
|
+
{
|
449
|
+
assert(self);
|
450
|
+
auto ch =
|
451
|
+
detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
|
452
|
+
assert(ch && !ch.done());
|
453
|
+
assert(self->coro_->awaited_from == detail::noop_coroutine());
|
454
|
+
|
455
|
+
self->coro_->awaited_from =
|
456
|
+
post_coroutine(std::move(exec), std::move(h));
|
457
|
+
self->coro_->reset_error();
|
458
|
+
ch.resume();
|
459
|
+
};
|
460
|
+
}
|
461
|
+
|
462
|
+
template <typename E, typename WaitHandler>
|
463
|
+
requires (!std::is_void_v<result_type>)
|
464
|
+
auto handle(E exec, WaitHandler&& handler,
|
465
|
+
std::true_type /* error is noexcept */,
|
466
|
+
std::false_type /* result is void */) const //noexcept
|
467
|
+
{
|
468
|
+
return [self = self_,
|
469
|
+
h = std::forward<WaitHandler>(handler),
|
470
|
+
exec = std::move(exec)]() mutable
|
471
|
+
{
|
472
|
+
assert(self);
|
473
|
+
|
474
|
+
auto ch =
|
475
|
+
detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
|
476
|
+
assert(ch && !ch.done());
|
477
|
+
assert(self->coro_->awaited_from == detail::noop_coroutine());
|
478
|
+
|
479
|
+
self->coro_->awaited_from =
|
480
|
+
detail::post_coroutine(exec,
|
481
|
+
[self, h = std::move(h)]() mutable
|
482
|
+
{
|
483
|
+
std::move(h)(std::move(self->coro_->result_));
|
484
|
+
});
|
485
|
+
self->coro_->reset_error();
|
486
|
+
ch.resume();
|
487
|
+
};
|
488
|
+
}
|
489
|
+
|
490
|
+
template <typename E, typename WaitHandler>
|
491
|
+
auto handle(E exec, WaitHandler&& handler,
|
492
|
+
std::false_type /* error is noexcept */,
|
493
|
+
std::true_type /* result is void */) const
|
494
|
+
{
|
495
|
+
return [self = self_,
|
496
|
+
h = std::forward<WaitHandler>(handler),
|
497
|
+
exec = std::move(exec)]() mutable
|
498
|
+
{
|
499
|
+
if (!self)
|
500
|
+
{
|
501
|
+
boost::asio::post(exec,
|
502
|
+
[h = std::move(h)]() mutable
|
503
|
+
{
|
504
|
+
h(detail::coro_error<error_type>::invalid());
|
505
|
+
});
|
506
|
+
return;
|
507
|
+
}
|
508
|
+
|
509
|
+
auto ch =
|
510
|
+
detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
|
511
|
+
if (!ch)
|
512
|
+
{
|
513
|
+
boost::asio::post(exec,
|
514
|
+
[h = std::move(h)]() mutable
|
515
|
+
{
|
516
|
+
h(detail::coro_error<error_type>::invalid());
|
517
|
+
});
|
518
|
+
}
|
519
|
+
else if (ch.done())
|
520
|
+
{
|
521
|
+
boost::asio::post(exec,
|
522
|
+
[h = std::move(h)]() mutable
|
523
|
+
{
|
524
|
+
h(detail::coro_error<error_type>::done());
|
525
|
+
});
|
526
|
+
}
|
527
|
+
else
|
528
|
+
{
|
529
|
+
assert(self->coro_->awaited_from == detail::noop_coroutine());
|
530
|
+
self->coro_->awaited_from =
|
531
|
+
detail::post_coroutine(exec,
|
532
|
+
[self, h = std::move(h)]() mutable
|
533
|
+
{
|
534
|
+
std::move(h)(std::move(self->coro_->error_));
|
535
|
+
});
|
536
|
+
self->coro_->reset_error();
|
537
|
+
ch.resume();
|
538
|
+
}
|
539
|
+
};
|
540
|
+
}
|
541
|
+
|
542
|
+
template <typename E, typename WaitHandler>
|
543
|
+
auto handle(E exec, WaitHandler&& handler,
|
544
|
+
std::false_type /* error is noexcept */,
|
545
|
+
std::false_type /* result is void */) const
|
546
|
+
{
|
547
|
+
return [self = self_, h = std::forward<WaitHandler>(handler),
|
548
|
+
exec = std::move(exec)]() mutable
|
549
|
+
{
|
550
|
+
if (!self)
|
551
|
+
{
|
552
|
+
boost::asio::post(exec,
|
553
|
+
[h = std::move(h)]() mutable
|
554
|
+
{
|
555
|
+
h(detail::coro_error<error_type>::invalid(), result_type{});
|
556
|
+
});
|
557
|
+
return;
|
558
|
+
}
|
559
|
+
|
560
|
+
auto ch =
|
561
|
+
detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
|
562
|
+
if (!ch)
|
563
|
+
{
|
564
|
+
boost::asio::post(exec,
|
565
|
+
[h = std::move(h)]() mutable
|
566
|
+
{
|
567
|
+
h(detail::coro_error<error_type>::invalid(), result_type{});
|
568
|
+
});
|
569
|
+
}
|
570
|
+
else if (ch.done())
|
571
|
+
{
|
572
|
+
boost::asio::post(exec,
|
573
|
+
[h = std::move(h)]() mutable
|
574
|
+
{
|
575
|
+
h(detail::coro_error<error_type>::done(), result_type{});
|
576
|
+
});
|
577
|
+
}
|
578
|
+
else
|
579
|
+
{
|
580
|
+
assert(self->coro_->awaited_from == detail::noop_coroutine());
|
581
|
+
self->coro_->awaited_from =
|
582
|
+
detail::post_coroutine(exec,
|
583
|
+
[h = std::move(h), self]() mutable
|
584
|
+
{
|
585
|
+
std::move(h)(std::move(self->coro_->error_),
|
586
|
+
std::move(self->coro_->result_));
|
587
|
+
});
|
588
|
+
self->coro_->reset_error();
|
589
|
+
ch.resume();
|
590
|
+
}
|
591
|
+
};
|
592
|
+
}
|
593
|
+
|
594
|
+
struct cancel_handler
|
595
|
+
{
|
596
|
+
promise_type* coro;
|
597
|
+
|
598
|
+
cancel_handler(promise_type* coro) : coro(coro) {}
|
599
|
+
|
600
|
+
void operator()(cancellation_type ct)
|
601
|
+
{
|
602
|
+
boost::asio::dispatch(coro->get_executor(),
|
603
|
+
[ct, k = coro] { k->cancel.signal.emit(ct); });
|
604
|
+
}
|
605
|
+
};
|
606
|
+
|
607
|
+
template <typename WaitHandler>
|
608
|
+
void operator()(WaitHandler&& handler) const
|
609
|
+
{
|
610
|
+
const auto exec =
|
611
|
+
boost::asio::prefer(
|
612
|
+
get_associated_executor(handler, get_executor()),
|
613
|
+
execution::outstanding_work.tracked);
|
614
|
+
|
615
|
+
using cancel_t = decltype(self_->coro_->cancel);
|
616
|
+
self_->coro_->cancel.~cancel_t();
|
617
|
+
new(&self_->coro_->cancel) cancel_t();
|
618
|
+
|
619
|
+
auto cancel = get_associated_cancellation_slot(handler);
|
620
|
+
if (cancel.is_connected())
|
621
|
+
cancel.template emplace<cancel_handler>(self_->coro_);
|
622
|
+
|
623
|
+
boost::asio::dispatch(get_executor(),
|
624
|
+
handle(exec, std::forward<WaitHandler>(handler),
|
625
|
+
std::integral_constant<bool, is_noexcept>{},
|
626
|
+
std::is_void<result_type>{}));
|
627
|
+
}
|
628
|
+
|
629
|
+
template <typename WaitHandler, typename Input>
|
630
|
+
void operator()(WaitHandler&& handler, Input&& input) const
|
631
|
+
{
|
632
|
+
const auto exec =
|
633
|
+
boost::asio::prefer(
|
634
|
+
get_associated_executor(handler, get_executor()),
|
635
|
+
execution::outstanding_work.tracked);
|
636
|
+
auto cancel = get_associated_cancellation_slot(handler);
|
637
|
+
|
638
|
+
using cancel_t = decltype(self_->coro_->cancel);
|
639
|
+
self_->coro_->cancel.~cancel_t();
|
640
|
+
new(&self_->coro_->cancel) cancel_t();
|
641
|
+
|
642
|
+
if (cancel.is_connected())
|
643
|
+
cancel.template emplace<cancel_handler>(self_->coro_);
|
644
|
+
|
645
|
+
boost::asio::dispatch(get_executor(),
|
646
|
+
[h = handle(exec, std::forward<WaitHandler>(handler),
|
647
|
+
std::integral_constant<bool, is_noexcept>{},
|
648
|
+
std::is_void<result_type>{}),
|
649
|
+
in = std::forward<Input>(input), self = self_]() mutable
|
650
|
+
{
|
651
|
+
self->coro_->input_ = std::move(in);
|
652
|
+
std::move(h)();
|
653
|
+
});
|
654
|
+
}
|
655
|
+
|
656
|
+
private:
|
657
|
+
coro* self_;
|
658
|
+
};
|
659
|
+
|
660
|
+
explicit coro(promise_type* const cr) : coro_(cr) {}
|
661
|
+
|
662
|
+
promise_type* coro_{nullptr};
|
663
|
+
};
|
664
|
+
|
665
|
+
namespace detail {
|
666
|
+
|
667
|
+
template <bool IsNoexcept>
|
668
|
+
struct coro_promise_error;
|
669
|
+
|
670
|
+
template <>
|
671
|
+
struct coro_promise_error<false>
|
672
|
+
{
|
673
|
+
std::exception_ptr error_;
|
674
|
+
|
675
|
+
void reset_error() { error_ = std::exception_ptr{}; }
|
676
|
+
|
677
|
+
void unhandled_exception() { error_ = std::current_exception(); }
|
678
|
+
|
679
|
+
void rethrow_if()
|
680
|
+
{
|
681
|
+
if (error_)
|
682
|
+
std::rethrow_exception(error_);
|
683
|
+
}
|
684
|
+
};
|
685
|
+
|
686
|
+
template <>
|
687
|
+
struct coro_promise_error<true>
|
688
|
+
{
|
689
|
+
void reset_error() {}
|
690
|
+
|
691
|
+
void unhandled_exception() noexcept { throw; }
|
692
|
+
|
693
|
+
void rethrow_if() {}
|
694
|
+
};
|
695
|
+
|
696
|
+
template <typename T = void>
|
697
|
+
struct yield_input
|
698
|
+
{
|
699
|
+
T& value;
|
700
|
+
coroutine_handle<> awaited_from{noop_coroutine()};
|
701
|
+
|
702
|
+
bool await_ready() const noexcept
|
703
|
+
{
|
704
|
+
return false;
|
705
|
+
}
|
706
|
+
|
707
|
+
auto await_suspend(coroutine_handle<>) noexcept
|
708
|
+
{
|
709
|
+
return std::exchange(awaited_from, noop_coroutine());
|
710
|
+
}
|
711
|
+
|
712
|
+
T await_resume() const noexcept { return std::move(value); }
|
713
|
+
};
|
714
|
+
|
715
|
+
template <>
|
716
|
+
struct yield_input<void>
|
717
|
+
{
|
718
|
+
coroutine_handle<> awaited_from{noop_coroutine()};
|
719
|
+
|
720
|
+
bool await_ready() const noexcept
|
721
|
+
{
|
722
|
+
return false;
|
723
|
+
}
|
724
|
+
|
725
|
+
auto await_suspend(coroutine_handle<>) noexcept
|
726
|
+
{
|
727
|
+
return std::exchange(awaited_from, noop_coroutine());
|
728
|
+
}
|
729
|
+
|
730
|
+
constexpr void await_resume() const noexcept {}
|
731
|
+
};
|
732
|
+
|
733
|
+
struct coro_awaited_from
|
734
|
+
{
|
735
|
+
coroutine_handle<> awaited_from{noop_coroutine()};
|
736
|
+
|
737
|
+
auto final_suspend() noexcept
|
738
|
+
{
|
739
|
+
struct suspendor
|
740
|
+
{
|
741
|
+
coroutine_handle<> awaited_from;
|
742
|
+
|
743
|
+
constexpr static bool await_ready() noexcept { return false; }
|
744
|
+
|
745
|
+
auto await_suspend(coroutine_handle<>) noexcept
|
746
|
+
{
|
747
|
+
return std::exchange(awaited_from, noop_coroutine());
|
748
|
+
}
|
749
|
+
|
750
|
+
constexpr static void await_resume() noexcept {}
|
751
|
+
};
|
752
|
+
|
753
|
+
return suspendor{std::exchange(awaited_from, noop_coroutine())};
|
754
|
+
}
|
755
|
+
|
756
|
+
~coro_awaited_from()
|
757
|
+
{
|
758
|
+
awaited_from.resume();
|
759
|
+
}//must be on the right executor
|
760
|
+
};
|
761
|
+
|
762
|
+
template <typename Yield, typename Input, typename Return>
|
763
|
+
struct coro_promise_exchange : coro_awaited_from
|
764
|
+
{
|
765
|
+
using result_type = coro_result_t<Yield, Return>;
|
766
|
+
|
767
|
+
result_type result_;
|
768
|
+
Input input_;
|
769
|
+
|
770
|
+
auto yield_value(Yield&& y)
|
771
|
+
{
|
772
|
+
result_ = std::move(y);
|
773
|
+
return yield_input<Input>{std::move(input_),
|
774
|
+
std::exchange(awaited_from, noop_coroutine())};
|
775
|
+
}
|
776
|
+
|
777
|
+
auto yield_value(const Yield& y)
|
778
|
+
{
|
779
|
+
result_ = y;
|
780
|
+
return yield_input<Input>{std::move(input_),
|
781
|
+
std::exchange(awaited_from, noop_coroutine())};
|
782
|
+
}
|
783
|
+
|
784
|
+
void return_value(const Return& r) { result_ = r; }
|
785
|
+
|
786
|
+
void return_value(Return&& r) { result_ = std::move(r); }
|
787
|
+
};
|
788
|
+
|
789
|
+
template <typename YieldReturn>
|
790
|
+
struct coro_promise_exchange<YieldReturn, void, YieldReturn> : coro_awaited_from
|
791
|
+
{
|
792
|
+
using result_type = coro_result_t<YieldReturn, YieldReturn>;
|
793
|
+
|
794
|
+
result_type result_;
|
795
|
+
|
796
|
+
auto yield_value(const YieldReturn& y)
|
797
|
+
{
|
798
|
+
result_ = y;
|
799
|
+
return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
|
800
|
+
}
|
801
|
+
|
802
|
+
auto yield_value(YieldReturn&& y)
|
803
|
+
{
|
804
|
+
result_ = std::move(y);
|
805
|
+
return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
|
806
|
+
}
|
807
|
+
|
808
|
+
void return_value(const YieldReturn& r) { result_ = r; }
|
809
|
+
|
810
|
+
void return_value(YieldReturn&& r) { result_ = std::move(r); }
|
811
|
+
};
|
812
|
+
|
813
|
+
template <typename Yield, typename Return>
|
814
|
+
struct coro_promise_exchange<Yield, void, Return> : coro_awaited_from
|
815
|
+
{
|
816
|
+
using result_type = coro_result_t<Yield, Return>;
|
817
|
+
|
818
|
+
result_type result_;
|
819
|
+
|
820
|
+
auto yield_value(const Yield& y)
|
821
|
+
{
|
822
|
+
result_.template emplace<0>(y);
|
823
|
+
return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
|
824
|
+
}
|
825
|
+
|
826
|
+
auto yield_value(Yield&& y)
|
827
|
+
{
|
828
|
+
result_.template emplace<0>(std::move(y));
|
829
|
+
return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
|
830
|
+
}
|
831
|
+
|
832
|
+
void return_value(const Return& r)
|
833
|
+
{ result_.template emplace<1>(r); }
|
834
|
+
|
835
|
+
void return_value(Return&& r)
|
836
|
+
{ result_.template emplace<1>(std::move(r)); }
|
837
|
+
};
|
838
|
+
|
839
|
+
template <typename Yield, typename Input>
|
840
|
+
struct coro_promise_exchange<Yield, Input, void> : coro_awaited_from
|
841
|
+
{
|
842
|
+
using result_type = coro_result_t<Yield, void>;
|
843
|
+
|
844
|
+
result_type result_;
|
845
|
+
Input input_;
|
846
|
+
|
847
|
+
auto yield_value(Yield&& y)
|
848
|
+
{
|
849
|
+
result_ = std::move(y);
|
850
|
+
return yield_input<Input>{input_,
|
851
|
+
std::exchange(awaited_from, noop_coroutine())};
|
852
|
+
}
|
853
|
+
|
854
|
+
auto yield_value(const Yield& y)
|
855
|
+
{
|
856
|
+
result_ = y;
|
857
|
+
return yield_input<Input>{input_,
|
858
|
+
std::exchange(awaited_from, noop_coroutine())};
|
859
|
+
}
|
860
|
+
|
861
|
+
void return_void() { result_.reset(); }
|
862
|
+
};
|
863
|
+
|
864
|
+
template <typename Return>
|
865
|
+
struct coro_promise_exchange<void, void, Return> : coro_awaited_from
|
866
|
+
{
|
867
|
+
using result_type = coro_result_t<void, Return>;
|
868
|
+
|
869
|
+
result_type result_;
|
870
|
+
|
871
|
+
void yield_value();
|
872
|
+
|
873
|
+
void return_value(const Return& r) { result_ = r; }
|
874
|
+
|
875
|
+
void return_value(Return&& r) { result_ = std::move(r); }
|
876
|
+
};
|
877
|
+
|
878
|
+
|
879
|
+
template <>
|
880
|
+
struct coro_promise_exchange<void, void, void> : coro_awaited_from
|
881
|
+
{
|
882
|
+
void return_void() {}
|
883
|
+
|
884
|
+
void yield_value();
|
885
|
+
};
|
886
|
+
|
887
|
+
template <typename Yield>
|
888
|
+
struct coro_promise_exchange<Yield, void, void> : coro_awaited_from
|
889
|
+
{
|
890
|
+
using result_type = coro_result_t<Yield, void>;
|
891
|
+
|
892
|
+
result_type result_;
|
893
|
+
|
894
|
+
auto yield_value(const Yield& y)
|
895
|
+
{
|
896
|
+
result_ = y;
|
897
|
+
return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
|
898
|
+
}
|
899
|
+
|
900
|
+
auto yield_value(Yield&& y)
|
901
|
+
{
|
902
|
+
result_ = std::move(y);
|
903
|
+
return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
|
904
|
+
}
|
905
|
+
|
906
|
+
void return_void() { result_.reset(); }
|
907
|
+
};
|
908
|
+
|
909
|
+
template <typename Yield, typename Return, typename Executor>
|
910
|
+
struct coro_promise final :
|
911
|
+
coro_promise_allocator<coro<Yield, Return, Executor>>,
|
912
|
+
coro_promise_error<coro_traits<Yield, Return, Executor>::is_noexcept>,
|
913
|
+
coro_promise_exchange<
|
914
|
+
typename coro_traits<Yield, Return, Executor>::yield_type,
|
915
|
+
typename coro_traits<Yield, Return, Executor>::input_type,
|
916
|
+
typename coro_traits<Yield, Return, Executor>::return_type>
|
917
|
+
{
|
918
|
+
using coro_type = coro<Yield, Return, Executor>;
|
919
|
+
|
920
|
+
auto handle()
|
921
|
+
{ return coroutine_handle<coro_promise>::from_promise(this); }
|
922
|
+
|
923
|
+
using executor_type = Executor;
|
924
|
+
|
925
|
+
executor_type executor_;
|
926
|
+
struct cancel_pair
|
927
|
+
{
|
928
|
+
cancellation_signal signal;
|
929
|
+
boost::asio::cancellation_state state{signal.slot()};
|
930
|
+
|
931
|
+
};
|
932
|
+
cancel_pair cancel;
|
933
|
+
|
934
|
+
using allocator_type =
|
935
|
+
typename std::allocator_traits<associated_allocator_t < Executor>>::
|
936
|
+
template rebind_alloc<std::byte>;
|
937
|
+
using traits = coro_traits<Yield, Return, Executor>;
|
938
|
+
|
939
|
+
using input_type = typename traits::input_type;
|
940
|
+
using yield_type = typename traits::yield_type;
|
941
|
+
using return_type = typename traits::return_type;
|
942
|
+
using error_type = typename traits::error_type;
|
943
|
+
using result_type = typename traits::result_type;
|
944
|
+
constexpr static bool is_noexcept = traits::is_noexcept;
|
945
|
+
|
946
|
+
auto get_executor() const -> Executor { return executor_; }
|
947
|
+
|
948
|
+
auto get_handle()
|
949
|
+
{
|
950
|
+
return coroutine_handle<coro_promise>::from_promise(*this);
|
951
|
+
}
|
952
|
+
|
953
|
+
template <typename... Args>
|
954
|
+
coro_promise(Executor executor, Args &&...) noexcept
|
955
|
+
: executor_(std::move(executor))
|
956
|
+
{
|
957
|
+
}
|
958
|
+
|
959
|
+
template <execution_context Context, typename... Args>
|
960
|
+
coro_promise(Context&& ctx, Args&&...) noexcept
|
961
|
+
: executor_(ctx.get_executor())
|
962
|
+
{
|
963
|
+
}
|
964
|
+
|
965
|
+
auto get_return_object()
|
966
|
+
{
|
967
|
+
return coro<Yield, Return, Executor>{this};
|
968
|
+
}
|
969
|
+
|
970
|
+
auto initial_suspend() noexcept
|
971
|
+
{
|
972
|
+
return suspend_always{};
|
973
|
+
}
|
974
|
+
|
975
|
+
using coro_promise_exchange<
|
976
|
+
typename coro_traits<Yield, Return, Executor>::yield_type,
|
977
|
+
typename coro_traits<Yield, Return, Executor>::input_type,
|
978
|
+
typename coro_traits<Yield, Return, Executor>::return_type>::yield_value;
|
979
|
+
|
980
|
+
auto await_transform(this_coro::executor_t) const
|
981
|
+
{
|
982
|
+
struct exec_helper
|
983
|
+
{
|
984
|
+
const executor_type& value;
|
985
|
+
|
986
|
+
constexpr static bool await_ready() noexcept { return true; }
|
987
|
+
|
988
|
+
constexpr static void await_suspend(coroutine_handle<>) noexcept {}
|
989
|
+
|
990
|
+
executor_type await_resume() const noexcept { return value; }
|
991
|
+
};
|
992
|
+
|
993
|
+
return exec_helper{executor_};
|
994
|
+
}
|
995
|
+
|
996
|
+
auto await_transform(this_coro::cancellation_state_t) const
|
997
|
+
{
|
998
|
+
struct exec_helper
|
999
|
+
{
|
1000
|
+
const boost::asio::cancellation_state& value;
|
1001
|
+
|
1002
|
+
constexpr static bool await_ready() noexcept { return true; }
|
1003
|
+
|
1004
|
+
constexpr static void await_suspend(coroutine_handle<>) noexcept {}
|
1005
|
+
|
1006
|
+
const boost::asio::cancellation_state& await_resume() const noexcept
|
1007
|
+
{
|
1008
|
+
return value;
|
1009
|
+
}
|
1010
|
+
};
|
1011
|
+
|
1012
|
+
return exec_helper{cancel.state};
|
1013
|
+
}
|
1014
|
+
|
1015
|
+
template <typename Yield_, typename Return_, typename Executor_>
|
1016
|
+
auto await_transform(coro<Yield_, Return_, Executor_>& kr) -> decltype(auto)
|
1017
|
+
{
|
1018
|
+
return kr;
|
1019
|
+
}
|
1020
|
+
|
1021
|
+
template <typename Yield_, typename Return_, typename Executor_>
|
1022
|
+
auto await_transform(coro<Yield_, Return_, Executor_>&& kr)
|
1023
|
+
{
|
1024
|
+
return std::move(kr);
|
1025
|
+
}
|
1026
|
+
|
1027
|
+
template <typename T_, typename Coroutine>
|
1028
|
+
auto await_transform(coro_with_arg<T_, Coroutine>&& kr) -> decltype(auto)
|
1029
|
+
{
|
1030
|
+
return std::move(kr);
|
1031
|
+
}
|
1032
|
+
|
1033
|
+
template <typename T_>
|
1034
|
+
requires requires(T_ t) {{ t.async_wait(use_coro) }; }
|
1035
|
+
auto await_transform(T_ &t) -> decltype(auto)
|
1036
|
+
{
|
1037
|
+
return await_transform(t.async_wait(use_coro));
|
1038
|
+
}
|
1039
|
+
|
1040
|
+
template <typename... Ts>
|
1041
|
+
auto await_transform(coro_init_handler<Executor, Ts...>&& kr) const
|
1042
|
+
{
|
1043
|
+
if constexpr (is_noexcept)
|
1044
|
+
return std::move(kr).as_noexcept(cancel.state.slot());
|
1045
|
+
else
|
1046
|
+
return std::move(kr).as_throwing(cancel.state.slot());
|
1047
|
+
}
|
1048
|
+
};
|
1049
|
+
|
1050
|
+
} // namespace detail
|
1051
|
+
} // namespace experimental
|
1052
|
+
} // namespace asio
|
1053
|
+
} // namespace boost
|
1054
|
+
|
1055
|
+
#include <boost/asio/detail/pop_options.hpp>
|
1056
|
+
|
1057
|
+
#endif // BOOST_ASIO_EXPERIMENTAL_CORO_HPP
|