diff --git a/.clang-uml b/.clang-uml new file mode 100644 index 0000000000..b4dff783a7 --- /dev/null +++ b/.clang-uml @@ -0,0 +1,51 @@ +compilation_database_dir: ./build +output_directory: ./docs/diagrams +diagrams: + boost_asio: + type: class + generate_method_arguments: none + include_relations_also_as_members: false + glob: + - example/cpp11/http/server/server.cpp + using_namespace: + - boost::asio + include: + namespaces: + - boost::asio + exclude: + namespaces: + - http::server + - std + - boost::asio::detail + - boost::asio::buffer_literals::detail + - boost::asio::execution::detail + - boost::asio::experimental::detail + - boost::asio::impl + - boost::asio::executor::impl + - boost::asio::ip::detail + - boost::asio::posix + - boost::asio::traits + - boost::beast + - boost::redis + elements: + - boost::asio::associator + - boost::asio::async_result + - boost::asio::deferred_init_tag + - boost::asio::is_deferred + - boost::asio::traits::static_query + - boost::asio::is_applicable_property + + # Excluding these specializations unfortunately results in a crash of clang-uml + # specializations: + # - boost::asio::associator + # - boost::asio::associator + # - boost::asio::asyncresult + # - boost::asio::asyncresult + # - boost::asio::is_deferred + # - boost::asio::is_deferred + access: + - private + plantuml: + before: + - 'title Class Diagram for boost asio' + diff --git a/create_class_diagram.sh b/create_class_diagram.sh new file mode 100755 index 0000000000..0b09b1068f --- /dev/null +++ b/create_class_diagram.sh @@ -0,0 +1,19 @@ +# Expects the BOOST_ROOT environment variable to be set. + +# Get and build clang-uml: https://github.com/bkryza/clang-uml +# Expects the CLANG_UML environment variable to be set, containing the path to the clang-uml executable + +# Example: +# BOOST_ROOT=~/projects/boost CLANG_UML=~/projects/clang-uml/build/clang-uml ./create_class_diagram.sh + +mkdir -p example/cpp11/http/server/build +pushd example/cpp11/http/server/build +cmake .. -DCMAKE_EXPORT_COMPILE_COMMANDS=1 +make -j4 +popd + +${CLANG_UML} -c .clang-uml -d example/cpp11/http/server/build/compile_commands.json -o ./doc + +# Install plantuml & use it to convert to image format +# sudo apt install plantuml +plantuml ./doc/boost_asio.puml -tsvg diff --git a/doc/boost_asio.puml b/doc/boost_asio.puml new file mode 100644 index 0000000000..fd740a05d6 --- /dev/null +++ b/doc/boost_asio.puml @@ -0,0 +1,3117 @@ +@startuml +title Class Diagram for boost asio +class "aligned_storage" as C_0000579592779670012332 +class C_0000579592779670012332 { +} +class "aligned_storage::type" as C_0002110400422178108755 +class C_0002110400422178108755 { ++data : unsigned char [N] +} +class "remove_cvref" as C_0001987019697484329811 +class C_0001987019697484329811 { +} +class "void_type<>" as C_0001000103218164549947 +class C_0001000103218164549947 { +} +class "conjunction<...>" as C_0000753777493944093159 +class C_0000753777493944093159 { +} +class "conjunction" as C_0000296724516884520014 +class C_0000296724516884520014 { +} +class "conjunction" as C_0001041834930635121886 +class C_0001041834930635121886 { +} +class "conjunction" as C_0001684094058832511287 +class C_0001684094058832511287 { +} +class "defaulted_constraint" as C_0002086795079272478460 +class C_0002086795079272478460 { ++defaulted_constraint() : void +} +class "constraint<_Bool Condition,Type>" as C_0000576389164609867081 +class C_0000576389164609867081 { +} +class "execution::invocable_archetype" as C_0002268761606142125805 +class C_0002268761606142125805 { ++operator()() : void +} +class "execution::receiver_invocation_error" as C_0000972429552341426131 +class C_0000972429552341426131 { ++receiver_invocation_error() : void +} +class "execution::can_set_done" as C_0002082518388914266172 +class C_0002082518388914266172 { +} +class "execution::is_nothrow_set_done" as C_0001962000632127088146 +class C_0001962000632127088146 { +} +class "execution::can_set_error" as C_0000405303666802852631 +class C_0000405303666802852631 { +} +class "execution::is_nothrow_set_error" as C_0000045140933470815653 +class C_0000045140933470815653 { +} +class "execution::can_set_value" as C_0000389647355528027145 +class C_0000389647355528027145 { +} +class "execution::is_nothrow_set_value" as C_0001441722819273374224 +class C_0001441722819273374224 { +} +class "execution::can_execute" as C_0002119763767749626858 +class C_0002119763767749626858 { +} +class "execution::is_executor" as C_0002295839784929029914 +class C_0002295839784929029914 { +} +class "execution::is_executor_of" as C_0002144590037745486826 +class C_0002144590037745486826 { +} +class "execution::executor_shape" as C_0000445495203297773331 +class C_0000445495203297773331 { +} +class "execution::executor_index" as C_0001609874729614519265 +class C_0001609874729614519265 { +} +class "execution::can_schedule" as C_0000732418261509680155 +class C_0000732418261509680155 { +} +class "execution::is_nothrow_schedule" as C_0000067795948250504679 +class C_0000067795948250504679 { +} +class "execution::is_scheduler" as C_0000935905208951410413 +class C_0000935905208951410413 { +} +class "execution::is_receiver" as C_0000111106382659944809 +class C_0000111106382659944809 { +} +class "execution::is_receiver_of" as C_0001642894112610859064 +class C_0001642894112610859064 { +} +class "execution::is_nothrow_receiver_of" as C_0001181660369662644829 +class C_0001181660369662644829 { +} +class "execution::sender_traits" as C_0000004602000229436680 +class C_0000004602000229436680 { +} +class "execution::is_sender" as C_0001149225105691160543 +class C_0001149225105691160543 { +} +class "execution::is_sender_to" as C_0001381488724873157820 +class C_0001381488724873157820 { +} +class "execution::is_typed_sender" as C_0001738113620967102102 +class C_0001738113620967102102 { +} +class "execution::can_start" as C_0000967739045281501834 +class C_0000967739045281501834 { +} +class "execution::is_nothrow_start" as C_0001447801322838974785 +class C_0001447801322838974785 { +} +class "execution::is_operation_state" as C_0001585224038675902175 +class C_0001585224038675902175 { +} +class "execution::can_connect" as C_0001332409624746049559 +class C_0001332409624746049559 { +} +class "execution::is_nothrow_connect" as C_0001900795959504001078 +class C_0001900795959504001078 { +} +class "execution::connect_result" as C_0000590588717228504908 +class C_0000590588717228504908 { +} +class "execution::allocator_t" as C_0001919956248681364680 +class C_0001919956248681364680 { ++value() const : ProtoAllocator +{static} +is_requirable : const bool +{static} +is_preferable : const bool +} +class "execution::allocator_t::static_proxy" as C_0002178673844739850305 +class C_0002178673844739850305 { +} +class "execution::allocator_t::query_static_constexpr_member" as C_0002094325986805421920 +class C_0002094325986805421920 { +} +class "execution::allocator_t" as C_0000328240645697443049 +class C_0000328240645697443049 { ++allocator_t() : void ++operator()() : allocator_t +{static} +is_requirable : const bool +{static} +is_preferable : const bool +} +class "execution::allocator_t" as C_0001751898571735160462 +class C_0001751898571735160462 { ++allocator_t() : void ++operator()() : allocator_t +{static} +is_requirable : const bool +{static} +is_preferable : const bool +} +class "execution::bad_executor" as C_0002062081675072086182 +class C_0002062081675072086182 { ++bad_executor() : void ++what() const : const char * +} +class "execution::any_executor" as C_0001163808302553303505 +class C_0001163808302553303505 { ++any_executor() : void ++any_executor() : void ++any_executor() : void ++any_executor() : void ++operator=() : execution::any_executor<> & ++operator=() : execution::any_executor<> & ++any_executor() : void ++any_executor() : void ++operator=() : execution::any_executor<> & ++swap() : void ++equality_helper() const : bool ++any_executor() : void ++any_executor() : void ++any_executor() : void ++any_executor() : void +} +class "execution::any_executor" as C_0000352118411325380521 +class C_0000352118411325380521 { +} +class "execution::any_executor::find_convertible_property" as C_0001886574204218092814 +class C_0001886574204218092814 { +} +class "execution::any_executor::find_convertible_requirable_property" as C_0001232554361209982665 +class C_0001232554361209982665 { +} +class "execution::any_executor::find_convertible_preferable_property" as C_0001631490790111047121 +class C_0001631490790111047121 { +} +class "execution::can_bulk_execute" as C_0001980535949126915332 +class C_0001980535949126915332 { +} +class "execution::is_nothrow_bulk_execute" as C_0001474698393389523959 +class C_0001474698393389523959 { +} +class "execution::bulk_execute_result" as C_0001969029287527607370 +class C_0001969029287527607370 { +} +class "execution::context_as_t" as C_0002111739362956445069 +class C_0002111739362956445069 { ++context_as_t() : void ++context_as_t() : void +{static} +is_requirable : const bool +{static} +is_preferable : const bool +} +class "execution::prefer_only" as C_0002099617589394897753 +class C_0002099617589394897753 { ++prefer_only() : void +{static} +is_requirable : const bool +} +class "execution::can_submit" as C_0001917254621073297788 +class C_0001917254621073297788 { +} +class "execution::is_nothrow_submit" as C_0001228625026234348305 +class C_0001228625026234348305 { +} +class "execution::submit_result" as C_0000849094483816578277 +class C_0000849094483816578277 { +} +class "execution::is_executor" as C_0001262484639467907853 +class C_0001262484639467907853 { +} +class "execution::is_executor" as C_0000105945471770528204 +class C_0000105945471770528204 { +} +class "execution::is_executor" as C_0001620070496707355129 +class C_0001620070496707355129 { +} +class "execution::any_executor<...>" as C_0000958091182183117250 +class C_0000958091182183117250 { +} +class "execution::context_as_t" as C_0002080209979786011883 +class C_0002080209979786011883 { +} +class "multiple_exceptions" as C_0001264191542819817749 +class C_0001264191542819817749 { ++multiple_exceptions() : void ++what() const : const char * ++first_exception() const : std::exception_ptr +} +class "associated_allocator" as C_0001763862446001942345 +class C_0001763862446001942345 { +} +class "associated_allocator" as C_0001830365946563533489 +class C_0001830365946563533489 { +{static} +get() : associated_allocator,type-parameter-0-1>::type +{static} +get() : decltype(associated_allocator::get(t.get(),a)) +} +class "associated_allocator,type-parameter-0-1>" as C_0001333988438710426705 +class C_0001333988438710426705 { +{static} +get() : associated_allocator,type-parameter-0-1>::type +{static} +get() : decltype(associated_allocator::get(t.get(),a)) +} +class "can_prefer" as C_0002185418976218609686 +class C_0002185418976218609686 { +} +class "is_nothrow_prefer" as C_0001732291581700516551 +class C_0001732291581700516551 { +} +class "prefer_result" as C_0001333738625188322489 +class C_0001333738625188322489 { +} +class "can_query" as C_0001914587886529905881 +class C_0001914587886529905881 { +} +class "is_nothrow_query" as C_0001519501349843584133 +class C_0001519501349843584133 { +} +class "query_result" as C_0000132471295115447389 +class C_0000132471295115447389 { +} +class "can_require" as C_0001696722461684456340 +class C_0001696722461684456340 { +} +class "is_nothrow_require" as C_0002291828421873652752 +class C_0002291828421873652752 { +} +class "require_result" as C_0001279614435415410300 +class C_0001279614435415410300 { +} +enum "error::basic_errors" as C_0002147120332809299988 +enum C_0002147120332809299988 { +access_denied +address_family_not_supported +address_in_use +already_connected +already_started +broken_pipe +connection_aborted +connection_refused +connection_reset +bad_descriptor +fault +host_unreachable +in_progress +interrupted +invalid_argument +message_size +name_too_long +network_down +network_reset +network_unreachable +no_descriptors +no_buffer_space +no_memory +no_permission +no_protocol_option +no_such_device +not_connected +not_socket +operation_aborted +operation_not_supported +shut_down +timed_out +try_again +would_block +} +enum "error::netdb_errors" as C_0000925057522115825409 +enum C_0000925057522115825409 { +host_not_found +host_not_found_try_again +no_data +no_recovery +} +enum "error::addrinfo_errors" as C_0002162172288910256282 +enum C_0002162172288910256282 { +service_not_found +socket_type_not_supported +} +enum "error::misc_errors" as C_0002067309675921375731 +enum C_0002067309675921375731 { +already_open +eof +not_found +fd_set_failure +} +class "error::detail::netdb_category" as C_0000570278424444546455 +class C_0000570278424444546455 { ++name() const : const char * ++message() const : std::string +} +class "error::detail::addrinfo_category" as C_0000264153005272410604 +class C_0000264153005272410604 { ++name() const : const char * ++message() const : std::string +} +class "error::detail::misc_category" as C_0001534085128894270884 +class C_0001534085128894270884 { ++name() const : const char * ++message() const : std::string +} +class "any_completion_executor" as C_0002216123710377401285 +class C_0002216123710377401285 { ++any_completion_executor() : void ++any_completion_executor() : void ++any_completion_executor() : void ++any_completion_executor() : void ++any_completion_executor() : void ++any_completion_executor() : void ++operator=() : any_completion_executor & ++operator=() : any_completion_executor & ++operator=() : any_completion_executor & ++~any_completion_executor() : void ++swap() : void ++any_completion_executor() : void ++any_completion_executor() : void ++any_completion_executor() : void ++any_completion_executor() : void ++require() : class any_completion_executor ++prefer() : class any_completion_executor +} +enum "cancellation_type" as C_0000267097329498411292 +enum C_0000267097329498411292 { +none +terminal +partial +total +all +} +class "cancellation_signal" as C_0001075184824456831325 +class C_0001075184824456831325 { ++cancellation_signal() : void ++~cancellation_signal() : void ++emit() : void ++slot() : cancellation_slot +} +class "cancellation_slot" as C_0001060514151700537330 +class C_0001060514151700537330 { ++cancellation_slot() : void ++clear() : void ++is_connected() const : bool ++has_handler() const : bool ++emplace() : CancellationHandler & ++assign() : typename decay::type & +} +class "cancellation_slot::auto_delete_helper" as C_0000957743670870456570 +class C_0000957743670870456570 { ++~auto_delete_helper() : void ++mem : std::pair +} +class "associated_cancellation_slot" as C_0000532634720971459996 +class C_0000532634720971459996 { +} +class "associated_cancellation_slot" as C_0001005884597158528235 +class C_0001005884597158528235 { +{static} +get() : associated_cancellation_slot,type-parameter-0-1>::type +{static} +get() : decltype(associated_cancellation_slot::get(t.get(),s)) +} +class "associated_cancellation_slot,type-parameter-0-1>" as C_0000899286941696341228 +class C_0000899286941696341228 { +{static} +get() : associated_cancellation_slot,type-parameter-0-1>::type +{static} +get() : decltype(associated_cancellation_slot::get(t.get(),s)) +} +class "is_executor" as C_0000872970159060608462 +class C_0000872970159060608462 { +} +class "basic_system_executor" as C_0001884445244141597806 +class C_0001884445244141597806 { ++basic_system_executor() : void ++context() const : system_context & ++on_work_started() const : void ++on_work_finished() const : void ++execute() : void ++dispatch() : void ++post() : void ++defer() : void +} +class "execution_context" as C_0002065305983511051496 +class C_0002065305983511051496 { ++execution_context() : void ++~execution_context() : void +#shutdown() : void +#destroy() : void ++notify_fork() : void +} +enum "execution_context::fork_event" as C_0000695141153035704827 +enum C_0000695141153035704827 { +fork_prepare +fork_parent +fork_child +} +class "execution_context::id" as C_0002061865058505779735 +class C_0002061865058505779735 { ++id() : void +} +abstract "execution_context::service" as C_0002149874971759018197 +abstract C_0002149874971759018197 { ++context() : execution_context & +#service() : void +#~service() : void +} +class "execution_context::service::key" as C_0000707417393859856318 +class C_0000707417393859856318 { ++key() : void ++type_info_ : const std::type_info * ++id_ : const execution_context::id * +} +class "service_already_exists" as C_0001303087164408281476 +class C_0001303087164408281476 { ++service_already_exists() : void +} +class "invalid_service_owner" as C_0000724166715409489817 +class C_0000724166715409489817 { ++invalid_service_owner() : void +} +class "async_completion" as C_0001538166116730723609 +class C_0001538166116730723609 { ++async_completion() : void ++completion_handler : typename conditional::value,completion_handler_type &,completion_handler_type>::type ++result : async_result::type,Signatures...> +} +class "is_async_operation" as C_0001973172076909946704 +class C_0001973172076909946704 { +} +class "completion_signature_of" as C_0001885286219411315513 +class C_0001885286219411315513 { +} +class "default_completion_token" as C_0002020472629250993016 +class C_0002020472629250993016 { +} +class "basic_system_executor,execution::detail::relationship::fork_t,std::allocator>" as C_0001930045390932397221 +class C_0001930045390932397221 { +} +class "system_context" as C_0001221939569020161524 +class C_0001221939569020161524 { ++~system_context() : void ++get_executor() : system_context::executor_type ++stop() : void ++stopped() const : bool ++join() : void ++system_context() : void +} +class "system_context::thread_function" as C_0000927029792606998000 +class C_0000927029792606998000 { ++operator()() : void ++scheduler_ : detail::scheduler * +} +class "associated_executor" as C_0000923206039121407326 +class C_0000923206039121407326 { +} +class "associated_executor" as C_0000542372358239726186 +class C_0000542372358239726186 { +{static} +get() : associated_executor,type-parameter-0-1>::type +{static} +get() : decltype(associated_executor::get(t.get(),ex)) +} +class "associated_executor,type-parameter-0-1>" as C_0001454795182572301238 +class C_0001454795182572301238 { +{static} +get() : associated_executor,type-parameter-0-1>::type +{static} +get() : decltype(associated_executor::get(t.get(),ex)) +} +class "cancellation_filter" as C_0002052210819347097931 +class C_0002052210819347097931 { ++operator()() const : cancellation_type_t +} +class "cancellation_state" as C_0001623925961559449120 +class C_0001623925961559449120 { ++cancellation_state() : void ++slot() const : cancellation_slot ++cancelled() const : cancellation_type_t ++clear() : void ++cancellation_state() : void ++cancellation_state() : void ++cancellation_state() : void +} +class "cancellation_state::impl_base" as C_0000211046925031916270 +class C_0000211046925031916270 { ++impl_base() : void +} +class "cancellation_state::impl" as C_0000475070016299141269 +class C_0000475070016299141269 { ++impl() : void ++impl() : void ++operator()() : void ++in_filter_ : InFilter ++out_filter_ : OutFilter +} +class "recycling_allocator" as C_0001164715841612463432 +class C_0001164715841612463432 { ++recycling_allocator() : void ++operator==() const : bool ++operator!=() const : bool ++allocate() : T * ++deallocate() : void ++recycling_allocator() : void +} +class "recycling_allocator::rebind" as C_0000473578666287689519 +class C_0000473578666287689519 { +} +class "recycling_allocator" as C_0001992449723781696109 +class C_0001992449723781696109 { ++recycling_allocator() : void ++operator==() const : bool ++operator!=() const : bool ++recycling_allocator() : void +} +class "recycling_allocator" as C_0002289647677683880663 +class C_0002289647677683880663 { ++recycling_allocator() : void ++operator==() const : bool ++operator!=() const : bool ++recycling_allocator() : void +} +class "any_completion_handler_allocator" as C_0000339474733885529932 +class C_0000339474733885529932 { ++operator==() const : bool ++operator!=() const : bool ++allocate() const : T * ++deallocate() const : void ++any_completion_handler_allocator() : void +} +class "any_completion_handler_allocator::rebind" as C_0000995635239522977261 +class C_0000995635239522977261 { +} +class "any_completion_handler_allocator" as C_0001333788306557319588 +class C_0001333788306557319588 { ++operator==() const : bool ++operator!=() const : bool ++any_completion_handler_allocator() : void +} +class "any_completion_handler_allocator" as C_0000994107202387188237 +class C_0000994107202387188237 { ++operator==() const : bool ++operator!=() const : bool ++any_completion_handler_allocator() : void +} +class "any_completion_handler" as C_0001518213415919356242 +class C_0001518213415919356242 { ++any_completion_handler() : void ++any_completion_handler() : void ++any_completion_handler() : void ++operator=() : any_completion_handler & ++operator=() : any_completion_handler & ++~any_completion_handler() : void ++operator bool() const : bool ++operator!() const : bool ++swap() : void ++get_allocator() const : any_completion_handler::allocator_type ++get_cancellation_slot() const : any_completion_handler::cancellation_slot_type ++any_completion_handler() : void ++operator()() : decltype(this->fn_table_->call(this->impl_, static_cast(args)...)) +} +class "associated_executor,type-parameter-0-1>" as C_0000996213171688166134 +class C_0000996213171688166134 { +{static} +get() : any_completion_executor,type-parameter-0-1>::type +} +class "any_io_executor" as C_0000750189554942949379 +class C_0000750189554942949379 { ++any_io_executor() : void ++any_io_executor() : void ++any_io_executor() : void ++any_io_executor() : void ++any_io_executor() : void ++any_io_executor() : void ++operator=() : any_io_executor & ++operator=() : any_io_executor & ++operator=() : any_io_executor & ++~any_io_executor() : void ++swap() : void ++any_io_executor() : void ++any_io_executor() : void ++any_io_executor() : void ++any_io_executor() : void ++require() : class any_io_executor ++prefer() : class any_io_executor +} +class "append_t" as C_0000920728604948448211 +class C_0000920728604948448211 { ++append_t() : void ++token_ : CompletionToken ++values_ : std::tuple +} +class "as_tuple_t" as C_0000821918711511637479 +class C_0000821918711511637479 { ++as_tuple_t() : void ++as_tuple_t() : void +{static} +as_default_on() : typename decay::type::template rebind_executor::type::executor_type> >::other ++token_ : CompletionToken +} +class "as_tuple_t::default_constructor_tag" as C_0001283838706248842689 +class C_0001283838706248842689 { +} +class "as_tuple_t::executor_with_default" as C_0001427378672799846397 +class C_0001427378672799846397 { ++executor_with_default() : void +} +class "associated_immediate_executor" as C_0001058762363213460233 +class C_0001058762363213460233 { +} +class "associated_immediate_executor" as C_0002036247542250675663 +class C_0002036247542250675663 { +{static} +get() : decltype(associated_immediate_executor::get(t.get(),ex)) +} +class "associated_immediate_executor,type-parameter-0-1>" as C_0002287188187341591389 +class C_0002287188187341591389 { +{static} +get() : decltype(associated_immediate_executor::get(t.get(),ex)) +} +class "io_context::basic_executor_type,0>" as C_0001588984883922838991 +class C_0001588984883922838991 { +} +class "io_context" as C_0000105129752803362734 +class C_0000105129752803362734 { ++io_context() : void ++io_context() : void ++~io_context() : void ++get_executor() : io_context::executor_type ++run() : io_context::count_type ++run() : io_context::count_type ++run_one() : io_context::count_type ++run_one() : io_context::count_type ++poll() : io_context::count_type ++poll() : io_context::count_type ++poll_one() : io_context::count_type ++poll_one() : io_context::count_type ++stop() : void ++stopped() const : bool ++restart() : void ++reset() : void ++run_for() : std::size_t ++run_until() : std::size_t ++run_one_for() : std::size_t ++run_one_until() : std::size_t ++dispatch() : decltype(async_initiate(declval(), handler, this)) ++post() : decltype(async_initiate(declval(), handler, this)) ++wrap() : detail::wrapped_handler +} +class "io_context::basic_executor_type" as C_0000276547691992090690 +class C_0000276547691992090690 { ++basic_executor_type() : void ++basic_executor_type() : void ++~basic_executor_type() : void ++operator=() : basic_executor_type & ++operator=() : basic_executor_type & ++running_in_this_thread() const : bool ++context() const : io_context & ++on_work_started() const : void ++on_work_finished() const : void ++execute() : void ++dispatch() : void ++post() : void ++defer() : void +} +class "io_context::work" as C_0000001930820299579924 +class C_0000001930820299579924 { ++work() : void ++work() : void ++~work() : void ++get_io_context() : io_context & +} +class "io_context::service" as C_0001841820429911858749 +class C_0001841820429911858749 { ++get_io_context() : io_context & +#service() : void +#~service() : void +} +class "executor_work_guard" as C_0001052945440517134591 +class C_0001052945440517134591 { ++executor_work_guard::value, void>::type>() : void ++executor_work_guard::value, void>::type>() : void ++executor_work_guard::value, void>::type>() : void ++~executor_work_guard::value, void>::type>() : void ++get_executor() const : executor_work_guard::value,void>::type>::executor_type ++owns_work() const : bool ++reset() : void +} +class "executor_work_guard>,void>" as C_0000116913879989434614 +class C_0000116913879989434614 { ++executor_work_guard::value, void>::type>() : void ++executor_work_guard::value, void>::type>() : void ++executor_work_guard::value, void>::type>() : void ++~executor_work_guard::value, void>::type>() : void ++get_executor() const : executor_work_guard::value,void>::type>::executor_type ++owns_work() const : bool ++reset() : void +} +class "executor_work_guard>,typename enable_if>>" as C_0001466659954377760637 +class C_0001466659954377760637 { ++executor_work_guard::value, void>::type, typename enable_if::value, void>::type>() : void ++executor_work_guard::value, void>::type, typename enable_if::value, void>::type>() : void ++executor_work_guard::value, void>::type, typename enable_if::value, void>::type>() : void ++~executor_work_guard::value, void>::type, typename enable_if::value, void>::type>() : void ++get_executor() const : executor_work_guard::value,void>::type,typename enable_if::value,void>::type>::executor_type ++owns_work() const : bool ++reset() : void +} +class "io_context::initiate_dispatch" as C_0000073531310776945951 +class C_0000073531310776945951 { ++operator()() : void +} +class "io_context::initiate_post" as C_0002167338014875013779 +class C_0002167338014875013779 { ++operator()() : void +} +class "socket_base" as C_0001329267821479112043 +class C_0001329267821479112043 { +#~socket_base() : void +{static} +message_peek : const int +{static} +message_out_of_band : const int +{static} +message_do_not_route : const int +{static} +message_end_of_record : const int +{static} +max_listen_connections : const int +{static} +max_connections : const int +} +enum "socket_base::shutdown_type" as C_0000133685500292154467 +enum C_0000133685500292154467 { +shutdown_receive +shutdown_send +shutdown_both +} +enum "socket_base::wait_type" as C_0000336099795826135937 +enum C_0000336099795826135937 { +wait_read +wait_write +wait_error +} +class "is_contiguous_iterator" as C_0002205823896566184199 +class C_0002205823896566184199 { +} +class "mutable_buffer" as C_0000622260736241324297 +class C_0000622260736241324297 { ++mutable_buffer() : void ++mutable_buffer() : void ++data() const : void * ++size() const : std::size_t ++operator+=() : mutable_buffer & +} +class "mutable_buffers_1" as C_0001682096113223144056 +class C_0001682096113223144056 { ++mutable_buffers_1() : void ++mutable_buffers_1() : void ++begin() const : mutable_buffers_1::const_iterator ++end() const : mutable_buffers_1::const_iterator +} +class "const_buffer" as C_0000298775955056524500 +class C_0000298775955056524500 { ++const_buffer() : void ++const_buffer() : void ++const_buffer() : void ++data() const : const void * ++size() const : std::size_t ++operator+=() : const_buffer & +} +class "const_buffers_1" as C_0000923069171355014186 +class C_0000923069171355014186 { ++const_buffers_1() : void ++const_buffers_1() : void ++begin() const : const_buffers_1::const_iterator ++end() const : const_buffers_1::const_iterator +} +class "null_buffers" as C_0001632964849648014196 +class C_0001632964849648014196 { ++begin() const : null_buffers::const_iterator ++end() const : null_buffers::const_iterator +} +class "dynamic_string_buffer" as C_0000491537876793414642 +class C_0000491537876793414642 { ++dynamic_string_buffer() : void ++dynamic_string_buffer() : void ++dynamic_string_buffer() : void ++size() const : std::size_t ++max_size() const : std::size_t ++capacity() const : std::size_t ++data() const : dynamic_string_buffer::const_buffers_type ++data() : dynamic_string_buffer::mutable_buffers_type ++data() const : dynamic_string_buffer::const_buffers_type ++prepare() : dynamic_string_buffer::mutable_buffers_type ++commit() : void ++grow() : void ++shrink() : void ++consume() : void +} +class "dynamic_vector_buffer" as C_0000042643733936786038 +class C_0000042643733936786038 { ++dynamic_vector_buffer() : void ++dynamic_vector_buffer() : void ++dynamic_vector_buffer() : void ++size() const : std::size_t ++max_size() const : std::size_t ++capacity() const : std::size_t ++data() const : dynamic_vector_buffer::const_buffers_type ++data() : dynamic_vector_buffer::mutable_buffers_type ++data() const : dynamic_vector_buffer::const_buffers_type ++prepare() : dynamic_vector_buffer::mutable_buffers_type ++commit() : void ++grow() : void ++shrink() : void ++consume() : void +} +class "is_mutable_buffer_sequence" as C_0001245799211275390768 +class C_0001245799211275390768 { +} +class "is_const_buffer_sequence" as C_0000531835600544833660 +class C_0000531835600544833660 { +} +class "is_dynamic_buffer_v1" as C_0000493043484508310822 +class C_0000493043484508310822 { +} +class "is_dynamic_buffer_v2" as C_0000098699251076698219 +class C_0000098699251076698219 { +} +class "is_dynamic_buffer" as C_0002258581739027353293 +class C_0002258581739027353293 { +} +class "registered_buffer_id" as C_0000735632064666601427 +class C_0000735632064666601427 { ++registered_buffer_id() : void ++native_handle() const : registered_buffer_id::native_handle_type +} +class "mutable_registered_buffer" as C_0000138963604805253517 +class C_0000138963604805253517 { ++mutable_registered_buffer() : void ++buffer() const : const mutable_buffer & ++data() const : void * ++size() const : std::size_t ++id() const : const registered_buffer_id & ++operator+=() : mutable_registered_buffer & +} +class "const_registered_buffer" as C_0002280791800217451586 +class C_0002280791800217451586 { ++const_registered_buffer() : void ++const_registered_buffer() : void ++buffer() const : const const_buffer & ++data() const : const void * ++size() const : std::size_t ++id() const : const registered_buffer_id & ++operator+=() : const_registered_buffer & +} +class "basic_socket" as C_0002251142779628954667 +class C_0002251142779628954667 { ++basic_socket() : void ++basic_socket() : void ++basic_socket() : void ++basic_socket() : void ++basic_socket() : void ++operator=() : basic_socket & ++get_executor() : const basic_socket::executor_type & ++lowest_layer() : basic_socket::lowest_layer_type & ++lowest_layer() const : const basic_socket::lowest_layer_type & ++open() : void ++open() : boost::system::error_code ++assign() : void ++assign() : boost::system::error_code ++is_open() const : bool ++close() : void ++close() : boost::system::error_code ++release() : basic_socket::native_handle_type ++release() : basic_socket::native_handle_type ++native_handle() : basic_socket::native_handle_type ++cancel() : void ++cancel() : boost::system::error_code ++at_mark() const : bool ++at_mark() const : bool ++available() const : std::size_t ++available() const : std::size_t ++bind() : void ++bind() : boost::system::error_code ++connect() : void ++connect() : boost::system::error_code ++non_blocking() const : bool ++non_blocking() : void ++non_blocking() : boost::system::error_code ++native_non_blocking() const : bool ++native_non_blocking() : void ++native_non_blocking() : boost::system::error_code ++local_endpoint() const : basic_socket::endpoint_type ++local_endpoint() const : basic_socket::endpoint_type ++remote_endpoint() const : basic_socket::endpoint_type ++remote_endpoint() const : basic_socket::endpoint_type ++shutdown() : void ++shutdown() : boost::system::error_code ++wait() : void ++wait() : boost::system::error_code +#~basic_socket() : void ++basic_socket() : void ++basic_socket() : void ++basic_socket() : void ++basic_socket() : void ++basic_socket() : void ++operator=() : typename constraint::value && is_convertible::value, basic_socket &>::type ++async_connect() : decltype(async_initiate(declval(), token, peer_endpoint, declval())) ++set_option() : void ++set_option() : boost::system::error_code ++get_option() : void ++get_option() : boost::system::error_code ++io_control() : void ++io_control() : boost::system::error_code ++async_wait() : decltype(async_initiate(declval(), token, w)) +#impl_ : detail::io_object_impl,Executor> +} +class "basic_socket::rebind_executor" as C_0000118360417514684777 +class C_0000118360417514684777 { +} +class "basic_socket::initiate_async_connect" as C_0000992936191056096373 +class C_0000992936191056096373 { ++initiate_async_connect() : void ++get_executor() const : const basic_socket::initiate_async_connect::executor_type & ++operator()() : void +} +class "basic_socket::initiate_async_wait" as C_0000663413449874258456 +class C_0000663413449874258456 { ++initiate_async_wait() : void ++get_executor() const : const basic_socket::initiate_async_wait::executor_type & ++operator()() : void +} +class "basic_datagram_socket" as C_0000300421770783900070 +class C_0000300421770783900070 { ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++operator=() : basic_datagram_socket & ++~basic_datagram_socket() : void ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++basic_datagram_socket() : void ++operator=() : typename constraint::value && is_convertible::value, basic_datagram_socket &>::type ++send() : std::size_t ++send() : std::size_t ++send() : std::size_t ++async_send() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) ++async_send() : decltype(async_initiate(declval(), token, buffers, flags)) ++send_to() : std::size_t ++send_to() : std::size_t ++send_to() : std::size_t ++async_send_to() : decltype(async_initiate(declval(), token, buffers, destination, class socket_base::message_flags(0))) ++async_send_to() : decltype(async_initiate(declval(), token, buffers, destination, flags)) ++receive() : std::size_t ++receive() : std::size_t ++receive() : std::size_t ++async_receive() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) ++async_receive() : decltype(async_initiate(declval(), token, buffers, flags)) ++receive_from() : std::size_t ++receive_from() : std::size_t ++receive_from() : std::size_t ++async_receive_from() : decltype(async_initiate(declval(), token, buffers, & sender_endpoint, class socket_base::message_flags(0))) ++async_receive_from() : decltype(async_initiate(declval(), token, buffers, & sender_endpoint, flags)) +} +class "basic_datagram_socket::rebind_executor" as C_0000845548434118702422 +class C_0000845548434118702422 { +} +class "basic_datagram_socket::initiate_async_send" as C_0002106151838513322220 +class C_0002106151838513322220 { ++initiate_async_send() : void ++get_executor() const : const basic_datagram_socket::initiate_async_send::executor_type & ++operator()() : void +} +class "basic_datagram_socket::initiate_async_send_to" as C_0001404791623453730807 +class C_0001404791623453730807 { ++initiate_async_send_to() : void ++get_executor() const : const basic_datagram_socket::initiate_async_send_to::executor_type & ++operator()() : void +} +class "basic_datagram_socket::initiate_async_receive" as C_0001993384269880860283 +class C_0001993384269880860283 { ++initiate_async_receive() : void ++get_executor() const : const basic_datagram_socket::initiate_async_receive::executor_type & ++operator()() : void +} +class "basic_datagram_socket::initiate_async_receive_from" as C_0001751521259469802707 +class C_0001751521259469802707 { ++initiate_async_receive_from() : void ++get_executor() const : const basic_datagram_socket::initiate_async_receive_from::executor_type & ++operator()() : void +} +class "time_traits" as C_0000684139325220970560 +class C_0000684139325220970560 { +{static} +now() : time_traits::time_type +{static} +add() : time_traits::time_type +{static} +subtract() : boost::posix_time::time_duration::duration_type +{static} +less_than() : bool +{static} +to_posix_duration() : boost::posix_time::time_duration +} +class "time_traits" as C_0001429389221502855366 +class C_0001429389221502855366 { +{static} +now() : time_traits::time_type +{static} +add() : time_traits::time_type +{static} +subtract() : boost::posix_time::time_duration::duration_type +{static} +less_than() : bool +{static} +to_posix_duration() : boost::posix_time::time_duration +} +class "basic_deadline_timer" as C_0000825134613055375187 +class C_0000825134613055375187 { ++basic_deadline_timer() : void ++basic_deadline_timer() : void ++basic_deadline_timer() : void ++basic_deadline_timer() : void ++operator=() : basic_deadline_timer & ++~basic_deadline_timer() : void ++get_executor() : const basic_deadline_timer::executor_type & ++cancel() : std::size_t ++cancel() : std::size_t ++cancel_one() : std::size_t ++cancel_one() : std::size_t ++expires_at() const : basic_deadline_timer::time_type ++expires_at() : std::size_t ++expires_at() : std::size_t ++expires_from_now() const : basic_deadline_timer::duration_type ++expires_from_now() : std::size_t ++expires_from_now() : std::size_t ++wait() : void ++wait() : void ++basic_deadline_timer() : void ++basic_deadline_timer() : void ++basic_deadline_timer() : void ++async_wait() : decltype(async_initiate(declval(), token)) +} +class "basic_deadline_timer::rebind_executor" as C_0002179810917352815544 +class C_0002179810917352815544 { +} +class "basic_deadline_timer::initiate_async_wait" as C_0000634773909533942772 +class C_0000634773909533942772 { ++initiate_async_wait() : void ++get_executor() const : const basic_deadline_timer::initiate_async_wait::executor_type & ++operator()() : void +} +class "basic_io_object" as C_0000539825336144485956 +class C_0000539825336144485956 { ++get_io_context() : io_context & ++get_io_service() : io_context & ++get_executor() : basic_io_object::executor_type +#basic_io_object() : void +#~basic_io_object() : void +#get_service() : basic_io_object::service_type & +#get_service() const : const basic_io_object::service_type & +#get_implementation() : basic_io_object::implementation_type & +#get_implementation() const : const basic_io_object::implementation_type & +} +class "basic_io_object" as C_0000617462298852086838 +class C_0000617462298852086838 { ++get_io_context() : io_context & ++get_io_service() : io_context & ++get_executor() : io_context::basic_executor_type::executor_type +#basic_io_object() : void +#basic_io_object() : void +#~basic_io_object() : void +#operator=() : basic_io_object & +#get_service() : basic_io_object::service_type & +#get_service() const : const basic_io_object::service_type & +#get_implementation() : typename type-parameter-0-0::implementation_type &::implementation_type & +#get_implementation() const : const typename type-parameter-0-0::implementation_type &::implementation_type & +#basic_io_object() : void +} +class "basic_io_object" as C_0002023240989275094213 +class C_0002023240989275094213 { ++get_io_context() : io_context & ++get_io_service() : io_context & ++get_executor() : io_context::basic_executor_type::executor_type +#basic_io_object() : void +#basic_io_object() : void +#~basic_io_object() : void +#operator=() : basic_io_object & +#get_service() : basic_io_object::service_type & +#get_service() const : const basic_io_object::service_type & +#get_implementation() : typename type-parameter-0-0::implementation_type &::implementation_type & +#get_implementation() const : const typename type-parameter-0-0::implementation_type &::implementation_type & +#basic_io_object() : void +} +class "basic_raw_socket" as C_0001689830339688587027 +class C_0001689830339688587027 { ++basic_raw_socket() : void ++basic_raw_socket() : void ++basic_raw_socket() : void ++basic_raw_socket() : void ++basic_raw_socket() : void ++operator=() : basic_raw_socket & ++~basic_raw_socket() : void ++basic_raw_socket() : void ++basic_raw_socket() : void ++basic_raw_socket() : void ++basic_raw_socket() : void ++basic_raw_socket() : void ++operator=() : typename constraint::value && is_convertible::value, basic_raw_socket &>::type ++send() : std::size_t ++send() : std::size_t ++send() : std::size_t ++async_send() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) ++async_send() : decltype(async_initiate(declval(), token, buffers, flags)) ++send_to() : std::size_t ++send_to() : std::size_t ++send_to() : std::size_t ++async_send_to() : decltype(async_initiate(declval(), token, buffers, destination, class socket_base::message_flags(0))) ++async_send_to() : decltype(async_initiate(declval(), token, buffers, destination, flags)) ++receive() : std::size_t ++receive() : std::size_t ++receive() : std::size_t ++async_receive() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) ++async_receive() : decltype(async_initiate(declval(), token, buffers, flags)) ++receive_from() : std::size_t ++receive_from() : std::size_t ++receive_from() : std::size_t ++async_receive_from() : decltype(async_initiate(declval(), token, buffers, & sender_endpoint, class socket_base::message_flags(0))) ++async_receive_from() : decltype(async_initiate(declval(), token, buffers, & sender_endpoint, flags)) +} +class "basic_raw_socket::rebind_executor" as C_0001787537657380559740 +class C_0001787537657380559740 { +} +class "basic_raw_socket::initiate_async_send" as C_0000497487532278530771 +class C_0000497487532278530771 { ++initiate_async_send() : void ++get_executor() const : const basic_raw_socket::initiate_async_send::executor_type & ++operator()() : void +} +class "basic_raw_socket::initiate_async_send_to" as C_0000851301681241319678 +class C_0000851301681241319678 { ++initiate_async_send_to() : void ++get_executor() const : const basic_raw_socket::initiate_async_send_to::executor_type & ++operator()() : void +} +class "basic_raw_socket::initiate_async_receive" as C_0002101155047341252618 +class C_0002101155047341252618 { ++initiate_async_receive() : void ++get_executor() const : const basic_raw_socket::initiate_async_receive::executor_type & ++operator()() : void +} +class "basic_raw_socket::initiate_async_receive_from" as C_0000170381772536364385 +class C_0000170381772536364385 { ++initiate_async_receive_from() : void ++get_executor() const : const basic_raw_socket::initiate_async_receive_from::executor_type & ++operator()() : void +} +class "basic_readable_pipe" as C_0002203480802918800744 +class C_0002203480802918800744 { ++basic_readable_pipe() : void ++basic_readable_pipe() : void ++basic_readable_pipe() : void ++operator=() : basic_readable_pipe & ++~basic_readable_pipe() : void ++get_executor() : const basic_readable_pipe::executor_type & ++lowest_layer() : basic_readable_pipe::lowest_layer_type & ++lowest_layer() const : const basic_readable_pipe::lowest_layer_type & ++assign() : void ++assign() : boost::system::error_code ++is_open() const : bool ++close() : void ++close() : boost::system::error_code ++release() : basic_readable_pipe::native_handle_type ++release() : basic_readable_pipe::native_handle_type ++native_handle() : basic_readable_pipe::native_handle_type ++cancel() : void ++cancel() : boost::system::error_code ++basic_readable_pipe() : void ++basic_readable_pipe() : void ++basic_readable_pipe() : void ++operator=() : typename constraint::value, basic_readable_pipe &>::type ++read_some() : std::size_t ++read_some() : std::size_t ++async_read_some() : decltype(async_initiate(declval(), token, buffers)) +} +class "basic_readable_pipe::rebind_executor" as C_0000928439653276581367 +class C_0000928439653276581367 { +} +class "basic_readable_pipe::initiate_async_read_some" as C_0000694677938061162486 +class C_0000694677938061162486 { ++initiate_async_read_some() : void ++get_executor() const : const basic_readable_pipe::initiate_async_read_some::executor_type & ++operator()() : void +} +class "basic_seq_packet_socket" as C_0000102779505467483669 +class C_0000102779505467483669 { ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++operator=() : basic_seq_packet_socket & ++~basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++basic_seq_packet_socket() : void ++operator=() : typename constraint::value && is_convertible::value, basic_seq_packet_socket &>::type ++send() : std::size_t ++send() : std::size_t ++async_send() : decltype(async_initiate(declval(), token, buffers, flags)) ++receive() : std::size_t ++receive() : std::size_t ++receive() : std::size_t ++async_receive() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0), &out_flags)) ++async_receive() : decltype(async_initiate(declval(), token, buffers, in_flags, &out_flags)) +} +class "basic_seq_packet_socket::rebind_executor" as C_0001580129487375757497 +class C_0001580129487375757497 { +} +class "basic_seq_packet_socket::initiate_async_send" as C_0001561069650707268835 +class C_0001561069650707268835 { ++initiate_async_send() : void ++get_executor() const : const basic_seq_packet_socket::initiate_async_send::executor_type & ++operator()() : void +} +class "basic_seq_packet_socket::initiate_async_receive_with_flags" as C_0000684171793268208012 +class C_0000684171793268208012 { ++initiate_async_receive_with_flags() : void ++get_executor() const : const basic_seq_packet_socket::initiate_async_receive_with_flags::executor_type & ++operator()() : void +} +class "serial_port_base" as C_0001872423731591456498 +class C_0001872423731591456498 { +#~serial_port_base() : void +} +class "serial_port_base::baud_rate" as C_0002275936598283369010 +class C_0002275936598283369010 { ++baud_rate() : void ++value() const : unsigned int ++store() const : boost::system::error_code ++load() : boost::system::error_code +} +class "serial_port_base::flow_control" as C_0001935096372874959705 +class C_0001935096372874959705 { ++flow_control() : void ++value() const : serial_port_base::flow_control::type ++store() const : boost::system::error_code ++load() : boost::system::error_code +} +enum "serial_port_base::flow_control::type" as C_0001214867729856727203 +enum C_0001214867729856727203 { +none +software +hardware +} +class "serial_port_base::parity" as C_0000382608433822363207 +class C_0000382608433822363207 { ++parity() : void ++value() const : serial_port_base::parity::type ++store() const : boost::system::error_code ++load() : boost::system::error_code +} +enum "serial_port_base::parity::type" as C_0002127774062639185902 +enum C_0002127774062639185902 { +none +odd +even +} +class "serial_port_base::stop_bits" as C_0001372024863050258601 +class C_0001372024863050258601 { ++stop_bits() : void ++value() const : serial_port_base::stop_bits::type ++store() const : boost::system::error_code ++load() : boost::system::error_code +} +enum "serial_port_base::stop_bits::type" as C_0000002389278402762306 +enum C_0000002389278402762306 { +one +onepointfive +two +} +class "serial_port_base::character_size" as C_0000938921830601086473 +class C_0000938921830601086473 { ++character_size() : void ++value() const : unsigned int ++store() const : boost::system::error_code ++load() : boost::system::error_code +} +class "basic_serial_port" as C_0000607999972769002841 +class C_0000607999972769002841 { ++basic_serial_port() : void ++basic_serial_port() : void ++basic_serial_port() : void ++basic_serial_port() : void ++basic_serial_port() : void ++operator=() : basic_serial_port & ++~basic_serial_port() : void ++get_executor() : const basic_serial_port::executor_type & ++lowest_layer() : basic_serial_port::lowest_layer_type & ++lowest_layer() const : const basic_serial_port::lowest_layer_type & ++open() : void ++open() : boost::system::error_code ++assign() : void ++assign() : boost::system::error_code ++is_open() const : bool ++close() : void ++close() : boost::system::error_code ++native_handle() : basic_serial_port::native_handle_type ++cancel() : void ++cancel() : boost::system::error_code ++send_break() : void ++send_break() : boost::system::error_code ++basic_serial_port() : void ++basic_serial_port() : void ++basic_serial_port() : void ++basic_serial_port() : void ++basic_serial_port() : void ++operator=() : typename constraint::value, basic_serial_port &>::type ++set_option() : void ++set_option() : boost::system::error_code ++get_option() : void ++get_option() : boost::system::error_code ++write_some() : std::size_t ++write_some() : std::size_t ++async_write_some() : decltype(async_initiate(declval(), token, buffers)) ++read_some() : std::size_t ++read_some() : std::size_t ++async_read_some() : decltype(async_initiate(declval(), token, buffers)) +} +class "basic_serial_port::rebind_executor" as C_0001863119155462986358 +class C_0001863119155462986358 { +} +class "basic_serial_port::initiate_async_write_some" as C_0001481347359384526046 +class C_0001481347359384526046 { ++initiate_async_write_some() : void ++get_executor() const : const basic_serial_port::initiate_async_write_some::executor_type & ++operator()() : void +} +class "basic_serial_port::initiate_async_read_some" as C_0000463694792247200959 +class C_0000463694792247200959 { ++initiate_async_read_some() : void ++get_executor() const : const basic_serial_port::initiate_async_read_some::executor_type & ++operator()() : void +} +class "signal_set_base" as C_0000473339362468888815 +class C_0000473339362468888815 { +#~signal_set_base() : void +} +enum "signal_set_base::flags" as C_0000721964023551572495 +enum C_0000721964023551572495 { +none +restart +no_child_stop +no_child_wait +dont_care +} +class "basic_signal_set" as C_0001994823049193047898 +class C_0001994823049193047898 { ++basic_signal_set() : void ++basic_signal_set() : void ++basic_signal_set() : void ++basic_signal_set() : void ++~basic_signal_set() : void ++get_executor() : const basic_signal_set::executor_type & ++add() : void ++add() : boost::system::error_code ++add() : void ++add() : boost::system::error_code ++remove() : void ++remove() : boost::system::error_code ++clear() : void ++clear() : boost::system::error_code ++cancel() : void ++cancel() : boost::system::error_code ++basic_signal_set() : void ++basic_signal_set() : void ++basic_signal_set() : void ++basic_signal_set() : void ++async_wait() : decltype(async_initiate(declval(), token)) +} +class "basic_signal_set::rebind_executor" as C_0001310078398999034377 +class C_0001310078398999034377 { +} +class "basic_signal_set::initiate_async_wait" as C_0001462986487885308685 +class C_0001462986487885308685 { ++initiate_async_wait() : void ++get_executor() const : const basic_signal_set::initiate_async_wait::executor_type & ++operator()() : void +} +class "basic_socket_acceptor" as C_0000800464884670493624 +class C_0000800464884670493624 { ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++operator=() : basic_socket_acceptor & ++~basic_socket_acceptor() : void ++get_executor() : const basic_socket_acceptor::executor_type & ++open() : void ++open() : boost::system::error_code ++assign() : void ++assign() : boost::system::error_code ++is_open() const : bool ++bind() : void ++bind() : boost::system::error_code ++listen() : void ++listen() : boost::system::error_code ++close() : void ++close() : boost::system::error_code ++release() : basic_socket_acceptor::native_handle_type ++release() : basic_socket_acceptor::native_handle_type ++native_handle() : basic_socket_acceptor::native_handle_type ++cancel() : void ++cancel() : boost::system::error_code ++non_blocking() const : bool ++non_blocking() : void ++non_blocking() : boost::system::error_code ++native_non_blocking() const : bool ++native_non_blocking() : void ++native_non_blocking() : boost::system::error_code ++local_endpoint() const : basic_socket_acceptor::endpoint_type ++local_endpoint() const : basic_socket_acceptor::endpoint_type ++wait() : void ++wait() : boost::system::error_code ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++basic_socket_acceptor() : void ++operator=() : typename constraint::value && is_convertible::value, basic_socket_acceptor &>::type ++set_option() : void ++set_option() : boost::system::error_code ++get_option() : void ++get_option() : boost::system::error_code ++io_control() : void ++io_control() : boost::system::error_code ++async_wait() : decltype(async_initiate(declval(), token, w)) ++accept() : void ++accept() : boost::system::error_code ++async_accept() : decltype(async_initiate(declval(), token, & peer, static_cast(0))) ++accept() : void ++accept() : boost::system::error_code ++async_accept() : decltype(async_initiate(declval(), token, & peer, & peer_endpoint)) ++async_accept() : decltype(async_initiate::other)>(declval(), token, declval(), static_cast(0), static_cast::other *>(0))) ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++async_accept() : decltype(async_initiate::other)>(declval(), token, ex, static_cast(0), static_cast::other *>(0))) ++async_accept() : decltype(async_initiate::other)>(declval(), token, context.get_executor(), static_cast(0), static_cast::other *>(0))) ++async_accept() : decltype(async_initiate::other)>(declval(), token, declval(), & peer_endpoint, static_cast::other *>(0))) ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++accept() : typename Protocol::socket::template rebind_executor::other ++async_accept() : decltype(async_initiate::other)>(declval(), token, ex, & peer_endpoint, static_cast::other *>(0))) ++async_accept() : decltype(async_initiate::other)>(declval(), token, context.get_executor(), & peer_endpoint, static_cast::other *>(0))) +} +class "basic_socket_acceptor::rebind_executor" as C_0000101577815943841046 +class C_0000101577815943841046 { +} +class "basic_socket_acceptor::initiate_async_wait" as C_0000486324289532472689 +class C_0000486324289532472689 { ++initiate_async_wait() : void ++get_executor() const : const basic_socket_acceptor::initiate_async_wait::executor_type & ++operator()() : void +} +class "basic_socket_acceptor::initiate_async_accept" as C_0001031346170663651795 +class C_0001031346170663651795 { ++initiate_async_accept() : void ++get_executor() const : const basic_socket_acceptor::initiate_async_accept::executor_type & ++operator()() : void +} +class "basic_socket_acceptor::initiate_async_move_accept" as C_0001167514986718000192 +class C_0001167514986718000192 { ++initiate_async_move_accept() : void ++get_executor() const : const basic_socket_acceptor::initiate_async_move_accept::executor_type & ++operator()() : void +} +class "basic_stream_socket" as C_0000888920646676525023 +class C_0000888920646676525023 { ++basic_stream_socket() : void ++basic_stream_socket() : void ++basic_stream_socket() : void ++basic_stream_socket() : void ++basic_stream_socket() : void ++operator=() : basic_stream_socket & ++~basic_stream_socket() : void ++basic_stream_socket() : void ++basic_stream_socket() : void ++basic_stream_socket() : void ++basic_stream_socket() : void ++basic_stream_socket() : void ++operator=() : typename constraint::value && is_convertible::value, basic_stream_socket &>::type ++send() : std::size_t ++send() : std::size_t ++send() : std::size_t ++async_send() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) ++async_send() : decltype(async_initiate(declval(), token, buffers, flags)) ++receive() : std::size_t ++receive() : std::size_t ++receive() : std::size_t ++async_receive() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) ++async_receive() : decltype(async_initiate(declval(), token, buffers, flags)) ++write_some() : std::size_t ++write_some() : std::size_t ++async_write_some() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) ++read_some() : std::size_t ++read_some() : std::size_t ++async_read_some() : decltype(async_initiate(declval(), token, buffers, class socket_base::message_flags(0))) +} +class "basic_stream_socket::rebind_executor" as C_0001619071580851378341 +class C_0001619071580851378341 { +} +class "basic_stream_socket::initiate_async_send" as C_0001246419260724352257 +class C_0001246419260724352257 { ++initiate_async_send() : void ++get_executor() const : const basic_stream_socket::initiate_async_send::executor_type & ++operator()() : void +} +class "basic_stream_socket::initiate_async_receive" as C_0000402371130314303983 +class C_0000402371130314303983 { ++initiate_async_receive() : void ++get_executor() const : const basic_stream_socket::initiate_async_receive::executor_type & ++operator()() : void +} +class "wait_traits" as C_0002247574831392807382 +class C_0002247574831392807382 { +{static} +to_wait_duration() : typename Clock::duration +{static} +to_wait_duration() : typename Clock::duration +} +class "basic_waitable_timer" as C_0001480821051807658755 +class C_0001480821051807658755 { ++basic_waitable_timer() : void ++basic_waitable_timer() : void ++basic_waitable_timer() : void ++basic_waitable_timer() : void ++operator=() : basic_waitable_timer & ++~basic_waitable_timer() : void ++get_executor() : const basic_waitable_timer::executor_type & ++cancel() : std::size_t ++cancel() : std::size_t ++cancel_one() : std::size_t ++cancel_one() : std::size_t ++expires_at() const : basic_waitable_timer::time_point ++expiry() const : basic_waitable_timer::time_point ++expires_at() : std::size_t ++expires_at() : std::size_t ++expires_after() : std::size_t ++expires_from_now() const : basic_waitable_timer::duration ++expires_from_now() : std::size_t ++expires_from_now() : std::size_t ++wait() : void ++wait() : void ++basic_waitable_timer() : void ++basic_waitable_timer() : void ++basic_waitable_timer() : void ++basic_waitable_timer() : void ++operator=() : typename constraint::value, basic_waitable_timer &>::type ++async_wait() : decltype(async_initiate(declval(), token)) +} +class "basic_waitable_timer::rebind_executor" as C_0001339208676110265245 +class C_0001339208676110265245 { +} +class "basic_waitable_timer::initiate_async_wait" as C_0001563175005524888899 +class C_0001563175005524888899 { ++initiate_async_wait() : void ++get_executor() const : const basic_waitable_timer::initiate_async_wait::executor_type & ++operator()() : void +} +class "basic_socket_streambuf" as C_0000598211904123792581 +class C_0000598211904123792581 { ++basic_socket_streambuf() : void ++basic_socket_streambuf() : void ++basic_socket_streambuf() : void ++operator=() : basic_socket_streambuf & ++~basic_socket_streambuf() : void ++connect() : basic_socket_streambuf * ++close() : basic_socket_streambuf * ++socket() : basic_socket & ++error() const : const boost::system::error_code & ++puberror() const : const boost::system::error_code & ++expires_at() const : basic_socket_streambuf::time_point ++expiry() const : basic_socket_streambuf::time_point ++expires_at() : void ++expires_after() : void ++expires_from_now() const : basic_socket_streambuf::duration ++expires_from_now() : void +#underflow() : std::basic_streambuf::int_type +#overflow() : std::basic_streambuf::int_type +#sync() : int +#setbuf() : std::streambuf * ++connect() : basic_socket_streambuf * +} +class "basic_socket_iostream" as C_0001368414461083048547 +class C_0001368414461083048547 { ++basic_socket_iostream() : void ++basic_socket_iostream() : void ++basic_socket_iostream() : void ++operator=() : basic_socket_iostream & ++close() : void ++rdbuf() const : basic_socket_streambuf * ++socket() : basic_socket & ++error() const : const boost::system::error_code & ++expires_at() const : basic_socket_iostream::time_point ++expiry() const : basic_socket_iostream::time_point ++expires_at() : void ++expires_after() : void ++expires_from_now() const : basic_socket_iostream::duration ++expires_from_now() : void ++basic_socket_iostream() : void ++connect() : void +} +class "basic_streambuf" as C_0000447720034096664289 +class C_0000447720034096664289 { ++basic_streambuf() : void ++size() const : std::size_t ++max_size() const : std::size_t ++capacity() const : std::size_t ++data() const : basic_streambuf::const_buffers_type ++prepare() : basic_streambuf::mutable_buffers_type ++commit() : void ++consume() : void +#underflow() : std::basic_streambuf::int_type +#overflow() : std::basic_streambuf::int_type +#reserve() : void +#buffer_delta : enum +} +class "basic_streambuf_ref" as C_0001707204983602852877 +class C_0001707204983602852877 { ++basic_streambuf_ref() : void ++basic_streambuf_ref() : void ++basic_streambuf_ref() : void ++size() const : std::size_t ++max_size() const : std::size_t ++capacity() const : std::size_t ++data() const : basic_streambuf_ref::const_buffers_type ++prepare() : basic_streambuf_ref::mutable_buffers_type ++commit() : void ++consume() : void +} +class "basic_writable_pipe" as C_0000565542308197095561 +class C_0000565542308197095561 { ++basic_writable_pipe() : void ++basic_writable_pipe() : void ++basic_writable_pipe() : void ++operator=() : basic_writable_pipe & ++~basic_writable_pipe() : void ++get_executor() : const basic_writable_pipe::executor_type & ++lowest_layer() : basic_writable_pipe::lowest_layer_type & ++lowest_layer() const : const basic_writable_pipe::lowest_layer_type & ++assign() : void ++assign() : boost::system::error_code ++is_open() const : bool ++close() : void ++close() : boost::system::error_code ++release() : basic_writable_pipe::native_handle_type ++release() : basic_writable_pipe::native_handle_type ++native_handle() : basic_writable_pipe::native_handle_type ++cancel() : void ++cancel() : boost::system::error_code ++basic_writable_pipe() : void ++basic_writable_pipe() : void ++basic_writable_pipe() : void ++operator=() : typename constraint::value, basic_writable_pipe &>::type ++write_some() : std::size_t ++write_some() : std::size_t ++async_write_some() : decltype(async_initiate(declval(), token, buffers)) +} +class "basic_writable_pipe::rebind_executor" as C_0000326567288131709361 +class C_0000326567288131709361 { +} +class "basic_writable_pipe::initiate_async_write_some" as C_0000141398663260888379 +class C_0000141398663260888379 { ++initiate_async_write_some() : void ++get_executor() const : const basic_writable_pipe::initiate_async_write_some::executor_type & ++operator()() : void +} +class "allocator_binder" as C_0001209250569527793898 +class C_0001209250569527793898 { ++allocator_binder() : void ++allocator_binder() : void ++allocator_binder() : void ++allocator_binder() : void ++~allocator_binder() : void ++get() : allocator_binder::target_type & ++get() const : const allocator_binder::target_type & ++get_allocator() const : allocator_binder::allocator_type ++allocator_binder() : void ++allocator_binder() : void ++allocator_binder() : void ++allocator_binder() : void ++allocator_binder() : void ++operator()() : typename result_of::type ++operator()() : typename result_of::type +} +class "associated_allocator,type-parameter-0-2>" as C_0001341254032176167842 +class C_0001341254032176167842 { +{static} +get() : decltype(b.get_allocator()) +} +class "cancellation_slot_binder" as C_0001835176679716454787 +class C_0001835176679716454787 { ++cancellation_slot_binder() : void ++cancellation_slot_binder() : void ++cancellation_slot_binder() : void ++cancellation_slot_binder() : void ++~cancellation_slot_binder() : void ++get() : cancellation_slot_binder::target_type & ++get() const : const cancellation_slot_binder::target_type & ++get_cancellation_slot() const : cancellation_slot_binder::cancellation_slot_type ++cancellation_slot_binder() : void ++cancellation_slot_binder() : void ++cancellation_slot_binder() : void ++cancellation_slot_binder() : void ++cancellation_slot_binder() : void ++operator()() : typename result_of::type ++operator()() : typename result_of::type +} +class "associated_cancellation_slot,type-parameter-0-2>" as C_0000344792771848228327 +class C_0000344792771848228327 { +{static} +get() : decltype(b.get_cancellation_slot()) +} +class "executor_arg_t" as C_0001251642126827096656 +class C_0001251642126827096656 { ++executor_arg_t() : void +} +class "uses_executor" as C_0002085166210246050158 +class C_0002085166210246050158 { +} +class "executor_binder" as C_0000737634417215276942 +class C_0000737634417215276942 { ++executor_binder() : void ++executor_binder() : void ++executor_binder() : void ++executor_binder() : void ++~executor_binder() : void ++get() : executor_binder::target_type & ++get() const : const executor_binder::target_type & ++get_executor() const : executor_binder::executor_type ++executor_binder() : void ++executor_binder() : void ++executor_binder() : void ++executor_binder() : void ++executor_binder() : void ++operator()() : typename result_of::type ++operator()() : typename result_of::type +} +class "uses_executor" as C_0000373881468381634030 +class C_0000373881468381634030 { +} +class "uses_executor,type-parameter-0-1>" as C_0000667662157759996161 +class C_0000667662157759996161 { +} +class "associated_executor,type-parameter-0-2>" as C_0000674820976728978734 +class C_0000674820976728978734 { +{static} +get() : decltype(b.get_executor()) +} +class "immediate_executor_binder" as C_0001292987643905878313 +class C_0001292987643905878313 { ++immediate_executor_binder() : void ++immediate_executor_binder() : void ++immediate_executor_binder() : void ++immediate_executor_binder() : void ++~immediate_executor_binder() : void ++get() : immediate_executor_binder::target_type & ++get() const : const immediate_executor_binder::target_type & ++get_immediate_executor() const : immediate_executor_binder::immediate_executor_type ++immediate_executor_binder() : void ++immediate_executor_binder() : void ++immediate_executor_binder() : void ++immediate_executor_binder() : void ++immediate_executor_binder() : void ++operator()() : typename result_of::type ++operator()() : typename result_of::type +} +class "associated_immediate_executor,type-parameter-0-2>" as C_0000396051957264461855 +class C_0000396051957264461855 { +{static} +get() : decltype(b.get_immediate_executor()) +} +class "buffer_registration" as C_0000243748527253355396 +class C_0000243748527253355396 { ++buffer_registration() : void ++~buffer_registration() : void ++operator=() : buffer_registration & ++size() const : std::size_t ++begin() const : buffer_registration::const_iterator ++cbegin() const : buffer_registration::const_iterator ++end() const : buffer_registration::const_iterator ++cend() const : buffer_registration::const_iterator ++operator[]() : const mutable_registered_buffer & ++at() : const mutable_registered_buffer & ++buffer_registration() : void ++buffer_registration() : void +} +class "buffered_read_stream" as C_0000762851305950348766 +class C_0000762851305950348766 { ++next_layer() : buffered_read_stream::next_layer_type & ++lowest_layer() : buffered_read_stream::lowest_layer_type & ++lowest_layer() const : const buffered_read_stream::lowest_layer_type & ++get_executor() : buffered_read_stream::executor_type ++close() : void ++close() : boost::system::error_code ++fill() : std::size_t ++fill() : std::size_t ++in_avail() : std::size_t ++in_avail() : std::size_t ++buffered_read_stream() : void ++buffered_read_stream() : void ++write_some() : std::size_t ++write_some() : std::size_t ++async_write_some() : decltype(declval::type>().async_write_some(buffers, static_cast(handler))) ++async_fill() : decltype(async_initiate(declval >(), handler, declval())) ++read_some() : std::size_t ++read_some() : std::size_t ++async_read_some() : decltype(async_initiate(declval >(), handler, declval(), buffers)) ++peek() : std::size_t ++peek() : std::size_t +{static} +default_buffer_size : const std::size_t +} +class "buffered_write_stream" as C_0000820246541163106035 +class C_0000820246541163106035 { ++next_layer() : buffered_write_stream::next_layer_type & ++lowest_layer() : buffered_write_stream::lowest_layer_type & ++lowest_layer() const : const buffered_write_stream::lowest_layer_type & ++get_executor() : buffered_write_stream::executor_type ++close() : void ++close() : boost::system::error_code ++flush() : std::size_t ++flush() : std::size_t ++in_avail() : std::size_t ++in_avail() : std::size_t ++buffered_write_stream() : void ++buffered_write_stream() : void ++async_flush() : decltype(async_initiate(declval >(), handler, declval())) ++write_some() : std::size_t ++write_some() : std::size_t ++async_write_some() : decltype(async_initiate(declval >(), handler, declval(), buffers)) ++read_some() : std::size_t ++read_some() : std::size_t ++async_read_some() : decltype(declval::type>().async_read_some(buffers, static_cast(handler))) ++peek() : std::size_t ++peek() : std::size_t +{static} +default_buffer_size : const std::size_t +} +class "buffered_read_stream" as C_0001893286903938629994 +class C_0001893286903938629994 { +} +class "buffered_stream" as C_0000035198005532594412 +class C_0000035198005532594412 { ++next_layer() : buffered_stream::next_layer_type & ++lowest_layer() : buffered_stream::lowest_layer_type & ++lowest_layer() const : const buffered_stream::lowest_layer_type & ++get_executor() : buffered_stream::executor_type ++close() : void ++close() : boost::system::error_code ++flush() : std::size_t ++flush() : std::size_t ++fill() : std::size_t ++fill() : std::size_t ++in_avail() : std::size_t ++in_avail() : std::size_t ++buffered_stream() : void ++buffered_stream() : void ++async_flush() : decltype(declval &>().async_flush(static_cast(handler))) ++write_some() : std::size_t ++write_some() : std::size_t ++async_write_some() : decltype(declval().async_write_some(buffers, static_cast(handler))) ++async_fill() : decltype(declval > &>().async_fill(static_cast(handler))) ++read_some() : std::size_t ++read_some() : std::size_t ++async_read_some() : decltype(declval().async_read_some(buffers, static_cast(handler))) ++peek() : std::size_t ++peek() : std::size_t +} +class "buffers_iterator" as C_0001617501813464659292 +class C_0001617501813464659292 { ++buffers_iterator() : void +{static} +begin() : buffers_iterator +{static} +end() : buffers_iterator ++operator*() const : buffers_iterator::reference ++operator->() const : buffers_iterator::pointer ++operator[]() const : buffers_iterator::reference ++operator++() : buffers_iterator & ++operator++() : buffers_iterator ++operator--() : buffers_iterator & ++operator--() : buffers_iterator ++operator+=() : buffers_iterator & ++operator-=() : buffers_iterator & +} +class "is_endpoint_sequence" as C_0000525854547058639503 +class C_0000525854547058639503 { ++value : enum +} +class "consign_t" as C_0000316430127824501579 +class C_0000316430127824501579 { ++consign_t() : void ++token_ : CompletionToken ++values_ : std::tuple +} +class "coroutine" as C_0000794848617510637586 +class C_0000794848617510637586 { ++coroutine() : void ++is_child() const : bool ++is_parent() const : bool ++is_complete() const : bool +} +class "deferred_signatures" as C_0001472099186716181715 +class C_0001472099186716181715 { +} +class "deferred_noop" as C_0001872625171729549394 +class C_0001872625171729549394 { ++operator()() : void ++operator()() : void +} +class "deferred_function" as C_0001754043766963330684 +class C_0001754043766963330684 { ++deferred_function() : void ++operator()() : decltype(static_cast(this->function_)(static_cast(args)...)) ++operator()() : decltype(Function(this->function_)(static_cast(args)...)) ++function_ : Function +} +class "deferred_values" as C_0000478198388049114075 +class C_0000478198388049114075 { ++deferred_values() : void ++operator()() : decltype(this->invoke_helper(static_cast(token), detail::index_sequence_for())) ++operator()() : decltype(this->const_invoke_helper(static_cast(token), detail::index_sequence_for())) +} +class "deferred_values::initiate" as C_0002154363408278802263 +class C_0002154363408278802263 { ++operator()() : void +} +class "deferred_async_operation" as C_0001354847054453951725 +class C_0001354847054453951725 { ++deferred_async_operation() : void ++operator()() : decltype(this->invoke_helper(static_cast(token), detail::index_sequence_for())) ++operator()() : decltype(this->const_invoke_helper(static_cast(token), detail::index_sequence_for())) +} +class "deferred_async_operation" as C_0000049391965140997166 +class C_0000049391965140997166 { ++deferred_async_operation, type-parameter-0-1, type-parameter-0-2...>() : void ++operator()() : decltype(this->invoke_helper(static_cast(token), detail::index_sequence_for())) ++operator()() : decltype(this->const_invoke_helper(static_cast(token), detail::index_sequence_for())) +} +class "deferred_async_operation,type-parameter-0-1,type-parameter-0-2...>" as C_0000108266549297425902 +class C_0000108266549297425902 { ++deferred_async_operation, type-parameter-0-1, type-parameter-0-2...>() : void ++operator()() : decltype(this->invoke_helper(static_cast(token), detail::index_sequence_for())) ++operator()() : decltype(this->const_invoke_helper(static_cast(token), detail::index_sequence_for())) +} +class "deferred_sequence" as C_0001218625529098884481 +class C_0001218625529098884481 { ++deferred_sequence() : void +} +class "deferred_conditional" as C_0001118399273803747903 +class C_0001118399273803747903 { ++deferred_conditional() : void ++operator()() : decltype(static_cast(this->on_true_)(static_cast(args)...)) ++operator()() : decltype(this->on_true_(static_cast(args)...)) ++then() : deferred_conditional ++otherwise() : deferred_conditional +} +class "deferred_conditional" as C_0001639765042149222702 +class C_0001639765042149222702 { +} +class "deferred_t" as C_0001841029389783028511 +class C_0001841029389783028511 { ++deferred_t() : void +{static} +when() : deferred_conditional<> +{static} +as_default_on() : typename decay::type::template rebind_executor::type::executor_type> >::other ++operator()() : typename constraint::type>::value, deferred_function::type> >::type ++operator()() : typename constraint::type>::value, typename decay::type>::type +{static} +values() : deferred_values::type...> +} +class "deferred_t::executor_with_default" as C_0000040289487466732585 +class C_0000040289487466732585 { ++executor_with_default() : void +} +class "detached_t" as C_0000068264242739121300 +class C_0000068264242739121300 { ++detached_t() : void +{static} +as_default_on() : typename decay::type::template rebind_executor::type::executor_type> >::other +} +class "detached_t::executor_with_default" as C_0001469913543827020208 +class C_0001469913543827020208 { ++executor_with_default() : void ++executor_with_default() : void +} +class "bad_executor" as C_0000536189499668024446 +class C_0000536189499668024446 { ++bad_executor() : void ++what() const : const char * +} +class "executor" as C_0000408522659736215366 +class C_0000408522659736215366 { ++executor() : void ++executor() : void ++executor() : void ++executor() : void ++~executor() : void ++operator=() : executor & ++operator=() : executor & ++operator=() : executor & ++context() const : execution_context & ++on_work_started() const : void ++on_work_finished() const : void +{static} +unspecified_bool_true() : void ++operator void (*)(boost::asio::executor::unspecified_bool_type_t)() const : executor::unspecified_bool_type ++target_type() const : const std::type_info & ++executor() : void ++executor() : void ++operator=() : class executor & ++dispatch() : void ++post() : void ++defer() : void ++target() : Executor * ++target() : const Executor * +} +class "executor::unspecified_bool_type_t" as C_0001792641688715044824 +class C_0001792641688715044824 { +} +abstract "executor::impl_base" as C_0002304422587923435943 +abstract C_0002304422587923435943 { +{abstract} +clone() const = 0 : executor::impl_base * +{abstract} +destroy() = 0 : void +{abstract} +context() = 0 : execution_context & +{abstract} +on_work_started() = 0 : void +{abstract} +on_work_finished() = 0 : void +{abstract} +dispatch() = 0 : void +{abstract} +post() = 0 : void +{abstract} +defer() = 0 : void +{abstract} +target_type() const = 0 : executor::type_id_result_type +{abstract} +target() = 0 : void * +{abstract} +target() const = 0 : const void * +{abstract} +equals() const = 0 : bool +#impl_base() : void +#~impl_base() : void +} +class "executor::impl" as C_0002080923436031164336 +class C_0002080923436031164336 { +{static} +create() : executor::impl_base * ++impl() : void ++clone() const : executor::impl_base * ++destroy() : void ++on_work_started() : void ++on_work_finished() : void ++context() : execution_context & ++dispatch() : void ++post() : void ++defer() : void ++target_type() const : executor::type_id_result_type ++target() : void * ++target() const : const void * ++equals() const : bool +} +class "executor::impl" as C_0000640326921389067419 +class C_0000640326921389067419 { +{static} +create() : executor::impl_base * ++impl, boost::asio::execution::detail::relationship::fork_t<0>, std::allocator >, type-parameter-0-0>() : void ++clone() const : executor::impl_base * ++destroy() : void ++on_work_started() : void ++on_work_finished() : void ++context() : execution_context & ++dispatch() : void ++post() : void ++defer() : void ++target_type() const : executor::type_id_result_type ++target() : void * ++target() const : const void * ++equals() const : bool +} +class "generic::detail::endpoint" as C_0001197525458661947626 +class C_0001197525458661947626 { ++endpoint() : void ++endpoint() : void ++endpoint() : void ++operator=() : generic::detail::endpoint & ++family() const : int ++protocol() const : int ++data() : detail::socket_addr_type * ++data() const : const detail::socket_addr_type * ++size() const : std::size_t ++resize() : void ++capacity() const : std::size_t +} +class "generic::detail::endpoint::data_union" as C_0001204664422348815587 +class C_0001204664422348815587 { ++base : detail::socket_addr_type ++generic : detail::sockaddr_storage_type +} +class "generic::basic_endpoint" as C_0001317710114972522026 +class C_0001317710114972522026 { ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++operator=() : basic_endpoint & ++operator=() : basic_endpoint & ++protocol() const : generic::basic_endpoint::protocol_type ++data() : generic::basic_endpoint::data_type * ++data() const : const generic::basic_endpoint::data_type * ++size() const : std::size_t ++resize() : void ++capacity() const : std::size_t ++basic_endpoint() : void +} +class "generic::datagram_protocol" as C_0001134369500416867519 +class C_0001134369500416867519 { ++datagram_protocol() : void ++type() const : int ++protocol() const : int ++family() const : int ++datagram_protocol() : void +} +class "generic::raw_protocol" as C_0001345950551281786720 +class C_0001345950551281786720 { ++raw_protocol() : void ++type() const : int ++protocol() const : int ++family() const : int ++raw_protocol() : void +} +class "generic::seq_packet_protocol" as C_0001768178951380087929 +class C_0001768178951380087929 { ++seq_packet_protocol() : void ++type() const : int ++protocol() const : int ++family() const : int ++seq_packet_protocol() : void +} +class "generic::stream_protocol" as C_0001809122141265005642 +class C_0001809122141265005642 { ++stream_protocol() : void ++type() const : int ++protocol() const : int ++family() const : int ++stream_protocol() : void +} +class "io_context::strand" as C_0001047890427567912267 +class C_0001047890427567912267 { ++strand() : void ++~strand() : void ++context() const : io_context & ++on_work_started() const : void ++on_work_finished() const : void ++running_in_this_thread() const : bool ++dispatch() : void ++dispatch() : decltype(async_initiate(declval(), handler, this)) ++post() : void ++post() : decltype(async_initiate(declval(), handler, this)) ++defer() : void ++wrap() : detail::wrapped_handler +} +class "io_context::strand::initiate_dispatch" as C_0001293600527802285514 +class C_0001293600527802285514 { ++operator()() : void +} +class "io_context::strand::initiate_post" as C_0001830231423530344583 +class C_0001830231423530344583 { ++operator()() : void +} +class "ip::address_v4" as C_0002025919776476726445 +class C_0002025919776476726445 { ++address_v4() : void ++address_v4() : void ++address_v4() : void ++address_v4() : void ++address_v4() : void ++operator=() : ip::address_v4 & ++operator=() : ip::address_v4 & ++to_bytes() const : ip::address_v4::bytes_type ++to_uint() const : ip::address_v4::uint_type ++to_ulong() const : unsigned long ++to_string() const : std::string ++to_string() const : std::string +{static} +from_string() : ip::address_v4 +{static} +from_string() : ip::address_v4 +{static} +from_string() : ip::address_v4 +{static} +from_string() : ip::address_v4 ++is_loopback() const : bool ++is_unspecified() const : bool ++is_class_a() const : bool ++is_class_b() const : bool ++is_class_c() const : bool ++is_multicast() const : bool +{static} +any() : ip::address_v4 +{static} +loopback() : ip::address_v4 +{static} +broadcast() : ip::address_v4 +{static} +broadcast() : ip::address_v4 +{static} +netmask() : ip::address_v4 +} +class "ip::address_v6" as C_0002098982763942637031 +class C_0002098982763942637031 { ++address_v6() : void ++address_v6() : void ++address_v6() : void ++address_v6() : void ++operator=() : ip::address_v6 & ++operator=() : ip::address_v6 & ++scope_id() const : ip::scope_id_type ++scope_id() : void ++to_bytes() const : ip::address_v6::bytes_type ++to_string() const : std::string ++to_string() const : std::string +{static} +from_string() : ip::address_v6 +{static} +from_string() : ip::address_v6 +{static} +from_string() : ip::address_v6 +{static} +from_string() : ip::address_v6 ++to_v4() const : ip::address_v4 ++is_loopback() const : bool ++is_unspecified() const : bool ++is_link_local() const : bool ++is_site_local() const : bool ++is_v4_mapped() const : bool ++is_v4_compatible() const : bool ++is_multicast() const : bool ++is_multicast_global() const : bool ++is_multicast_link_local() const : bool ++is_multicast_node_local() const : bool ++is_multicast_org_local() const : bool ++is_multicast_site_local() const : bool +{static} +any() : ip::address_v6 +{static} +loopback() : ip::address_v6 +{static} +v4_mapped() : ip::address_v6 +{static} +v4_compatible() : ip::address_v6 +} +enum "ip::v4_mapped_t" as C_0001093647575738903606 +enum C_0001093647575738903606 { +v4_mapped +} +class "ip::bad_address_cast" as C_0001311393420595390911 +class C_0001311393420595390911 { ++bad_address_cast() : void ++~bad_address_cast() : void ++what() const : const char * +} +class "ip::address" as C_0001327524464125083386 +class C_0001327524464125083386 { ++address() : void ++address() : void ++address() : void ++address() : void ++address() : void ++operator=() : ip::address & ++operator=() : ip::address & ++operator=() : ip::address & ++operator=() : ip::address & ++is_v4() const : bool ++is_v6() const : bool ++to_v4() const : ip::address_v4 ++to_v6() const : ip::address_v6 ++to_string() const : std::string ++to_string() const : std::string +{static} +from_string() : ip::address +{static} +from_string() : ip::address +{static} +from_string() : ip::address +{static} +from_string() : ip::address ++is_loopback() const : bool ++is_unspecified() const : bool ++is_multicast() const : bool +} +class "ip::basic_address_iterator" as C_0000318402603351769102 +class C_0000318402603351769102 { ++basic_address_iterator() : void ++basic_address_iterator() : void ++basic_address_iterator() : void ++operator=() : ip::basic_address_iterator & ++operator=() : ip::basic_address_iterator & ++operator*() const : const ip::address_v4 & ++operator->() const : const ip::address_v4 * ++operator++() : ip::basic_address_iterator & ++operator++() : ip::basic_address_iterator ++operator--() : ip::basic_address_iterator & ++operator--() : ip::basic_address_iterator +} +class "ip::basic_address_iterator" as C_0001494989037982793636 +class C_0001494989037982793636 { ++basic_address_iterator() : void ++basic_address_iterator() : void ++basic_address_iterator() : void ++operator=() : ip::basic_address_iterator & ++operator=() : ip::basic_address_iterator & ++operator*() const : const ip::address_v4 & ++operator->() const : const ip::address_v4 * ++operator++() : ip::basic_address_iterator & ++operator++() : ip::basic_address_iterator ++operator--() : ip::basic_address_iterator & ++operator--() : ip::basic_address_iterator +} +class "ip::basic_address_range" as C_0001983676680109476603 +class C_0001983676680109476603 { ++basic_address_range() : void ++basic_address_range() : void ++basic_address_range() : void ++basic_address_range() : void ++operator=() : ip::basic_address_range & ++operator=() : ip::basic_address_range & ++begin() const : ip::basic_address_iterator::iterator ++end() const : ip::basic_address_iterator::iterator ++empty() const : bool ++size() const : std::size_t ++find() const : ip::basic_address_iterator::iterator +} +class "ip::basic_address_range" as C_0000772044873699700545 +class C_0000772044873699700545 { ++basic_address_range() : void ++basic_address_range() : void ++basic_address_range() : void ++basic_address_range() : void ++operator=() : ip::basic_address_range & ++operator=() : ip::basic_address_range & ++begin() const : ip::basic_address_iterator::iterator ++end() const : ip::basic_address_iterator::iterator ++empty() const : bool ++size() const : std::size_t ++find() const : ip::basic_address_iterator::iterator +} +class "ip::basic_address_iterator" as C_0002102615558040381043 +class C_0002102615558040381043 { ++basic_address_iterator() : void ++basic_address_iterator() : void ++basic_address_iterator() : void ++operator=() : ip::basic_address_iterator & ++operator=() : ip::basic_address_iterator & ++operator*() const : const ip::address_v6 & ++operator->() const : const ip::address_v6 * ++operator++() : ip::basic_address_iterator & ++operator++() : ip::basic_address_iterator ++operator--() : ip::basic_address_iterator & ++operator--() : ip::basic_address_iterator +} +class "ip::basic_address_range" as C_0001541815403956626262 +class C_0001541815403956626262 { ++basic_address_range() : void ++basic_address_range() : void ++basic_address_range() : void ++basic_address_range() : void ++operator=() : ip::basic_address_range & ++operator=() : ip::basic_address_range & ++begin() const : ip::basic_address_iterator::iterator ++end() const : ip::basic_address_iterator::iterator ++empty() const : bool ++find() const : ip::basic_address_iterator::iterator +} +class "ip::network_v4" as C_0000630457919158355745 +class C_0000630457919158355745 { ++network_v4() : void ++network_v4() : void ++network_v4() : void ++network_v4() : void ++network_v4() : void ++operator=() : ip::network_v4 & ++operator=() : ip::network_v4 & ++address() const : ip::address_v4 ++prefix_length() const : unsigned short ++netmask() const : ip::address_v4 ++network() const : ip::address_v4 ++broadcast() const : ip::address_v4 ++hosts() const : ip::address_v4_range ++canonical() const : ip::network_v4 ++is_host() const : bool ++is_subnet_of() const : bool ++to_string() const : std::string ++to_string() const : std::string +} +class "ip::network_v6" as C_0001305454857652324427 +class C_0001305454857652324427 { ++network_v6() : void ++network_v6() : void ++network_v6() : void ++network_v6() : void ++operator=() : ip::network_v6 & ++operator=() : ip::network_v6 & ++address() const : ip::address_v6 ++prefix_length() const : unsigned short ++network() const : ip::address_v6 ++hosts() const : ip::address_v6_range ++canonical() const : ip::network_v6 ++is_host() const : bool ++is_subnet_of() const : bool ++to_string() const : std::string ++to_string() const : std::string +} +class "ip::basic_endpoint" as C_0001250048442097748343 +class C_0001250048442097748343 { ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++operator=() : basic_endpoint & ++operator=() : basic_endpoint & ++protocol() const : ip::basic_endpoint::protocol_type ++data() : ip::basic_endpoint::data_type * ++data() const : const ip::basic_endpoint::data_type * ++size() const : std::size_t ++resize() : void ++capacity() const : std::size_t ++port() const : ip::port_type ++port() : void ++address() const : ip::address ++address() : void +} +class "ip::basic_resolver_entry" as C_0000504239392535325073 +class C_0000504239392535325073 { ++basic_resolver_entry() : void ++basic_resolver_entry() : void ++endpoint() const : ip::basic_resolver_entry::endpoint_type ++operator typename type-parameter-0-0::endpoint() const : ip::basic_resolver_entry::endpoint_type ++host_name() const : std::string ++service_name() const : std::string ++host_name() : std::basic_string, Allocator> ++service_name() : std::basic_string, Allocator> +} +class "ip::basic_resolver_iterator" as C_0001347871524203521943 +class C_0001347871524203521943 { ++basic_resolver_iterator() : void ++basic_resolver_iterator() : void ++basic_resolver_iterator() : void ++operator=() : basic_resolver_iterator & ++operator=() : basic_resolver_iterator & ++operator*() const : const basic_resolver_entry & ++operator->() const : const basic_resolver_entry * ++operator++() : basic_resolver_iterator & ++operator++() : basic_resolver_iterator +#increment() : void +#equal() const : bool +#dereference() const : const basic_resolver_entry & +#index_ : std::size_t +} +class "ip::resolver_base" as C_0002054056523873699388 +class C_0002054056523873699388 { +#~resolver_base() : void +} +enum "ip::resolver_base::flags" as C_0002226089269405758232 +enum C_0002226089269405758232 { +canonical_name +passive +numeric_host +numeric_service +v4_mapped +all_matching +address_configured +} +class "ip::resolver_query_base" as C_0001433847844236950668 +class C_0001433847844236950668 { +#~resolver_query_base() : void +} +class "ip::basic_resolver_query" as C_0001352938694161192245 +class C_0001352938694161192245 { ++basic_resolver_query() : void ++basic_resolver_query() : void ++basic_resolver_query() : void ++basic_resolver_query() : void ++hints() const : const detail::addrinfo_type & ++host_name() const : std::string ++service_name() const : std::string +} +class "ip::basic_resolver_results" as C_0002280271119024021380 +class C_0002280271119024021380 { ++basic_resolver_results() : void ++basic_resolver_results() : void ++basic_resolver_results() : void ++operator=() : basic_resolver_results & ++operator=() : basic_resolver_results & +{static} +create() : basic_resolver_results +{static} +create() : basic_resolver_results ++size() const : ip::basic_resolver_results::size_type ++max_size() const : ip::basic_resolver_results::size_type ++empty() const : bool ++begin() const : ip::basic_resolver_results::const_iterator ++end() const : ip::basic_resolver_results::const_iterator ++cbegin() const : ip::basic_resolver_results::const_iterator ++cend() const : ip::basic_resolver_results::const_iterator ++swap() : void +{static} +create() : basic_resolver_results +} +class "ip::basic_resolver" as C_0000605417433857946713 +class C_0000605417433857946713 { ++basic_resolver() : void ++basic_resolver() : void ++operator=() : basic_resolver & ++~basic_resolver() : void ++get_executor() : ip::basic_resolver::executor_type ++cancel() : void ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++resolve() : ip::basic_resolver::results_type ++basic_resolver() : void ++basic_resolver() : void ++operator=() : typename constraint::value, basic_resolver &>::type ++async_resolve() : decltype(async_initiate(declval(), token, q)) ++async_resolve() : decltype(async_initiate(declval(), token, declval &>())) ++async_resolve() : decltype(async_initiate(declval(), token, declval &>())) ++async_resolve() : decltype(async_initiate(declval(), token, declval &>())) ++async_resolve() : decltype(async_initiate(declval(), token, declval &>())) ++async_resolve() : decltype(async_initiate(declval(), token, e)) +} +class "ip::basic_resolver::rebind_executor" as C_0001751550961524516647 +class C_0001751550961524516647 { +} +class "ip::basic_resolver::initiate_async_resolve" as C_0000636570610308227296 +class C_0000636570610308227296 { ++initiate_async_resolve() : void ++get_executor() const : ip::basic_resolver::initiate_async_resolve::executor_type ++operator()() : void +} +class "ip::icmp" as C_0002286282680096396617 +class C_0002286282680096396617 { +{static} +v4() : ip::icmp +{static} +v6() : ip::icmp ++type() const : int ++protocol() const : int ++family() const : int +} +class "ip::tcp" as C_0001747329754165877091 +class C_0001747329754165877091 { +{static} +v4() : ip::tcp +{static} +v6() : ip::tcp ++type() const : int ++protocol() const : int ++family() const : int +} +class "ip::udp" as C_0001852578197906964688 +class C_0001852578197906964688 { +{static} +v4() : ip::udp +{static} +v6() : ip::udp ++type() const : int ++protocol() const : int ++family() const : int +} +class "ip::basic_address_iterator<>" as C_0000193569378466042893 +class C_0000193569378466042893 { +} +class "ip::basic_resolver" as C_0001111536083036436993 +class C_0001111536083036436993 { +} +class "ip::basic_address_range<>" as C_0002162700889548815212 +class C_0002162700889548815212 { +} +class "is_read_buffered" as C_0001170111170497037018 +class C_0001170111170497037018 { +{static} +value : const bool +} +class "is_write_buffered" as C_0002240001693239958926 +class C_0002240001693239958926 { +{static} +value : const bool +} +class "local::detail::endpoint" as C_0001936514665235435084 +class C_0001936514665235435084 { ++endpoint() : void ++endpoint() : void ++endpoint() : void ++endpoint() : void ++operator=() : local::detail::endpoint & ++data() : detail::socket_addr_type * ++data() const : const detail::socket_addr_type * ++size() const : std::size_t ++resize() : void ++capacity() const : std::size_t ++path() const : std::string ++path() : void ++path() : void +} +class "local::detail::endpoint::data_union" as C_0000767644011034091251 +class C_0000767644011034091251 { ++base : detail::socket_addr_type ++local : detail::sockaddr_un_type +} +class "local::basic_endpoint" as C_0002115006149424113920 +class C_0002115006149424113920 { ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++basic_endpoint() : void ++operator=() : basic_endpoint & ++operator=() : basic_endpoint & ++protocol() const : local::basic_endpoint::protocol_type ++data() : local::basic_endpoint::data_type * ++data() const : const local::basic_endpoint::data_type * ++size() const : std::size_t ++resize() : void ++capacity() const : std::size_t ++path() const : std::string ++path() : void ++path() : void +} +class "local::datagram_protocol" as C_0001854195773056506757 +class C_0001854195773056506757 { ++type() const : int ++protocol() const : int ++family() const : int +} +class "local::seq_packet_protocol" as C_0000310864930145326074 +class C_0000310864930145326074 { ++type() const : int ++protocol() const : int ++family() const : int +} +class "local::stream_protocol" as C_0002024172891526936075 +class C_0002024172891526936075 { ++type() const : int ++protocol() const : int ++family() const : int +} +class "prepend_t" as C_0000873450437072005506 +class C_0000873450437072005506 { ++prepend_t() : void ++token_ : CompletionToken ++values_ : std::tuple +} +class "is_match_condition" as C_0001967484069156113171 +class C_0001967484069156113171 { ++value : enum +} +class "redirect_error_t" as C_0001344052433180822513 +class C_0001344052433180822513 { ++redirect_error_t() : void ++token_ : CompletionToken ++ec_ : boost::system::error_code & +} +class "can_require_concept" as C_0001412872591570361122 +class C_0001412872591570361122 { +} +class "is_nothrow_require_concept" as C_0001406532248330840168 +class C_0001406532248330840168 { +} +class "require_concept_result" as C_0000367349886905107842 +class C_0000367349886905107842 { +} +class "thread_pool::basic_executor_type,0>" as C_0001091533276186936325 +class C_0001091533276186936325 { +} +class "thread_pool" as C_0000428358945123590506 +class C_0000428358945123590506 { ++thread_pool() : void ++thread_pool() : void ++~thread_pool() : void ++get_executor() : thread_pool::executor_type ++executor() : thread_pool::executor_type ++scheduler() : thread_pool::scheduler_type ++stop() : void ++attach() : void ++join() : void ++wait() : void +} +class "thread_pool::basic_executor_type" as C_0002216214012275323442 +class C_0002216214012275323442 { ++basic_executor_type() : void ++basic_executor_type() : void ++~basic_executor_type() : void ++operator=() : basic_executor_type & ++operator=() : basic_executor_type & ++running_in_this_thread() const : bool ++schedule() const : thread_pool::basic_executor_type::sender_type ++context() const : thread_pool & ++on_work_started() const : void ++on_work_finished() const : void ++execute() : void ++bulk_execute() : void ++connect() : execution::detail::as_operation, Receiver> ++dispatch() : void ++post() : void ++defer() : void +{static} +sends_done : const bool +} +class "thread_pool_always_blocking_function_adapter" as C_0000358207284792429370 +class C_0000358207284792429370 { ++operator()() : void ++f : typename decay::type * ++n : std::size_t +} +class "thread_pool::thread_function" as C_0000127867743380468457 +class C_0000127867743380468457 { ++operator()() : void ++scheduler_ : detail::scheduler * +} +class "strand" as C_0000128377300581950063 +class C_0000128377300581950063 { ++strand() : void ++strand() : void ++operator=() : strand & ++strand() : void ++operator=() : strand & ++~strand() : void ++get_inner_executor() const : strand::inner_executor_type ++context() const : execution_context & ++on_work_started() const : void ++on_work_finished() const : void ++running_in_this_thread() const : bool ++strand() : void ++strand() : void ++strand() : void ++operator=() : strand & ++strand() : void ++operator=() : strand & ++query() : typename constraint::value, typename conditional::value, execution::blocking_t, typename query_result::type>::type>::type ++require() : typename constraint::value && ! is_convertible::value, strand::type>::type> >::type ++prefer() : typename constraint::value && ! is_convertible::value, strand::type>::type> >::type ++execute() : typename constraint::value, void>::type ++dispatch() : void ++post() : void ++defer() : void +{static} +create_implementation() : strand::implementation_type +{static} +create_implementation() : strand::implementation_type ++query_helper() : typename query_result::type ++query_helper() : execution::blocking_t ++executor_ : Executor ++impl_ : strand::implementation_type +} +class "this_coro::executor_t" as C_0001504610152439225185 +class C_0001504610152439225185 { ++executor_t() : void +} +class "this_coro::cancellation_state_t" as C_0000294703930715479565 +class C_0000294703930715479565 { ++cancellation_state_t() : void +} +class "this_coro::reset_cancellation_state_0_t" as C_0002044191965526733817 +class C_0002044191965526733817 { ++reset_cancellation_state_0_t() : void +} +class "this_coro::reset_cancellation_state_1_t" as C_0001494855093536409981 +class C_0001494855093536409981 { ++reset_cancellation_state_1_t() : void ++filter : Filter +} +class "this_coro::reset_cancellation_state_2_t" as C_0002164251787289099355 +class C_0002164251787289099355 { ++reset_cancellation_state_2_t() : void ++in_filter : InFilter ++out_filter : OutFilter +} +class "this_coro::throw_if_cancelled_0_t" as C_0000875908961316745704 +class C_0000875908961316745704 { ++throw_if_cancelled_0_t() : void +} +class "this_coro::throw_if_cancelled_1_t" as C_0002026769674415075041 +class C_0002026769674415075041 { ++throw_if_cancelled_1_t() : void ++value : bool +} +class "use_future_t" as C_0000184205612715164375 +class C_0000184205612715164375 { ++use_future_t() : void ++use_future_t() : void ++get_allocator() const : use_future_t::allocator_type ++operator[]() : use_future_t ++rebind() : use_future_t ++operator()() : detail::packaged_token::type, Allocator> +} +class "use_future_t::std_allocator_void" as C_0001713724102727392149 +class C_0001713724102727392149 { ++std_allocator_void() : void ++operator allocator() const : std::allocator +} +class "executor_work_guard" as C_0000161744423736293270 +class C_0000161744423736293270 { +} +class "deferred_conditional" as C_0000405152319293864563 +class C_0000405152319293864563 { +} +class "associated_executor<,>" as C_0000449086915005619037 +class C_0000449086915005619037 { +} +class "io_context::basic_executor_type<,uintptr_t>" as C_0000454252346129031868 +class C_0000454252346129031868 { +} +class "basic_socket_acceptor" as C_0000458608041516983122 +class C_0000458608041516983122 { +} +class "any_completion_handler_allocator<,...>" as C_0000599912472826442676 +class C_0000599912472826442676 { +} +class "basic_serial_port" as C_0000629005009591162662 +class C_0000629005009591162662 { +} +class "basic_system_executor<,,>" as C_0001032056072342606223 +class C_0001032056072342606223 { +} +class "basic_readable_pipe" as C_0001159488150419572868 +class C_0001159488150419572868 { +} +class "basic_socket" as C_0001234152234264910327 +class C_0001234152234264910327 { +} +class "executor::impl<,>" as C_0001272670126457277140 +class C_0001272670126457277140 { +} +class "thread_pool::basic_executor_type<,unsigned int>" as C_0001522797346949347799 +class C_0001522797346949347799 { +} +class "time_traits