├── .bazelrc ├── .clang-format ├── .github ├── ISSUE_TEMPLATE.md ├── PULL_REQUEST_TEMPLATE.md ├── actions │ └── coverage │ │ └── action.yml └── workflows │ ├── bazel_clang.yml │ ├── clang-format.yml │ ├── clean_cache.yml │ ├── code-coverage.yml │ ├── comment.yml │ ├── linux_llvm_cov.yml │ ├── mac.yml │ ├── s390x.yml │ ├── ubuntu_clang.yml │ ├── ubuntu_gcc.yml │ ├── update_cache.yml │ ├── website.yml │ └── windows.yml ├── .gitignore ├── BUILD.bazel ├── CMakeLists.txt ├── LICENSE ├── MODULE.bazel ├── NOTICE ├── README.md ├── WORKSPACE ├── WORKSPACE.bzlmod ├── bazel ├── BUILD └── defs.bzl ├── cmake ├── Find │ └── Finduring.cmake ├── build.cmake ├── config.cmake ├── develop.cmake ├── find_ibverbs.cmake ├── find_openssl.cmake ├── install.cmake ├── subdir.cmake └── utils.cmake ├── coverage_gen.sh ├── include └── ylt │ ├── coro_http │ ├── coro_http_client.hpp │ └── coro_http_server.hpp │ ├── coro_io │ ├── client_pool.hpp │ ├── coro_file.hpp │ ├── coro_io.hpp │ ├── detail │ │ └── client_queue.hpp │ ├── ibverbs │ │ ├── ib_buffer.hpp │ │ ├── ib_device.hpp │ │ ├── ib_error.hpp │ │ ├── ib_io.hpp │ │ └── ib_socket.hpp │ ├── io_context_pool.hpp │ ├── load_balancer.hpp │ ├── rate_limiter.hpp │ └── socket_wrapper.hpp │ ├── coro_rpc │ ├── coro_rpc_client.hpp │ ├── coro_rpc_context.hpp │ ├── coro_rpc_server.hpp │ └── impl │ │ ├── common_service.hpp │ │ ├── context.hpp │ │ ├── coro_connection.hpp │ │ ├── coro_rpc_client.hpp │ │ ├── coro_rpc_server.hpp │ │ ├── default_config │ │ └── coro_rpc_config.hpp │ │ ├── errno.h │ │ ├── expected.hpp │ │ ├── protocol │ │ ├── coro_rpc_protocol.hpp │ │ └── struct_pack_protocol.hpp │ │ ├── router.hpp │ │ └── rpc_execute.hpp │ ├── easylog.hpp │ ├── easylog │ ├── appender.hpp │ └── record.hpp │ ├── metric.hpp │ ├── metric │ ├── counter.hpp │ ├── dynamic_metric.hpp │ ├── gauge.hpp │ ├── histogram.hpp │ ├── metric.hpp │ ├── metric_manager.hpp │ ├── summary.hpp │ ├── summary_impl.hpp │ ├── system_metric.hpp │ └── thread_local_value.hpp │ ├── reflection │ ├── internal │ │ ├── arg_list_macro.hpp │ │ ├── common_macro.hpp │ │ └── generate │ │ │ ├── arg_list_macro_gen.hpp │ │ │ └── member_macro.hpp │ ├── member_count.hpp │ ├── member_names.hpp │ ├── member_ptr.hpp │ ├── member_value.hpp │ ├── private_visitor.hpp │ ├── template_string.hpp │ ├── template_switch.hpp │ └── user_reflect_macro.hpp │ ├── standalone │ ├── cinatra │ │ ├── brzip.hpp │ │ ├── cinatra_log_wrapper.hpp │ │ ├── cookie.hpp │ │ ├── coro_http_client.hpp │ │ ├── coro_http_connection.hpp │ │ ├── coro_http_request.hpp │ │ ├── coro_http_response.hpp │ │ ├── coro_http_router.hpp │ │ ├── coro_http_server.hpp │ │ ├── coro_radix_tree.hpp │ │ ├── define.h │ │ ├── gzip.hpp │ │ ├── http_parser.hpp │ │ ├── io_service_pool.hpp │ │ ├── mime_types.hpp │ │ ├── multipart.hpp │ │ ├── picohttpparser.h │ │ ├── response_cv.hpp │ │ ├── session.hpp │ │ ├── session_manager.hpp │ │ ├── sha1.hpp │ │ ├── smtp_client.hpp │ │ ├── string_resize.hpp │ │ ├── time_util.hpp │ │ ├── uri.hpp │ │ ├── url_encode_decode.hpp │ │ ├── use_asio.hpp │ │ ├── utils.hpp │ │ ├── version.hpp │ │ ├── websocket.hpp │ │ └── ws_define.h │ └── iguana │ │ ├── common.hpp │ │ ├── define.h │ │ ├── detail │ │ ├── charconv.h │ │ ├── dragonbox.h │ │ ├── dragonbox_to_chars.h │ │ ├── fast_float.h │ │ ├── itoa.hpp │ │ ├── pb_type.hpp │ │ ├── string_resize.hpp │ │ ├── string_stream.hpp │ │ ├── traits.hpp │ │ └── utf.hpp │ │ ├── dynamic.hpp │ │ ├── error_code.h │ │ ├── field_reflection.hpp │ │ ├── iguana.hpp │ │ ├── json_reader.hpp │ │ ├── json_util.hpp │ │ ├── json_writer.hpp │ │ ├── pb_reader.hpp │ │ ├── pb_util.hpp │ │ ├── pb_writer.hpp │ │ ├── prettify.hpp │ │ ├── util.hpp │ │ ├── value.hpp │ │ ├── version.hpp │ │ ├── xml_reader.hpp │ │ ├── xml_util.hpp │ │ ├── xml_writer.hpp │ │ ├── yaml_reader.hpp │ │ ├── yaml_util.hpp │ │ └── yaml_writer.hpp │ ├── struct_json │ ├── json_reader.h │ └── json_writer.h │ ├── struct_pack.hpp │ ├── struct_pack │ ├── alignment.hpp │ ├── calculate_size.hpp │ ├── compatible.hpp │ ├── derived_helper.hpp │ ├── derived_marco.hpp │ ├── endian_wrapper.hpp │ ├── error_code.hpp │ ├── foreach_macro.h │ ├── marco.h │ ├── md5_constexpr.hpp │ ├── packer.hpp │ ├── reflection.hpp │ ├── size_info.hpp │ ├── trivial_view.hpp │ ├── tuple.hpp │ ├── type_calculate.hpp │ ├── type_id.hpp │ ├── type_trait.hpp │ ├── unpacker.hpp │ ├── user_helper.hpp │ ├── util.h │ └── varint.hpp │ ├── struct_pb.hpp │ ├── struct_pb │ └── struct_pb_impl.hpp │ ├── struct_xml │ ├── xml_reader.h │ └── xml_writer.h │ ├── struct_yaml │ ├── yaml_reader.h │ └── yaml_writer.h │ ├── thirdparty │ ├── asio.hpp │ ├── asio │ │ ├── any_io_executor.hpp │ │ ├── append.hpp │ │ ├── as_tuple.hpp │ │ ├── associated_allocator.hpp │ │ ├── associated_cancellation_slot.hpp │ │ ├── associated_executor.hpp │ │ ├── associator.hpp │ │ ├── async_result.hpp │ │ ├── awaitable.hpp │ │ ├── basic_datagram_socket.hpp │ │ ├── basic_deadline_timer.hpp │ │ ├── basic_file.hpp │ │ ├── basic_io_object.hpp │ │ ├── basic_random_access_file.hpp │ │ ├── basic_raw_socket.hpp │ │ ├── basic_readable_pipe.hpp │ │ ├── basic_seq_packet_socket.hpp │ │ ├── basic_serial_port.hpp │ │ ├── basic_signal_set.hpp │ │ ├── basic_socket.hpp │ │ ├── basic_socket_acceptor.hpp │ │ ├── basic_socket_iostream.hpp │ │ ├── basic_socket_streambuf.hpp │ │ ├── basic_stream_file.hpp │ │ ├── basic_stream_socket.hpp │ │ ├── basic_streambuf.hpp │ │ ├── basic_streambuf_fwd.hpp │ │ ├── basic_waitable_timer.hpp │ │ ├── basic_writable_pipe.hpp │ │ ├── bind_allocator.hpp │ │ ├── bind_cancellation_slot.hpp │ │ ├── bind_executor.hpp │ │ ├── buffer.hpp │ │ ├── buffer_registration.hpp │ │ ├── buffered_read_stream.hpp │ │ ├── buffered_read_stream_fwd.hpp │ │ ├── buffered_stream.hpp │ │ ├── buffered_stream_fwd.hpp │ │ ├── buffered_write_stream.hpp │ │ ├── buffered_write_stream_fwd.hpp │ │ ├── buffers_iterator.hpp │ │ ├── cancellation_signal.hpp │ │ ├── cancellation_state.hpp │ │ ├── cancellation_type.hpp │ │ ├── co_spawn.hpp │ │ ├── completion_condition.hpp │ │ ├── compose.hpp │ │ ├── connect.hpp │ │ ├── connect_pipe.hpp │ │ ├── coroutine.hpp │ │ ├── deadline_timer.hpp │ │ ├── defer.hpp │ │ ├── deferred.hpp │ │ ├── detached.hpp │ │ ├── detail │ │ │ ├── array.hpp │ │ │ ├── array_fwd.hpp │ │ │ ├── assert.hpp │ │ │ ├── atomic_count.hpp │ │ │ ├── base_from_cancellation_state.hpp │ │ │ ├── base_from_completion_cond.hpp │ │ │ ├── bind_handler.hpp │ │ │ ├── blocking_executor_op.hpp │ │ │ ├── buffer_resize_guard.hpp │ │ │ ├── buffer_sequence_adapter.hpp │ │ │ ├── buffered_stream_storage.hpp │ │ │ ├── bulk_executor_op.hpp │ │ │ ├── call_stack.hpp │ │ │ ├── chrono.hpp │ │ │ ├── chrono_time_traits.hpp │ │ │ ├── completion_handler.hpp │ │ │ ├── concurrency_hint.hpp │ │ │ ├── conditionally_enabled_event.hpp │ │ │ ├── conditionally_enabled_mutex.hpp │ │ │ ├── config.hpp │ │ │ ├── consuming_buffers.hpp │ │ │ ├── cstddef.hpp │ │ │ ├── cstdint.hpp │ │ │ ├── date_time_fwd.hpp │ │ │ ├── deadline_timer_service.hpp │ │ │ ├── dependent_type.hpp │ │ │ ├── descriptor_ops.hpp │ │ │ ├── descriptor_read_op.hpp │ │ │ ├── descriptor_write_op.hpp │ │ │ ├── dev_poll_reactor.hpp │ │ │ ├── epoll_reactor.hpp │ │ │ ├── event.hpp │ │ │ ├── eventfd_select_interrupter.hpp │ │ │ ├── exception.hpp │ │ │ ├── executor_function.hpp │ │ │ ├── executor_op.hpp │ │ │ ├── fd_set_adapter.hpp │ │ │ ├── fenced_block.hpp │ │ │ ├── functional.hpp │ │ │ ├── future.hpp │ │ │ ├── gcc_arm_fenced_block.hpp │ │ │ ├── gcc_hppa_fenced_block.hpp │ │ │ ├── gcc_sync_fenced_block.hpp │ │ │ ├── gcc_x86_fenced_block.hpp │ │ │ ├── global.hpp │ │ │ ├── handler_alloc_helpers.hpp │ │ │ ├── handler_cont_helpers.hpp │ │ │ ├── handler_invoke_helpers.hpp │ │ │ ├── handler_tracking.hpp │ │ │ ├── handler_type_requirements.hpp │ │ │ ├── handler_work.hpp │ │ │ ├── hash_map.hpp │ │ │ ├── impl │ │ │ │ ├── buffer_sequence_adapter.ipp │ │ │ │ ├── descriptor_ops.ipp │ │ │ │ ├── dev_poll_reactor.hpp │ │ │ │ ├── dev_poll_reactor.ipp │ │ │ │ ├── epoll_reactor.hpp │ │ │ │ ├── epoll_reactor.ipp │ │ │ │ ├── eventfd_select_interrupter.ipp │ │ │ │ ├── handler_tracking.ipp │ │ │ │ ├── io_uring_descriptor_service.ipp │ │ │ │ ├── io_uring_file_service.ipp │ │ │ │ ├── io_uring_service.hpp │ │ │ │ ├── io_uring_service.ipp │ │ │ │ ├── io_uring_socket_service_base.ipp │ │ │ │ ├── kqueue_reactor.hpp │ │ │ │ ├── kqueue_reactor.ipp │ │ │ │ ├── null_event.ipp │ │ │ │ ├── pipe_select_interrupter.ipp │ │ │ │ ├── posix_event.ipp │ │ │ │ ├── posix_mutex.ipp │ │ │ │ ├── posix_serial_port_service.ipp │ │ │ │ ├── posix_thread.ipp │ │ │ │ ├── posix_tss_ptr.ipp │ │ │ │ ├── reactive_descriptor_service.ipp │ │ │ │ ├── reactive_socket_service_base.ipp │ │ │ │ ├── resolver_service_base.ipp │ │ │ │ ├── scheduler.ipp │ │ │ │ ├── select_reactor.hpp │ │ │ │ ├── select_reactor.ipp │ │ │ │ ├── service_registry.hpp │ │ │ │ ├── service_registry.ipp │ │ │ │ ├── signal_set_service.ipp │ │ │ │ ├── socket_ops.ipp │ │ │ │ ├── socket_select_interrupter.ipp │ │ │ │ ├── strand_executor_service.hpp │ │ │ │ ├── strand_executor_service.ipp │ │ │ │ ├── strand_service.hpp │ │ │ │ ├── strand_service.ipp │ │ │ │ ├── thread_context.ipp │ │ │ │ ├── throw_error.ipp │ │ │ │ ├── timer_queue_ptime.ipp │ │ │ │ ├── timer_queue_set.ipp │ │ │ │ ├── win_event.ipp │ │ │ │ ├── win_iocp_file_service.ipp │ │ │ │ ├── win_iocp_handle_service.ipp │ │ │ │ ├── win_iocp_io_context.hpp │ │ │ │ ├── win_iocp_io_context.ipp │ │ │ │ ├── win_iocp_serial_port_service.ipp │ │ │ │ ├── win_iocp_socket_service_base.ipp │ │ │ │ ├── win_mutex.ipp │ │ │ │ ├── win_object_handle_service.ipp │ │ │ │ ├── win_static_mutex.ipp │ │ │ │ ├── win_thread.ipp │ │ │ │ ├── win_tss_ptr.ipp │ │ │ │ ├── winrt_ssocket_service_base.ipp │ │ │ │ ├── winrt_timer_scheduler.hpp │ │ │ │ ├── winrt_timer_scheduler.ipp │ │ │ │ └── winsock_init.ipp │ │ │ ├── io_control.hpp │ │ │ ├── io_object_impl.hpp │ │ │ ├── io_uring_descriptor_read_at_op.hpp │ │ │ ├── io_uring_descriptor_read_op.hpp │ │ │ ├── io_uring_descriptor_service.hpp │ │ │ ├── io_uring_descriptor_write_at_op.hpp │ │ │ ├── io_uring_descriptor_write_op.hpp │ │ │ ├── io_uring_file_service.hpp │ │ │ ├── io_uring_null_buffers_op.hpp │ │ │ ├── io_uring_operation.hpp │ │ │ ├── io_uring_service.hpp │ │ │ ├── io_uring_socket_accept_op.hpp │ │ │ ├── io_uring_socket_connect_op.hpp │ │ │ ├── io_uring_socket_recv_op.hpp │ │ │ ├── io_uring_socket_recvfrom_op.hpp │ │ │ ├── io_uring_socket_recvmsg_op.hpp │ │ │ ├── io_uring_socket_send_op.hpp │ │ │ ├── io_uring_socket_sendto_op.hpp │ │ │ ├── io_uring_socket_service.hpp │ │ │ ├── io_uring_socket_service_base.hpp │ │ │ ├── io_uring_wait_op.hpp │ │ │ ├── is_buffer_sequence.hpp │ │ │ ├── is_executor.hpp │ │ │ ├── keyword_tss_ptr.hpp │ │ │ ├── kqueue_reactor.hpp │ │ │ ├── limits.hpp │ │ │ ├── local_free_on_block_exit.hpp │ │ │ ├── macos_fenced_block.hpp │ │ │ ├── memory.hpp │ │ │ ├── mutex.hpp │ │ │ ├── non_const_lvalue.hpp │ │ │ ├── noncopyable.hpp │ │ │ ├── null_event.hpp │ │ │ ├── null_fenced_block.hpp │ │ │ ├── null_global.hpp │ │ │ ├── null_mutex.hpp │ │ │ ├── null_reactor.hpp │ │ │ ├── null_signal_blocker.hpp │ │ │ ├── null_socket_service.hpp │ │ │ ├── null_static_mutex.hpp │ │ │ ├── null_thread.hpp │ │ │ ├── null_tss_ptr.hpp │ │ │ ├── object_pool.hpp │ │ │ ├── old_win_sdk_compat.hpp │ │ │ ├── op_queue.hpp │ │ │ ├── operation.hpp │ │ │ ├── pipe_select_interrupter.hpp │ │ │ ├── pop_options.hpp │ │ │ ├── posix_event.hpp │ │ │ ├── posix_fd_set_adapter.hpp │ │ │ ├── posix_global.hpp │ │ │ ├── posix_mutex.hpp │ │ │ ├── posix_serial_port_service.hpp │ │ │ ├── posix_signal_blocker.hpp │ │ │ ├── posix_static_mutex.hpp │ │ │ ├── posix_thread.hpp │ │ │ ├── posix_tss_ptr.hpp │ │ │ ├── push_options.hpp │ │ │ ├── reactive_descriptor_service.hpp │ │ │ ├── reactive_null_buffers_op.hpp │ │ │ ├── reactive_socket_accept_op.hpp │ │ │ ├── reactive_socket_connect_op.hpp │ │ │ ├── reactive_socket_recv_op.hpp │ │ │ ├── reactive_socket_recvfrom_op.hpp │ │ │ ├── reactive_socket_recvmsg_op.hpp │ │ │ ├── reactive_socket_send_op.hpp │ │ │ ├── reactive_socket_sendto_op.hpp │ │ │ ├── reactive_socket_service.hpp │ │ │ ├── reactive_socket_service_base.hpp │ │ │ ├── reactive_wait_op.hpp │ │ │ ├── reactor.hpp │ │ │ ├── reactor_op.hpp │ │ │ ├── reactor_op_queue.hpp │ │ │ ├── recycling_allocator.hpp │ │ │ ├── regex_fwd.hpp │ │ │ ├── resolve_endpoint_op.hpp │ │ │ ├── resolve_op.hpp │ │ │ ├── resolve_query_op.hpp │ │ │ ├── resolver_service.hpp │ │ │ ├── resolver_service_base.hpp │ │ │ ├── scheduler.hpp │ │ │ ├── scheduler_operation.hpp │ │ │ ├── scheduler_task.hpp │ │ │ ├── scheduler_thread_info.hpp │ │ │ ├── scoped_lock.hpp │ │ │ ├── scoped_ptr.hpp │ │ │ ├── select_interrupter.hpp │ │ │ ├── select_reactor.hpp │ │ │ ├── service_registry.hpp │ │ │ ├── signal_blocker.hpp │ │ │ ├── signal_handler.hpp │ │ │ ├── signal_init.hpp │ │ │ ├── signal_op.hpp │ │ │ ├── signal_set_service.hpp │ │ │ ├── socket_holder.hpp │ │ │ ├── socket_ops.hpp │ │ │ ├── socket_option.hpp │ │ │ ├── socket_select_interrupter.hpp │ │ │ ├── socket_types.hpp │ │ │ ├── solaris_fenced_block.hpp │ │ │ ├── source_location.hpp │ │ │ ├── static_mutex.hpp │ │ │ ├── std_event.hpp │ │ │ ├── std_fenced_block.hpp │ │ │ ├── std_global.hpp │ │ │ ├── std_mutex.hpp │ │ │ ├── std_static_mutex.hpp │ │ │ ├── std_thread.hpp │ │ │ ├── strand_executor_service.hpp │ │ │ ├── strand_service.hpp │ │ │ ├── string_view.hpp │ │ │ ├── thread.hpp │ │ │ ├── thread_context.hpp │ │ │ ├── thread_group.hpp │ │ │ ├── thread_info_base.hpp │ │ │ ├── throw_error.hpp │ │ │ ├── throw_exception.hpp │ │ │ ├── timer_queue.hpp │ │ │ ├── timer_queue_base.hpp │ │ │ ├── timer_queue_ptime.hpp │ │ │ ├── timer_queue_set.hpp │ │ │ ├── timer_scheduler.hpp │ │ │ ├── timer_scheduler_fwd.hpp │ │ │ ├── tss_ptr.hpp │ │ │ ├── type_traits.hpp │ │ │ ├── utility.hpp │ │ │ ├── variadic_templates.hpp │ │ │ ├── wait_handler.hpp │ │ │ ├── wait_op.hpp │ │ │ ├── win_event.hpp │ │ │ ├── win_fd_set_adapter.hpp │ │ │ ├── win_fenced_block.hpp │ │ │ ├── win_global.hpp │ │ │ ├── win_iocp_file_service.hpp │ │ │ ├── win_iocp_handle_read_op.hpp │ │ │ ├── win_iocp_handle_service.hpp │ │ │ ├── win_iocp_handle_write_op.hpp │ │ │ ├── win_iocp_io_context.hpp │ │ │ ├── win_iocp_null_buffers_op.hpp │ │ │ ├── win_iocp_operation.hpp │ │ │ ├── win_iocp_overlapped_op.hpp │ │ │ ├── win_iocp_overlapped_ptr.hpp │ │ │ ├── win_iocp_serial_port_service.hpp │ │ │ ├── win_iocp_socket_accept_op.hpp │ │ │ ├── win_iocp_socket_connect_op.hpp │ │ │ ├── win_iocp_socket_recv_op.hpp │ │ │ ├── win_iocp_socket_recvfrom_op.hpp │ │ │ ├── win_iocp_socket_recvmsg_op.hpp │ │ │ ├── win_iocp_socket_send_op.hpp │ │ │ ├── win_iocp_socket_service.hpp │ │ │ ├── win_iocp_socket_service_base.hpp │ │ │ ├── win_iocp_thread_info.hpp │ │ │ ├── win_iocp_wait_op.hpp │ │ │ ├── win_mutex.hpp │ │ │ ├── win_object_handle_service.hpp │ │ │ ├── win_static_mutex.hpp │ │ │ ├── win_thread.hpp │ │ │ ├── win_tss_ptr.hpp │ │ │ ├── winapp_thread.hpp │ │ │ ├── wince_thread.hpp │ │ │ ├── winrt_async_manager.hpp │ │ │ ├── winrt_async_op.hpp │ │ │ ├── winrt_resolve_op.hpp │ │ │ ├── winrt_resolver_service.hpp │ │ │ ├── winrt_socket_connect_op.hpp │ │ │ ├── winrt_socket_recv_op.hpp │ │ │ ├── winrt_socket_send_op.hpp │ │ │ ├── winrt_ssocket_service.hpp │ │ │ ├── winrt_ssocket_service_base.hpp │ │ │ ├── winrt_timer_scheduler.hpp │ │ │ ├── winrt_utils.hpp │ │ │ ├── winsock_init.hpp │ │ │ ├── work_dispatcher.hpp │ │ │ └── wrapped_handler.hpp │ │ ├── dispatch.hpp │ │ ├── error.hpp │ │ ├── error_code.hpp │ │ ├── execution.hpp │ │ ├── execution │ │ │ ├── allocator.hpp │ │ │ ├── any_executor.hpp │ │ │ ├── bad_executor.hpp │ │ │ ├── blocking.hpp │ │ │ ├── blocking_adaptation.hpp │ │ │ ├── bulk_execute.hpp │ │ │ ├── bulk_guarantee.hpp │ │ │ ├── connect.hpp │ │ │ ├── context.hpp │ │ │ ├── context_as.hpp │ │ │ ├── detail │ │ │ │ ├── as_invocable.hpp │ │ │ │ ├── as_operation.hpp │ │ │ │ ├── as_receiver.hpp │ │ │ │ ├── bulk_sender.hpp │ │ │ │ ├── submit_receiver.hpp │ │ │ │ └── void_receiver.hpp │ │ │ ├── execute.hpp │ │ │ ├── executor.hpp │ │ │ ├── impl │ │ │ │ ├── bad_executor.ipp │ │ │ │ └── receiver_invocation_error.ipp │ │ │ ├── invocable_archetype.hpp │ │ │ ├── mapping.hpp │ │ │ ├── occupancy.hpp │ │ │ ├── operation_state.hpp │ │ │ ├── outstanding_work.hpp │ │ │ ├── prefer_only.hpp │ │ │ ├── receiver.hpp │ │ │ ├── receiver_invocation_error.hpp │ │ │ ├── relationship.hpp │ │ │ ├── schedule.hpp │ │ │ ├── scheduler.hpp │ │ │ ├── sender.hpp │ │ │ ├── set_done.hpp │ │ │ ├── set_error.hpp │ │ │ ├── set_value.hpp │ │ │ ├── start.hpp │ │ │ └── submit.hpp │ │ ├── execution_context.hpp │ │ ├── executor.hpp │ │ ├── executor_work_guard.hpp │ │ ├── experimental │ │ │ ├── append.hpp │ │ │ ├── as_single.hpp │ │ │ ├── as_tuple.hpp │ │ │ ├── awaitable_operators.hpp │ │ │ ├── basic_channel.hpp │ │ │ ├── basic_concurrent_channel.hpp │ │ │ ├── cancellation_condition.hpp │ │ │ ├── channel.hpp │ │ │ ├── channel_error.hpp │ │ │ ├── channel_traits.hpp │ │ │ ├── co_spawn.hpp │ │ │ ├── concurrent_channel.hpp │ │ │ ├── coro.hpp │ │ │ ├── coro_traits.hpp │ │ │ ├── deferred.hpp │ │ │ ├── detail │ │ │ │ ├── channel_handler.hpp │ │ │ │ ├── channel_message.hpp │ │ │ │ ├── channel_operation.hpp │ │ │ │ ├── channel_payload.hpp │ │ │ │ ├── channel_receive_op.hpp │ │ │ │ ├── channel_send_functions.hpp │ │ │ │ ├── channel_send_op.hpp │ │ │ │ ├── channel_service.hpp │ │ │ │ ├── completion_handler_erasure.hpp │ │ │ │ ├── coro_promise_allocator.hpp │ │ │ │ ├── has_signature.hpp │ │ │ │ ├── impl │ │ │ │ │ └── channel_service.hpp │ │ │ │ └── partial_promise.hpp │ │ │ ├── impl │ │ │ │ ├── as_single.hpp │ │ │ │ ├── channel_error.ipp │ │ │ │ ├── coro.hpp │ │ │ │ ├── parallel_group.hpp │ │ │ │ ├── promise.hpp │ │ │ │ └── use_coro.hpp │ │ │ ├── parallel_group.hpp │ │ │ ├── prepend.hpp │ │ │ ├── promise.hpp │ │ │ └── use_coro.hpp │ │ ├── file_base.hpp │ │ ├── generic │ │ │ ├── basic_endpoint.hpp │ │ │ ├── datagram_protocol.hpp │ │ │ ├── detail │ │ │ │ ├── endpoint.hpp │ │ │ │ └── impl │ │ │ │ │ └── endpoint.ipp │ │ │ ├── raw_protocol.hpp │ │ │ ├── seq_packet_protocol.hpp │ │ │ └── stream_protocol.hpp │ │ ├── handler_alloc_hook.hpp │ │ ├── handler_continuation_hook.hpp │ │ ├── handler_invoke_hook.hpp │ │ ├── high_resolution_timer.hpp │ │ ├── impl │ │ │ ├── any_io_executor.ipp │ │ │ ├── append.hpp │ │ │ ├── as_tuple.hpp │ │ │ ├── awaitable.hpp │ │ │ ├── buffered_read_stream.hpp │ │ │ ├── buffered_write_stream.hpp │ │ │ ├── cancellation_signal.ipp │ │ │ ├── co_spawn.hpp │ │ │ ├── connect.hpp │ │ │ ├── connect_pipe.hpp │ │ │ ├── connect_pipe.ipp │ │ │ ├── defer.hpp │ │ │ ├── deferred.hpp │ │ │ ├── detached.hpp │ │ │ ├── dispatch.hpp │ │ │ ├── error.ipp │ │ │ ├── error_code.ipp │ │ │ ├── execution_context.hpp │ │ │ ├── execution_context.ipp │ │ │ ├── executor.hpp │ │ │ ├── executor.ipp │ │ │ ├── handler_alloc_hook.ipp │ │ │ ├── io_context.hpp │ │ │ ├── io_context.ipp │ │ │ ├── multiple_exceptions.ipp │ │ │ ├── post.hpp │ │ │ ├── prepend.hpp │ │ │ ├── read.hpp │ │ │ ├── read_at.hpp │ │ │ ├── read_until.hpp │ │ │ ├── redirect_error.hpp │ │ │ ├── serial_port_base.hpp │ │ │ ├── serial_port_base.ipp │ │ │ ├── spawn.hpp │ │ │ ├── src.hpp │ │ │ ├── system_context.hpp │ │ │ ├── system_context.ipp │ │ │ ├── system_executor.hpp │ │ │ ├── thread_pool.hpp │ │ │ ├── thread_pool.ipp │ │ │ ├── use_awaitable.hpp │ │ │ ├── use_future.hpp │ │ │ ├── write.hpp │ │ │ └── write_at.hpp │ │ ├── io_context.hpp │ │ ├── io_context_strand.hpp │ │ ├── io_service.hpp │ │ ├── io_service_strand.hpp │ │ ├── ip │ │ │ ├── address.hpp │ │ │ ├── address_v4.hpp │ │ │ ├── address_v4_iterator.hpp │ │ │ ├── address_v4_range.hpp │ │ │ ├── address_v6.hpp │ │ │ ├── address_v6_iterator.hpp │ │ │ ├── address_v6_range.hpp │ │ │ ├── bad_address_cast.hpp │ │ │ ├── basic_endpoint.hpp │ │ │ ├── basic_resolver.hpp │ │ │ ├── basic_resolver_entry.hpp │ │ │ ├── basic_resolver_iterator.hpp │ │ │ ├── basic_resolver_query.hpp │ │ │ ├── basic_resolver_results.hpp │ │ │ ├── detail │ │ │ │ ├── endpoint.hpp │ │ │ │ ├── impl │ │ │ │ │ └── endpoint.ipp │ │ │ │ └── socket_option.hpp │ │ │ ├── host_name.hpp │ │ │ ├── icmp.hpp │ │ │ ├── impl │ │ │ │ ├── address.hpp │ │ │ │ ├── address.ipp │ │ │ │ ├── address_v4.hpp │ │ │ │ ├── address_v4.ipp │ │ │ │ ├── address_v6.hpp │ │ │ │ ├── address_v6.ipp │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ ├── host_name.ipp │ │ │ │ ├── network_v4.hpp │ │ │ │ ├── network_v4.ipp │ │ │ │ ├── network_v6.hpp │ │ │ │ └── network_v6.ipp │ │ │ ├── multicast.hpp │ │ │ ├── network_v4.hpp │ │ │ ├── network_v6.hpp │ │ │ ├── resolver_base.hpp │ │ │ ├── resolver_query_base.hpp │ │ │ ├── tcp.hpp │ │ │ ├── udp.hpp │ │ │ ├── unicast.hpp │ │ │ └── v6_only.hpp │ │ ├── is_applicable_property.hpp │ │ ├── is_contiguous_iterator.hpp │ │ ├── is_executor.hpp │ │ ├── is_read_buffered.hpp │ │ ├── is_write_buffered.hpp │ │ ├── local │ │ │ ├── basic_endpoint.hpp │ │ │ ├── connect_pair.hpp │ │ │ ├── datagram_protocol.hpp │ │ │ ├── detail │ │ │ │ ├── endpoint.hpp │ │ │ │ └── impl │ │ │ │ │ └── endpoint.ipp │ │ │ └── stream_protocol.hpp │ │ ├── multiple_exceptions.hpp │ │ ├── packaged_task.hpp │ │ ├── placeholders.hpp │ │ ├── posix │ │ │ ├── basic_descriptor.hpp │ │ │ ├── basic_stream_descriptor.hpp │ │ │ ├── descriptor.hpp │ │ │ ├── descriptor_base.hpp │ │ │ └── stream_descriptor.hpp │ │ ├── post.hpp │ │ ├── prefer.hpp │ │ ├── prepend.hpp │ │ ├── query.hpp │ │ ├── random_access_file.hpp │ │ ├── read.hpp │ │ ├── read_at.hpp │ │ ├── read_until.hpp │ │ ├── readable_pipe.hpp │ │ ├── recycling_allocator.hpp │ │ ├── redirect_error.hpp │ │ ├── registered_buffer.hpp │ │ ├── require.hpp │ │ ├── require_concept.hpp │ │ ├── serial_port.hpp │ │ ├── serial_port_base.hpp │ │ ├── signal_set.hpp │ │ ├── socket_base.hpp │ │ ├── spawn.hpp │ │ ├── ssl.hpp │ │ ├── ssl │ │ │ ├── context.hpp │ │ │ ├── context_base.hpp │ │ │ ├── detail │ │ │ │ ├── buffered_handshake_op.hpp │ │ │ │ ├── engine.hpp │ │ │ │ ├── handshake_op.hpp │ │ │ │ ├── impl │ │ │ │ │ ├── engine.ipp │ │ │ │ │ └── openssl_init.ipp │ │ │ │ ├── io.hpp │ │ │ │ ├── openssl_init.hpp │ │ │ │ ├── openssl_types.hpp │ │ │ │ ├── password_callback.hpp │ │ │ │ ├── read_op.hpp │ │ │ │ ├── shutdown_op.hpp │ │ │ │ ├── stream_core.hpp │ │ │ │ ├── verify_callback.hpp │ │ │ │ └── write_op.hpp │ │ │ ├── error.hpp │ │ │ ├── host_name_verification.hpp │ │ │ ├── impl │ │ │ │ ├── context.hpp │ │ │ │ ├── context.ipp │ │ │ │ ├── error.ipp │ │ │ │ ├── host_name_verification.ipp │ │ │ │ ├── rfc2818_verification.ipp │ │ │ │ └── src.hpp │ │ │ ├── rfc2818_verification.hpp │ │ │ ├── stream.hpp │ │ │ ├── stream_base.hpp │ │ │ ├── verify_context.hpp │ │ │ └── verify_mode.hpp │ │ ├── static_thread_pool.hpp │ │ ├── steady_timer.hpp │ │ ├── strand.hpp │ │ ├── stream_file.hpp │ │ ├── streambuf.hpp │ │ ├── system_context.hpp │ │ ├── system_error.hpp │ │ ├── system_executor.hpp │ │ ├── system_timer.hpp │ │ ├── this_coro.hpp │ │ ├── thread.hpp │ │ ├── thread_pool.hpp │ │ ├── time_traits.hpp │ │ ├── traits │ │ │ ├── bulk_execute_free.hpp │ │ │ ├── bulk_execute_member.hpp │ │ │ ├── connect_free.hpp │ │ │ ├── connect_member.hpp │ │ │ ├── equality_comparable.hpp │ │ │ ├── execute_free.hpp │ │ │ ├── execute_member.hpp │ │ │ ├── prefer_free.hpp │ │ │ ├── prefer_member.hpp │ │ │ ├── query_free.hpp │ │ │ ├── query_member.hpp │ │ │ ├── query_static_constexpr_member.hpp │ │ │ ├── require_concept_free.hpp │ │ │ ├── require_concept_member.hpp │ │ │ ├── require_free.hpp │ │ │ ├── require_member.hpp │ │ │ ├── schedule_free.hpp │ │ │ ├── schedule_member.hpp │ │ │ ├── set_done_free.hpp │ │ │ ├── set_done_member.hpp │ │ │ ├── set_error_free.hpp │ │ │ ├── set_error_member.hpp │ │ │ ├── set_value_free.hpp │ │ │ ├── set_value_member.hpp │ │ │ ├── start_free.hpp │ │ │ ├── start_member.hpp │ │ │ ├── static_query.hpp │ │ │ ├── static_require.hpp │ │ │ ├── static_require_concept.hpp │ │ │ ├── submit_free.hpp │ │ │ └── submit_member.hpp │ │ ├── ts │ │ │ ├── buffer.hpp │ │ │ ├── executor.hpp │ │ │ ├── internet.hpp │ │ │ ├── io_context.hpp │ │ │ ├── net.hpp │ │ │ ├── netfwd.hpp │ │ │ ├── socket.hpp │ │ │ └── timer.hpp │ │ ├── unyield.hpp │ │ ├── use_awaitable.hpp │ │ ├── use_future.hpp │ │ ├── uses_executor.hpp │ │ ├── version.hpp │ │ ├── wait_traits.hpp │ │ ├── windows │ │ │ ├── basic_object_handle.hpp │ │ │ ├── basic_overlapped_handle.hpp │ │ │ ├── basic_random_access_handle.hpp │ │ │ ├── basic_stream_handle.hpp │ │ │ ├── object_handle.hpp │ │ │ ├── overlapped_handle.hpp │ │ │ ├── overlapped_ptr.hpp │ │ │ ├── random_access_handle.hpp │ │ │ └── stream_handle.hpp │ │ ├── writable_pipe.hpp │ │ ├── write.hpp │ │ ├── write_at.hpp │ │ └── yield.hpp │ ├── async_simple │ │ ├── Collect.h │ │ ├── Common.h │ │ ├── CommonMacros.h │ │ ├── Executor.h │ │ ├── Future.h │ │ ├── FutureState.h │ │ ├── IOExecutor.h │ │ ├── LocalState.h │ │ ├── MoveWrapper.h │ │ ├── Promise.h │ │ ├── Signal.h │ │ ├── Traits.h │ │ ├── Try.h │ │ ├── Unit.h │ │ ├── async_simple.cppm │ │ ├── coro │ │ │ ├── Collect.h │ │ │ ├── ConditionVariable.h │ │ │ ├── CountEvent.h │ │ │ ├── DetachedCoroutine.h │ │ │ ├── Dispatch.h │ │ │ ├── FutureAwaiter.h │ │ │ ├── Generator.h │ │ │ ├── Latch.h │ │ │ ├── Lazy.h │ │ │ ├── LazyLocalBase.h │ │ │ ├── Mutex.h │ │ │ ├── PromiseAllocator.h │ │ │ ├── ResumeBySchedule.h │ │ │ ├── Semaphore.h │ │ │ ├── SharedMutex.h │ │ │ ├── Sleep.h │ │ │ ├── SpinLock.h │ │ │ ├── SyncAwait.h │ │ │ ├── Traits.h │ │ │ └── ViaCoroutine.h │ │ ├── executors │ │ │ ├── SimpleExecutor.h │ │ │ └── SimpleIOExecutor.h │ │ ├── experimental │ │ │ └── coroutine.h │ │ ├── std.mock.cppm │ │ ├── uthread │ │ │ ├── Async.h │ │ │ ├── Await.h │ │ │ ├── Collect.h │ │ │ ├── Latch.h │ │ │ ├── Uthread.h │ │ │ └── internal │ │ │ │ ├── Darwin │ │ │ │ ├── arm64 │ │ │ │ │ ├── jump_arm64_aapcs_macho_gas.S │ │ │ │ │ ├── make_arm64_aapcs_macho_gas.S │ │ │ │ │ └── ontop_arm64_aapcs_macho_gas.S │ │ │ │ └── x86_64 │ │ │ │ │ ├── jump_x86_64_sysv_macho_gas.S │ │ │ │ │ ├── make_x86_64_sysv_macho_gas.S │ │ │ │ │ └── ontop_x86_64_sysv_macho_gas.S │ │ │ │ ├── Linux │ │ │ │ ├── aarch64 │ │ │ │ │ ├── jump_arm64_aapcs_elf_gas.S │ │ │ │ │ ├── make_arm64_aapcs_elf_gas.S │ │ │ │ │ └── ontop_arm64_aapcs_elf_gas.S │ │ │ │ ├── ppc64le │ │ │ │ │ ├── jump_ppc64_sysv_elf_gas.S │ │ │ │ │ ├── make_ppc64_sysv_elf_gas.S │ │ │ │ │ └── ontop_ppc64_sysv_elf_gas.S │ │ │ │ └── x86_64 │ │ │ │ │ ├── jump_x86_64_sysv_elf_gas.S │ │ │ │ │ ├── make_x86_64_sysv_elf_gas.S │ │ │ │ │ └── ontop_x86_64_sysv_elf_gas.S │ │ │ │ ├── thread.cc │ │ │ │ ├── thread.h │ │ │ │ └── thread_impl.h │ │ └── util │ │ │ ├── Condition.h │ │ │ ├── Queue.h │ │ │ ├── ThreadPool.h │ │ │ └── move_only_function.h │ └── frozen │ │ ├── CMakeLists.txt │ │ ├── algorithm.h │ │ ├── bits │ │ ├── algorithms.h │ │ ├── basic_types.h │ │ ├── constexpr_assert.h │ │ ├── defines.h │ │ ├── elsa.h │ │ ├── elsa_std.h │ │ ├── exceptions.h │ │ ├── hash_string.h │ │ ├── pmh.h │ │ └── version.h │ │ ├── map.h │ │ ├── random.h │ │ ├── set.h │ │ ├── string.h │ │ ├── unordered_map.h │ │ └── unordered_set.h │ ├── util │ ├── atomic_shared_ptr.hpp │ ├── concurrentqueue.h │ ├── dragonbox.h │ ├── dragonbox_to_chars.h │ ├── expected.hpp │ ├── function_name.h │ ├── magic_names.hpp │ ├── map_sharded.hpp │ ├── meta_string.hpp │ ├── string_finder.hpp │ ├── time_util.h │ ├── tl │ │ └── expected.hpp │ ├── type_traits.h │ └── utils.hpp │ └── version.hpp ├── src ├── coro_http │ ├── examples │ │ ├── CMakeLists.txt │ │ ├── chat_room.cpp │ │ ├── client.html │ │ ├── example.cpp │ │ ├── load_balancer.cpp │ │ └── py_example │ │ │ ├── py_example.cpp │ │ │ └── test.py │ └── tests │ │ ├── CMakeLists.txt │ │ ├── main.cpp │ │ ├── openssl_files │ │ ├── server.crt │ │ └── server.key │ │ ├── test_cinatra.cpp │ │ ├── test_cinatra_websocket.cpp │ │ ├── test_coro_http_server.cpp │ │ └── test_http_parse.cpp ├── coro_io │ ├── examples │ │ ├── CMakeLists.txt │ │ └── main.cpp │ └── tests │ │ ├── CMakeLists.txt │ │ ├── ibverbs │ │ ├── CMakeLists.txt │ │ ├── ib_socket_pressure_test.cpp │ │ ├── main.cpp │ │ ├── test_device.cpp │ │ └── test_ib_socket.cpp │ │ ├── main.cpp │ │ ├── test_cancel.cpp │ │ ├── test_client_pool.cpp │ │ ├── test_coro_channel.cpp │ │ ├── test_corofile.cpp │ │ ├── test_load_balancer.cpp │ │ └── test_rate_limiter.cpp ├── coro_rpc │ ├── benchmark │ │ ├── CMakeLists.txt │ │ ├── api │ │ │ ├── Monster.h │ │ │ ├── Rect.h │ │ │ ├── ValidateRequest.h │ │ │ └── rpc_functions.hpp │ │ ├── bench.cpp │ │ ├── client.cpp │ │ ├── cmdline.h │ │ ├── data_gen.cpp │ │ ├── server.cpp │ │ └── server.hpp │ ├── examples │ │ ├── CMakeLists.txt │ │ ├── base_examples │ │ │ ├── CMakeLists.txt │ │ │ ├── client.cpp │ │ │ ├── client_pool.cpp │ │ │ ├── client_pools.cpp │ │ │ ├── concurrent_clients.cpp │ │ │ ├── coro_rpc_lib │ │ │ │ ├── coro_rpc.cpp │ │ │ │ └── coro_rpc.h │ │ │ ├── go_example │ │ │ │ └── test_rpc.go │ │ │ ├── load_balancer.cpp │ │ │ ├── rpc_service.cpp │ │ │ ├── rpc_service.h │ │ │ └── server.cpp │ │ ├── file_transfer │ │ │ ├── BUILD.bazel │ │ │ ├── CMakeLists.txt │ │ │ ├── file_client.cpp │ │ │ ├── file_server.cpp │ │ │ ├── rpc_service.cpp │ │ │ └── rpc_service.h │ │ ├── rdma_example │ │ │ ├── CMakeLists.txt │ │ │ └── rdma_example.cpp │ │ └── user_defined_rpc_protocol │ │ │ └── rest_rpc │ │ │ ├── CMakeLists.txt │ │ │ ├── config │ │ │ ├── msgpack_protocol.hpp │ │ │ └── rest_rpc_protocol.hpp │ │ │ ├── rpc_service.h │ │ │ └── server │ │ │ ├── main.cpp │ │ │ └── rpc_service.cpp │ └── tests │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── ServerTester.hpp │ │ ├── inject_action.hpp │ │ ├── main.cpp │ │ ├── openssl_files │ │ ├── dh512.pem │ │ ├── dhparam.pem │ │ ├── fake_server.crt │ │ ├── fake_server.key │ │ ├── generate.txt │ │ ├── server.crt │ │ ├── server.csr │ │ └── server.key │ │ ├── rpc_api.cpp │ │ ├── rpc_api.hpp │ │ ├── test_connection.cpp │ │ ├── test_coro_rpc_client.cpp │ │ ├── test_coro_rpc_server.cpp │ │ ├── test_function_name.cpp │ │ ├── test_parallel.cpp │ │ ├── test_register_duplication_1.cpp │ │ ├── test_register_duplication_2.cpp │ │ ├── test_register_duplication_3.cpp │ │ ├── test_register_handler.cpp │ │ ├── test_router.cpp │ │ └── test_variadic.cpp ├── easylog │ ├── benchmark │ │ ├── CMakeLists.txt │ │ └── main.cpp │ └── tests │ │ ├── CMakeLists.txt │ │ ├── main.cpp │ │ └── test_easylog.cpp ├── include │ └── doctest.h ├── metric │ ├── benchmark │ │ ├── CMakeLists.txt │ │ ├── bench.hpp │ │ └── main.cpp │ └── tests │ │ ├── CMakeLists.txt │ │ ├── parallel_test.cpp │ │ ├── parallel_test2.cpp │ │ └── test_metric.cpp ├── reflection │ └── tests │ │ ├── CMakeLists.txt │ │ └── test_reflection.cpp ├── struct_json │ └── examples │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── main.cpp │ │ └── user_defined_struct.cpp ├── struct_pack │ ├── benchmark │ │ ├── .gitignore │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── ScopedTimer.hpp │ │ ├── benchmark.cpp │ │ ├── config.hpp │ │ ├── data_def.fbs │ │ ├── data_def.hpp │ │ ├── data_def.proto │ │ ├── flatbuffer_sample.hpp │ │ ├── msgpack_sample.hpp │ │ ├── no_op.cpp │ │ ├── no_op.h │ │ ├── protobuf_sample.hpp │ │ ├── sample.hpp │ │ ├── struct_pack_sample.hpp │ │ └── struct_pb_sample.hpp │ ├── examples │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── basic_usage.cpp │ │ ├── derived_class.cpp │ │ ├── main.cpp │ │ ├── non_aggregated_type.cpp │ │ ├── serialize_config.cpp │ │ └── user_defined_serialization.cpp │ └── tests │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── binary_data │ │ ├── BUILD.bazel │ │ ├── test_cross_platform.dat │ │ └── test_cross_platform_without_debug_info.dat │ │ ├── main.cpp │ │ ├── test_alignas.cpp │ │ ├── test_compatible.cpp │ │ ├── test_compile_time_calculate.cpp │ │ ├── test_cross_platform.cpp │ │ ├── test_data_struct.cpp │ │ ├── test_data_struct2.cpp │ │ ├── test_derived.cpp │ │ ├── test_derived.hpp │ │ ├── test_disable_meta_info.cpp │ │ ├── test_fast_varint.cpp │ │ ├── test_many_members.cpp │ │ ├── test_non_aggregated_type.cpp │ │ ├── test_pragma_pack.cpp │ │ ├── test_pragma_pack_and_alignas_mix.cpp │ │ ├── test_serialize.cpp │ │ ├── test_stream.cpp │ │ ├── test_struct.hpp │ │ ├── test_tuplet.cpp │ │ ├── test_type_info_config.cpp │ │ ├── test_user_defined_type.cpp │ │ └── test_varint.cpp ├── struct_pb │ ├── examples │ │ ├── CMakeLists.txt │ │ └── main.cpp │ ├── tests │ │ ├── CMakeLists.txt │ │ ├── data_def.proto │ │ ├── main.cpp │ │ ├── unittest_proto3.h │ │ └── unittest_proto3.proto │ └── tools │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── proto_to_struct.cpp │ │ ├── struct_code_generator.hpp │ │ └── struct_token.hpp ├── struct_xml │ └── examples │ │ ├── CMakeLists.txt │ │ └── main.cpp ├── struct_yaml │ └── examples │ │ ├── CMakeLists.txt │ │ └── main.cpp └── util │ └── tests │ ├── CMakeLists.txt │ ├── test_meta_string.cpp │ └── test_time_util.cpp ├── vcpkg.json └── website ├── .gitignore ├── .vitepress └── config │ ├── en_data.ts │ ├── en_locale.ts │ ├── index.ts │ ├── zh_data.ts │ └── zh_locale.ts ├── Doxyfile ├── Doxyfile_cn ├── README.md ├── docs ├── en │ ├── coro_rpc │ │ ├── coro_rpc_client.md │ │ ├── coro_rpc_introduction.md │ │ ├── coro_rpc_server.md │ │ └── images │ │ │ ├── easy_to_use.png │ │ │ ├── long_tail_qps.png │ │ │ ├── long_tail_time.png │ │ │ ├── max_qps.png │ │ │ ├── pingpong_qps.png │ │ │ └── pingpong_time.png │ ├── guide │ │ ├── how_to_use_as_git_submodule.md │ │ ├── how_to_use_by_cmake_find_package.md │ │ └── what_is_yalantinglibs.md │ ├── index.md │ ├── struct_pack │ │ ├── images │ │ │ ├── 1byte_size.png │ │ │ ├── 1byte_vec.png │ │ │ ├── 2byte_size.png │ │ │ ├── 2byte_vec.png │ │ │ ├── 4byte_size.png │ │ │ ├── 4byte_vec.png │ │ │ ├── layout │ │ │ │ ├── LEN_SIZE.drawio │ │ │ │ ├── array_layout.drawio │ │ │ │ ├── array_layout.svg │ │ │ │ ├── debug_person.drawio │ │ │ │ ├── debug_person.svg │ │ │ │ ├── expected.drawio │ │ │ │ ├── expected.svg │ │ │ │ ├── expected_with_error.drawio │ │ │ │ ├── expected_with_error.svg │ │ │ │ ├── hash_info.drawio │ │ │ │ ├── hash_info.svg │ │ │ │ ├── map_layout.drawio │ │ │ │ ├── map_layout.svg │ │ │ │ ├── memory_layout1.drawio │ │ │ │ ├── memory_layout1.svg │ │ │ │ ├── memory_layout2.drawio │ │ │ │ ├── memory_layout2.svg │ │ │ │ ├── meta_info.drawio │ │ │ │ ├── meta_info.svg │ │ │ │ ├── optional_has_value.drawio │ │ │ │ ├── optional_has_value.svg │ │ │ │ ├── optional_null.drawio │ │ │ │ ├── optional_null.svg │ │ │ │ ├── person_type_info.drawio │ │ │ │ ├── person_type_info.svg │ │ │ │ ├── release_person.drawio │ │ │ │ ├── release_person.svg │ │ │ │ ├── release_person_long_name.drawio │ │ │ │ ├── release_person_long_name.svg │ │ │ │ ├── release_person_with_compatible.drawio │ │ │ │ ├── release_person_with_compatible.svg │ │ │ │ ├── set_layout.drawio │ │ │ │ ├── set_layout.svg │ │ │ │ ├── string_layout.drawio │ │ │ │ ├── string_layout.svg │ │ │ │ ├── variant.drawio │ │ │ │ └── variant.svg │ │ │ ├── mem_layout_of_person.png │ │ │ ├── mem_layout_of_vec_int.png │ │ │ ├── mem_layout_of_vec_rect.png │ │ │ ├── struct_pack_bench_binary_size.png │ │ │ ├── struct_pack_bench_deserialize.png │ │ │ ├── struct_pack_bench_serialize.png │ │ │ └── type_system │ │ │ │ └── md5_generate.png │ │ ├── struct_pack_intro.md │ │ ├── struct_pack_layout.md │ │ ├── struct_pack_tips.md │ │ └── struct_pack_type_system.md │ └── struct_pb │ │ ├── images │ │ └── pb_format.jpeg │ │ └── struct_pb_intro.md ├── public │ ├── icon │ │ └── logo.svg │ ├── img │ │ └── yalantinglibs_ding_talk_group.png │ ├── index.html │ ├── index.js │ └── resource │ │ ├── A Faster Serialization Library Based on Compile-time Reflection and C++ 20.pdf │ │ ├── CppSummit_struct_pack.pdf │ │ └── coro_rpc_introduction_purecpp_talk.pdf └── zh │ ├── coro_http │ └── coro_http_introduction.md │ ├── coro_rpc │ ├── coro_rpc_client.md │ ├── coro_rpc_doc.hpp │ ├── coro_rpc_introduction.md │ └── coro_rpc_server.md │ ├── easylog │ └── easylog_introduction.md │ ├── guide │ ├── how_to_use_as_git_submodule.md │ ├── how_to_use_by_cmake_find_package.md │ └── what_is_yalantinglibs.md │ ├── index.md │ ├── metric │ └── metric_introduction.md │ ├── reflection │ ├── reflection.png │ └── reflection_introduction.md │ ├── struct_pack │ ├── struct_pack_doc.hpp │ ├── struct_pack_intro.md │ ├── struct_pack_layout.md │ ├── struct_pack_tips.md │ └── struct_pack_type_system.md │ ├── struct_pb │ └── struct_pb_intro.md │ └── struct_xxx │ └── struct_xxx_introduction.md ├── doxy └── header.html ├── generate.sh ├── package.json └── yarn.lock /.clang-format: -------------------------------------------------------------------------------- 1 | --- 2 | Language: Cpp 3 | BasedOnStyle: Google 4 | # Should be declared this way: 5 | BreakBeforeBraces: Custom 6 | BraceWrapping: 7 | BeforeElse: true 8 | AllowShortLambdasOnASingleLine: None 9 | AllowShortIfStatementsOnASingleLine: Never 10 | --- 11 | Language: JavaScript 12 | DisableFormat: true 13 | --- 14 | # Ignore json file 15 | Language: Json 16 | DisableFormat: true 17 | --- 18 | Language: Proto 19 | DisableFormat: true 20 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | ### Search before asking 2 | 3 | - [ ] I searched the [issues](https://github.com/alibaba/yalantinglibs/issues) and found no similar issues. 4 | 5 | 6 | ### What happened + What you expected to happen 7 | 8 | 9 | ### Reproduction way 10 | 11 | 12 | ### Anything else 13 | 14 | 15 | ### Are you willing to submit a PR? 16 | 17 | - [ ] Yes I am willing to submit a PR! -------------------------------------------------------------------------------- /.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## Why 4 | 5 | 6 | 7 | 8 | 9 | ## What is changing 10 | 11 | ## Example -------------------------------------------------------------------------------- /.github/workflows/bazel_clang.yml: -------------------------------------------------------------------------------- 1 | name: Bazel-Clang 2 | 3 | on: 4 | push: 5 | branches: [ main ] 6 | pull_request: 7 | branches: [ main ] 8 | workflow_dispatch: 9 | 10 | jobs: 11 | build: 12 | runs-on: ubuntu-22.04 13 | 14 | steps: 15 | - uses: actions/checkout@v2 16 | 17 | - name: Install newer Clang 18 | run: | 19 | sudo rm /etc/apt/sources.list.d/microsoft-prod.list 20 | sudo apt-get update 21 | wget https://apt.llvm.org/llvm.sh 22 | chmod +x ./llvm.sh 23 | sudo ./llvm.sh 17 24 | 25 | - name: Build 26 | working-directory: ${{github.workspace}} 27 | run: bazel build --config=clang-cl --action_env=CXX=clang++-17 --action_env=CC=clang-17 ... 28 | 29 | - name: Test 30 | working-directory: ${{github.workspace}} 31 | run: bazel test --config=clang-cl --action_env=CXX=clang++-17 --action_env=CC=clang-17 --test_output=errors ... 32 | -------------------------------------------------------------------------------- /.github/workflows/clang-format.yml: -------------------------------------------------------------------------------- 1 | name: Clang Format Diff 2 | 3 | on: 4 | push: 5 | branches: [ main, develop ] 6 | pull_request: 7 | branches: [ main, develop ] 8 | workflow_dispatch: 9 | 10 | jobs: 11 | build: 12 | 13 | runs-on: ubuntu-22.04 14 | 15 | steps: 16 | - name: Checkout 17 | uses: actions/checkout@v4 18 | with: 19 | fetch-depth: 0 20 | - name: install clang-format 21 | run: sudo apt install clang-format 22 | - name: check-diff 23 | run: | 24 | diff=`git-clang-format --diff HEAD^` 25 | if ! [[ "$diff" = "no modified files to format" || "$diff" = "clang-format did not modify any files" ]]; then 26 | echo "The diff you sent is not formatted correctly." 27 | echo "The suggested format is" 28 | echo "$diff" 29 | exit 1 30 | fi 31 | -------------------------------------------------------------------------------- /.github/workflows/clean_cache.yml: -------------------------------------------------------------------------------- 1 | name: cleanup closed branch's caches 2 | on: 3 | pull_request: 4 | types: 5 | - closed 6 | # cleanup closed branch's caches after pull request 7 | workflow_dispatch: 8 | 9 | jobs: 10 | clean_caches: 11 | runs-on: ubuntu-latest 12 | permissions: 13 | # `actions:write` permission is required to delete caches 14 | # See also: https://docs.github.com/en/rest/actions/cache?apiVersion=2022-11-28#delete-a-github-actions-cache-for-a-repository-using-a-cache-id 15 | actions: write 16 | contents: read 17 | steps: 18 | - name: Check out code 19 | uses: actions/checkout@v4 20 | 21 | - name: Cleanup 22 | run: | 23 | gh extension install actions/gh-actions-cache 24 | 25 | REPO=${{ github.repository }} 26 | BRANCH=refs/pull/${{ github.event.pull_request.number }}/merge 27 | 28 | echo "Fetching list of cache key" 29 | cacheKeysForPR=$(gh actions-cache list -R $REPO -B $BRANCH | cut -f 1 ) 30 | 31 | ## Setting this to not fail the workflow while deleting cache keys. 32 | set +e 33 | echo "Deleting caches..." 34 | for cacheKey in $cacheKeysForPR 35 | do 36 | gh actions-cache delete $cacheKey -R $REPO -B $BRANCH --confirm 37 | done 38 | echo "Done" 39 | env: 40 | GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} 41 | -------------------------------------------------------------------------------- /.github/workflows/code-coverage.yml: -------------------------------------------------------------------------------- 1 | name: Upload CodeCov Report 2 | 3 | on: [ push, pull_request ] 4 | 5 | jobs: 6 | build: 7 | 8 | runs-on: ubuntu-latest 9 | 10 | steps: 11 | - name: Checkout Code 12 | uses: actions/checkout@v2 13 | with: 14 | fetch-depth: 2 15 | 16 | - name: Install newer Clang 17 | run: | 18 | sudo rm /etc/apt/sources.list.d/microsoft-prod.list 19 | sudo apt-get update 20 | wget https://apt.llvm.org/llvm.sh 21 | chmod +x ./llvm.sh 22 | sudo ./llvm.sh 17 23 | 24 | - name: Configure 25 | run: | 26 | cmake -B ${{github.workspace}}/build \ 27 | -DCMAKE_BUILD_TYPE=${{matrix.mode}} -DBUILD_WITH_LIBCXX=OFF -DYLT_ENABLE_SSL=ON \ 28 | -DUSE_CCACHE=${{env.ccache}} -DCMAKE_C_COMPILER=clang-17 -DCMAKE_CXX_COMPILER=clang++-17 29 | 30 | - name: Build with ${{ matrix.compiler }} 31 | run: cmake --build ${{github.workspace}}/build --config Debug -- -j 32 | 33 | - name: Test 34 | working-directory: ${{github.workspace}}/build 35 | env: 36 | CTEST_OUTPUT_ON_FAILURE: 1 37 | run: ctest -C ${{ matrix.configuration }} -j 1 -V 38 | 39 | - name: Upload coverage to Codecov 40 | uses: codecov/codecov-action@v1 41 | -------------------------------------------------------------------------------- /.github/workflows/s390x.yml: -------------------------------------------------------------------------------- 1 | name: IBM S390X 2 | 3 | on: 4 | push: 5 | branches: [ main, develop ] 6 | pull_request: 7 | branches: [ main, develop ] 8 | workflow_dispatch: 9 | 10 | jobs: 11 | build-ubuntu-s390x: 12 | name: Build Linux on s390x arch and run unit tests 13 | runs-on: ubuntu-latest 14 | steps: 15 | - uses: actions/checkout@v4 16 | - uses: uraimo/run-on-arch-action@v2 17 | name: Test 18 | id: runcmd 19 | with: 20 | arch: s390x 21 | distro: ubuntu22.04 22 | githubToken: ${{ github.token }} 23 | install: | 24 | apt-get update -q -y 25 | apt-get -y install cmake 26 | apt-get -y install make 27 | apt-get -y install g++ 28 | run: | 29 | lscpu | grep Endian 30 | CXX=g++ CC=gcc 31 | cmake -B ${{github.workspace}}/build \ 32 | -DCMAKE_BUILD_TYPE=Debug \ 33 | -DBUILD_CORO_HTTP=OFF -DBUILD_CORO_IO=OFF -DBUILD_CORO_RPC=OFF -DBUILD_EASYLOG=OFF -DBUILD_STRUCT_JSON=OFF -DBUILD_STRUCT_XML=OFF -DBUILD_STRUCT_YAML=OFF -DBUILD_UTIL=OFF -DBUILD_EXAMPLES=OFF -DBUILD_BENCHMARK=OFF 34 | cmake --build ${{github.workspace}}/build -j 35 | cd ${{github.workspace}}/build/output/tests 36 | ./struct_pack_test 37 | ./struct_pack_test_with_optimize -------------------------------------------------------------------------------- /.github/workflows/update_cache.yml: -------------------------------------------------------------------------------- 1 | name: CI Daily 2 | 3 | on: 4 | # Allows you to run this workflow manually from the Actions tab 5 | workflow_dispatch: 6 | schedule: 7 | - cron: '0 17 * * *' # 01:00 Chinese time is 17:00 UTC 8 | jobs: 9 | ubuntu_clang: 10 | uses: ./.github/workflows/ubuntu_clang.yml 11 | ubuntu_gcc: 12 | uses: ./.github/workflows/ubuntu_gcc.yml 13 | mac: 14 | uses: ./.github/workflows/mac.yml 15 | windows: 16 | uses: ./.github/workflows/windows.yml 17 | 18 | # run compile daily to make the cache in github update 19 | # run website to keep it follow main. 20 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | 34 | # 35 | .idea 36 | cmake-* 37 | *build* 38 | .fleet 39 | .vs 40 | out 41 | .vscode 42 | .cache 43 | .coverage 44 | .coverage_lcov 45 | .coverage_llvm_cov 46 | doxygen-awesome-css 47 | html 48 | CMakeUserPresets.json 49 | .DS_Store 50 | node_modules 51 | /CMakeSettings.json 52 | 53 | # Bazel 54 | bazel-* 55 | !BUILD.bazel 56 | cdb.json 57 | 58 | # website 59 | website/docs/zh/*/images/ 60 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.15) 2 | project(yaLanTingLibs 3 | VERSION 0.3.9 4 | DESCRIPTION "yaLanTingLibs" 5 | HOMEPAGE_URL "https://github.com/alibaba/yalantinglibs" 6 | LANGUAGES CXX 7 | ) 8 | 9 | # load pack finder 10 | list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Find/) 11 | 12 | find_package(Threads REQUIRED) 13 | link_libraries(Threads::Threads) 14 | 15 | include(cmake/install.cmake) 16 | 17 | if(CMAKE_PROJECT_NAME STREQUAL "yaLanTingLibs") # if ylt is top-level project 18 | # add include path 19 | include_directories(include) 20 | include_directories(include/ylt/thirdparty) 21 | include_directories(include/ylt/standalone) 22 | include_directories(src/include) 23 | 24 | include(cmake/find_openssl.cmake) 25 | include(cmake/find_ibverbs.cmake) 26 | include(cmake/utils.cmake) 27 | include(cmake/build.cmake) 28 | include(cmake/develop.cmake) 29 | # add project config, such as enable_ssl. 30 | include(cmake/config.cmake) 31 | # add project's source such as unit test, example & benchmark 32 | include(cmake/subdir.cmake) 33 | else () 34 | # add project config, such as enable_ssl. 35 | include(cmake/config.cmake) 36 | endif() 37 | 38 | -------------------------------------------------------------------------------- /MODULE.bazel: -------------------------------------------------------------------------------- 1 | ############################################################################### 2 | # Bazel now uses Bzlmod by default to manage external dependencies. 3 | # Please consider migrating your external dependencies from WORKSPACE to MODULE.bazel. 4 | # 5 | # For more details, please check https://github.com/bazelbuild/bazel/issues/18958 6 | ############################################################################### 7 | 8 | bazel_dep(name = "rules_cc", version = "0.0.16") -------------------------------------------------------------------------------- /NOTICE: -------------------------------------------------------------------------------- 1 | ======================================================== 2 | yaLanTingLibs 3 | Copyright (c) 2019-2022, Alibaba Group Holding Limited 4 | Licensed under the Apache License, Version 2.0 5 | =================================================================== 6 | 7 | This product contains various third-party components under other open source licenses 8 | This section summarizes those components and their licenses. 9 | Apache Software Foundation License 2.0 10 | -------------------------------------- 11 | 12 | ylt/struct_pack/texpr.hpp 13 | 14 | BSD 3-Clause "New" or "Revised" License 15 | -------------------------------------- 16 | 17 | util/expected.hpp 18 | 19 | Creative Commons Zero v1.0 Universal License 20 | 21 | -------------------------------------- 22 | 23 | test/doctest.h 24 | 25 | include/ylt/struct_pack/pp 26 | 27 | Distributed under the Boost Software License, Version 1.0. (See accompanying 28 | file LICENSE_1_0.txt or copy at ) 29 | 30 | =================================================================== 31 | The reflection of a struct and data format borrow various ideas from zpp_bits, reflect-cpp and msgpack. 32 | coro_rpc borrow various ideas from rest_rpc. 33 | -------------------------------------------------------------------------------- /WORKSPACE: -------------------------------------------------------------------------------- 1 | workspace(name = "com_alibaba_yalantinglibs") 2 | -------------------------------------------------------------------------------- /WORKSPACE.bzlmod: -------------------------------------------------------------------------------- 1 | # This is a WORKSPACE file used by bzlmod in combination with MODULE.bazel. 2 | # It's used for a gradual migration and it should be empty. 3 | # Don't remove this file. If the file doesn't exist, bzlmod falls back to WORKSPACE file. 4 | 5 | load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") 6 | 7 | workspace(name = "com_alibaba_yalantinglibs") -------------------------------------------------------------------------------- /bazel/BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alibaba/yalantinglibs/1bd20f7b8fc37a6677a8cc0ef743d6675bd35c42/bazel/BUILD -------------------------------------------------------------------------------- /bazel/defs.bzl: -------------------------------------------------------------------------------- 1 | YA_LT_COPT = [ 2 | "-fno-tree-slp-vectorize", # -ftree-slp-vectorize with coroutine cause link error. disable it util gcc fix. 3 | ] 4 | 5 | YA_BIN_COPT = [ 6 | "-fno-tree-slp-vectorize", # -ftree-slp-vectorize with coroutine cause link error. disable it util gcc fix. 7 | "-Wno-unused-but-set-variable", 8 | "-Wno-unused-value", 9 | "-Wno-unused-variable", 10 | "-Wno-sign-compare", 11 | "-Wno-reorder", 12 | "-Wno-unused-local-typedefs", 13 | "-Wno-missing-braces", 14 | "-Wno-uninitialized", 15 | ] 16 | -------------------------------------------------------------------------------- /cmake/Find/Finduring.cmake: -------------------------------------------------------------------------------- 1 | # * Find liburing Find the liburing library and includes 2 | # 3 | # URING_INCLUDE_DIR - where to find liburing.h, etc. URING_LIBRARIES - List of 4 | # libraries when using uring. URING_FOUND - True if uring found. 5 | 6 | find_path(URING_INCLUDE_DIR liburing.h) 7 | find_library(URING_LIBRARIES uring) 8 | 9 | include(FindPackageHandleStandardArgs) 10 | find_package_handle_standard_args(uring DEFAULT_MSG URING_LIBRARIES 11 | URING_INCLUDE_DIR) 12 | 13 | if(URING_FOUND) 14 | if(NOT TARGET uring) 15 | add_library(uring UNKNOWN IMPORTED) 16 | endif() 17 | set_target_properties( 18 | uring 19 | PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${URING_INCLUDE_DIR}" 20 | IMPORTED_LINK_INTERFACE_LANGUAGES "C" 21 | IMPORTED_LOCATION "${URING_LIBRARIES}") 22 | mark_as_advanced(URING_LIBRARIES) 23 | endif() -------------------------------------------------------------------------------- /cmake/find_ibverbs.cmake: -------------------------------------------------------------------------------- 1 | check_library_exists(ibverbs ibv_create_qp "" YLT_HAVE_IBVERBS) 2 | if(YLT_HAVE_IBVERBS) 3 | set(YLT_ENABLE_IBV ON) 4 | set(IBVERBS_LIBRARY ibverbs) 5 | message(STATUS "have libibverbs") 6 | endif() -------------------------------------------------------------------------------- /cmake/find_openssl.cmake: -------------------------------------------------------------------------------- 1 | check_library_exists(ssl SSL_new "" HAVE_SSL_LIB) 2 | if(HAVE_SSL_LIB) 3 | message(STATUS "Found OpenSSL libraries") 4 | set(YLT_ENABLE_SSL ON) 5 | else() 6 | message(STATUS "OpenSSL libraries not found") 7 | endif() 8 | -------------------------------------------------------------------------------- /cmake/subdir.cmake: -------------------------------------------------------------------------------- 1 | message(STATUS "-------------YLT PROJECT SETTING------------") 2 | 3 | file(GLOB children src/*) 4 | 5 | foreach(child ${children}) 6 | get_filename_component(subdir_name ${child} NAME) 7 | string(TOUPPER ${subdir_name} subdir_name) 8 | if (ENABLE_CPP_20) 9 | option(BUILD_${subdir_name} "BUILD_${subdir_name}" ON) 10 | else() 11 | option(BUILD_${subdir_name} "BUILD_${subdir_name}" OFF) 12 | endif() 13 | endforeach() 14 | 15 | if (NOT ENABLE_CPP_20) 16 | Set(BUILD_STRUCT_PACK ON) 17 | Set(BUILD_STRUCT_JSON ON) 18 | Set(BUILD_STRUCT_XML ON) 19 | Set(BUILD_STRUCT_YAML ON) 20 | endif() 21 | 22 | foreach(child ${children}) 23 | get_filename_component(subdir_name ${child} NAME) 24 | string(TOUPPER ${subdir_name} subdir_name) 25 | 26 | if (BUILD_${subdir_name}) 27 | message(STATUS "BUILD_${subdir_name}: ${BUILD_${subdir_name}}") 28 | if(BUILD_EXAMPLES AND EXISTS ${child}/examples) 29 | add_subdirectory(${child}/examples) 30 | endif() 31 | if(BUILD_UNIT_TESTS AND EXISTS ${child}/tests) 32 | add_subdirectory(${child}/tests) 33 | endif() 34 | if(BUILD_BENCHMARK AND EXISTS ${child}/benchmark) 35 | add_subdirectory(${child}/benchmark) 36 | endif() 37 | endif() 38 | endforeach() 39 | message(STATUS "--------------------------------------------") -------------------------------------------------------------------------------- /cmake/utils.cmake: -------------------------------------------------------------------------------- 1 | macro(check_asan _RESULT) 2 | include(CheckCXXSourceRuns) 3 | set(CMAKE_REQUIRED_FLAGS "-fsanitize=address") 4 | check_cxx_source_runs( 5 | [====[ 6 | int main() 7 | { 8 | return 0; 9 | } 10 | ]====] 11 | ${_RESULT} 12 | ) 13 | unset(CMAKE_REQUIRED_FLAGS) 14 | endmacro() 15 | 16 | macro(check_lld _RESULT) 17 | include(CheckCXXSourceRuns) 18 | set(CMAKE_REQUIRED_FLAGS "-fuse-ld=lld") 19 | check_cxx_source_runs( 20 | [====[ 21 | int main() 22 | { 23 | return 0; 24 | } 25 | ]====] 26 | ${_RESULT} 27 | ) 28 | unset(CMAKE_REQUIRED_FLAGS) 29 | endmacro() 30 | 31 | macro(check_tsan _RESULT) 32 | include(CheckCXXSourceRuns) 33 | set(CMAKE_REQUIRED_FLAGS "-fsanitize=thread") 34 | check_cxx_source_runs( 35 | [====[ 36 | int main() 37 | { 38 | return 0; 39 | } 40 | ]====] 41 | ${_RESULT} 42 | ) 43 | unset(CMAKE_REQUIRED_FLAGS) 44 | endmacro() -------------------------------------------------------------------------------- /include/ylt/coro_http/coro_http_client.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #ifdef YLT_ENABLE_SSL 18 | #ifndef CINATRA_ENABLE_SSL 19 | #define CINATRA_ENABLE_SSL 20 | #endif 21 | #endif 22 | #include 23 | #ifndef CINATRA_LOG_ERROR 24 | #define CINATRA_LOG_ERROR ELOG_ERROR 25 | #endif 26 | #ifndef CINATRA_LOG_WARNING 27 | #define CINATRA_LOG_WARNING ELOG_WARN 28 | #endif 29 | #ifndef CINATRA_LOG_INFO 30 | #define CINATRA_LOG_INFO ELOG_INFO 31 | #endif 32 | #ifndef CINATRA_LOG_DEBUG 33 | #define CINATRA_LOG_DEBUG ELOG_DEBUG 34 | #endif 35 | #ifndef CINATRA_LOG_TRACE 36 | #define CINATRA_LOG_TRACE ELOG_TRACE 37 | #endif 38 | 39 | #include 40 | 41 | namespace coro_http = cinatra; -------------------------------------------------------------------------------- /include/ylt/coro_http/coro_http_server.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #ifdef YLT_ENABLE_SSL 18 | #ifndef CINATRA_ENABLE_SSL 19 | #define CINATRA_ENABLE_SSL 20 | #endif 21 | #endif 22 | #include 23 | #ifndef CINATRA_LOG_ERROR 24 | #define CINATRA_LOG_ERROR ELOG_ERROR 25 | #endif 26 | #ifndef CINATRA_LOG_WARNING 27 | #define CINATRA_LOG_WARNING ELOG_WARN 28 | #endif 29 | #ifndef CINATRA_LOG_INFO 30 | #define CINATRA_LOG_INFO ELOG_INFO 31 | #endif 32 | #ifndef CINATRA_LOG_DEBUG 33 | #define CINATRA_LOG_DEBUG ELOG_DEBUG 34 | #endif 35 | #ifndef CINATRA_LOG_TRACE 36 | #define CINATRA_LOG_TRACE ELOG_TRACE 37 | #endif 38 | 39 | #include 40 | 41 | namespace coro_http = cinatra; -------------------------------------------------------------------------------- /include/ylt/coro_rpc/coro_rpc_client.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include "impl/coro_rpc_client.hpp" -------------------------------------------------------------------------------- /include/ylt/coro_rpc/coro_rpc_context.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include "impl/protocol/coro_rpc_protocol.hpp" 18 | -------------------------------------------------------------------------------- /include/ylt/coro_rpc/coro_rpc_server.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include "impl/coro_rpc_server.hpp" 18 | #include "impl/default_config/coro_rpc_config.hpp" 19 | -------------------------------------------------------------------------------- /include/ylt/coro_rpc/impl/expected.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #if __has_include() && __cplusplus > 202002L 18 | #include 19 | #if __cpp_lib_expected >= 202202L 20 | #else 21 | #include 22 | #endif 23 | #else 24 | #include 25 | #endif 26 | 27 | namespace coro_rpc { 28 | 29 | namespace protocol { 30 | struct coro_rpc_protocol; 31 | } 32 | 33 | template 34 | using rpc_result = expected; 35 | 36 | } // namespace coro_rpc -------------------------------------------------------------------------------- /include/ylt/metric.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2024, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #define CINATRA_ENABLE_METRIC_JSON 18 | #include "metric/gauge.hpp" 19 | #include "metric/histogram.hpp" 20 | #include "metric/metric_manager.hpp" 21 | #include "metric/summary.hpp" 22 | #include "metric/system_metric.hpp" 23 | #include "ylt/struct_json/json_writer.h" 24 | -------------------------------------------------------------------------------- /include/ylt/reflection/internal/arg_list_macro.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "common_macro.hpp" 3 | 4 | #define YLT_MACRO_EXPAND(...) __VA_ARGS__ 5 | 6 | #define WRAP_ARGS0(w, o) 7 | #define WRAP_ARGS1(w, o, _1) w(o, _1) 8 | #include "generate/arg_list_macro_gen.hpp" 9 | 10 | #define WRAP_ARGS_(w, object, ...) \ 11 | YLT_CONCAT(WRAP_ARGS, YLT_ARG_COUNT(__VA_ARGS__)) \ 12 | (w, object, ##__VA_ARGS__) 13 | #define WRAP_ARGS(w, object, ...) WRAP_ARGS_(w, object, ##__VA_ARGS__) 14 | -------------------------------------------------------------------------------- /include/ylt/reflection/internal/common_macro.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #define YLT_CONCAT_(l, r) l##r 3 | 4 | #define YLT_CONCAT(l, r) YLT_CONCAT_(l, r) 5 | 6 | #define CONCAT_MEMBER(t, x) t.x 7 | 8 | #define CONCAT_ADDR(T, x) &T::x 9 | 10 | #define CONCAT_NAME(t, x) #x 11 | 12 | namespace ylt::reflection { 13 | template 14 | struct identity {}; 15 | } // namespace ylt::reflection -------------------------------------------------------------------------------- /include/ylt/reflection/private_visitor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "internal/common_macro.hpp" 5 | 6 | namespace ylt::reflection { 7 | template 8 | struct private_visitor { 9 | friend inline constexpr auto get_private_ptrs( 10 | const ylt::reflection::identity&) { 11 | constexpr auto tp = std::make_tuple(field...); 12 | return tp; 13 | } 14 | }; 15 | } // namespace ylt::reflection 16 | -------------------------------------------------------------------------------- /include/ylt/standalone/cinatra/use_asio.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #if defined(ASIO_STANDALONE) 4 | // MSVC : define environment path 'ASIO_STANDALONE_INCLUDE', e.g. 5 | // 'E:\bdlibs\asio-1.10.6\include' 6 | 7 | #include 8 | #ifdef CINATRA_ENABLE_SSL 9 | #include 10 | #endif 11 | #include 12 | 13 | using tcp_socket = asio::ip::tcp::socket; 14 | #ifdef CINATRA_ENABLE_SSL 15 | using ssl_socket = asio::ssl::stream; 16 | #endif 17 | #endif 18 | -------------------------------------------------------------------------------- /include/ylt/standalone/cinatra/version.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Note: Update the version when release a new version. 4 | 5 | // CINATRA_VERSION % 100 is the sub-minor version 6 | // CINATRA_VERSION / 100 % 1000 is the minor version 7 | // CINATRA_VERSION / 100000 is the major version 8 | #define CINATRA_VERSION 902 // 0.9.2 -------------------------------------------------------------------------------- /include/ylt/standalone/iguana/detail/string_stream.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #if __has_include() 4 | #include 5 | #endif 6 | 7 | namespace iguana { 8 | #ifdef IGUANA_ENABLE_PMR 9 | #if __has_include() 10 | inline char iguana_buf[2048]; 11 | inline std::pmr::monotonic_buffer_resource iguana_resource(iguana_buf, 2048); 12 | using string_stream = std::pmr::string; 13 | #endif 14 | #else 15 | using string_stream = std::string; 16 | #endif 17 | } // namespace iguana -------------------------------------------------------------------------------- /include/ylt/standalone/iguana/iguana.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "iguana/dynamic.hpp" 3 | #include "iguana/json_reader.hpp" 4 | #include "iguana/json_writer.hpp" 5 | #include "iguana/pb_reader.hpp" 6 | #include "iguana/pb_writer.hpp" 7 | #include "iguana/xml_reader.hpp" 8 | #include "iguana/xml_writer.hpp" 9 | #include "iguana/yaml_reader.hpp" 10 | #include "iguana/yaml_writer.hpp" 11 | -------------------------------------------------------------------------------- /include/ylt/standalone/iguana/version.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Note: Update the version when release a new version. 4 | 5 | // IGUANA_VERSION % 100 is the sub-minor version 6 | // IGUANA_VERSION / 100 % 1000 is the minor version 7 | // IGUANA_VERSION / 100000 is the major version 8 | #define IGUANA_VERSION 100005 // 1.0.5 -------------------------------------------------------------------------------- /include/ylt/struct_json/json_reader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | 18 | #include 19 | namespace struct_json = iguana; -------------------------------------------------------------------------------- /include/ylt/struct_json/json_writer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | 18 | #include 19 | 20 | namespace struct_json = iguana; -------------------------------------------------------------------------------- /include/ylt/struct_pack/size_info.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include 18 | namespace struct_pack::detail { 19 | struct size_info { 20 | std::size_t total; 21 | std::size_t size_cnt; 22 | std::size_t max_size; 23 | constexpr size_info &operator+=(const size_info &other) { 24 | this->total += other.total; 25 | this->size_cnt += other.size_cnt; 26 | this->max_size = (std::max)(this->max_size, other.max_size); 27 | return *this; 28 | } 29 | constexpr size_info operator+(const size_info &other) { 30 | return {this->total + other.total, this->size_cnt + other.size_cnt, 31 | (std::max)(this->max_size, other.max_size)}; 32 | } 33 | }; 34 | } // namespace struct_pack::detail -------------------------------------------------------------------------------- /include/ylt/struct_pb.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2024, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include "struct_pb/struct_pb_impl.hpp" 18 | -------------------------------------------------------------------------------- /include/ylt/struct_pb/struct_pb_impl.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2024, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include 18 | #include 19 | #include 20 | namespace struct_pb = iguana; 21 | -------------------------------------------------------------------------------- /include/ylt/struct_xml/xml_reader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include 18 | #include 19 | 20 | namespace struct_xml = iguana; 21 | -------------------------------------------------------------------------------- /include/ylt/struct_xml/xml_writer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include 18 | 19 | namespace struct_xml = iguana; 20 | -------------------------------------------------------------------------------- /include/ylt/struct_yaml/yaml_reader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include 18 | 19 | namespace struct_yaml = iguana; 20 | -------------------------------------------------------------------------------- /include/ylt/struct_yaml/yaml_writer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2023, Alibaba Group Holding Limited; 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | #pragma once 17 | #include 18 | 19 | namespace struct_yaml = iguana; 20 | -------------------------------------------------------------------------------- /include/ylt/thirdparty/asio/associator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // associator.hpp 3 | // ~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef ASIO_ASSOCIATOR_HPP 12 | #define ASIO_ASSOCIATOR_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "asio/detail/config.hpp" 19 | 20 | #include "asio/detail/push_options.hpp" 21 | 22 | namespace asio { 23 | 24 | /// Used to generically specialise associators for a type. 25 | template