Full Code of scylladb/seastar for AI

gitextract_vjp23guz/

├── .clangd
├── .claude/
│   └── CLAUDE.md
├── .dockerignore
├── .gitattributes
├── .github/
│   └── workflows/
│       ├── alpinelinux.yaml
│       ├── docker.yaml
│       ├── pre-commit.yaml
│       ├── python-lint.yaml
│       ├── test.yaml
│       └── tests.yaml
├── .gitignore
├── .gitmodules
├── .gitorderfile
├── .mailmap
├── .pre-commit-config.yaml
├── CMakeLists.txt
├── CONTRIBUTING.md
├── HACKING.md
├── LICENSE
├── NOTICE
├── README-DPDK.md
├── README.md
├── apps/
│   ├── CMakeLists.txt
│   ├── httpd/
│   │   ├── CMakeLists.txt
│   │   ├── demo.json
│   │   └── main.cc
│   ├── io_tester/
│   │   ├── CMakeLists.txt
│   │   ├── conf.yaml
│   │   ├── io_tester.cc
│   │   ├── ioinfo.cc
│   │   └── sched.yaml
│   ├── iotune/
│   │   ├── CMakeLists.txt
│   │   └── iotune.cc
│   ├── lib/
│   │   └── stop_signal.hh
│   ├── memcached/
│   │   ├── CMakeLists.txt
│   │   ├── ascii.rl
│   │   ├── memcache.cc
│   │   ├── memcached.hh
│   │   └── tests/
│   │       ├── CMakeLists.txt
│   │       ├── test.py
│   │       ├── test_ascii_parser.cc
│   │       └── test_memcached.py
│   ├── rpc_tester/
│   │   ├── CMakeLists.txt
│   │   ├── rpc_tester.cc
│   │   └── sample-conf.yaml
│   └── seawreck/
│       ├── CMakeLists.txt
│       └── seawreck.cc
├── cmake/
│   ├── CheckGcc107852.cmake
│   ├── CheckHeaders.cmake
│   ├── CheckIncludeStyle.cmake
│   ├── CheckLibc.cmake
│   ├── CheckP2582R1.cmake
│   ├── CxxModulesRules.cmake
│   ├── FindGnuTLS.cmake
│   ├── FindLibUring.cmake
│   ├── FindLinuxMembarrier.cmake
│   ├── FindPthreadSetName.cmake
│   ├── FindSanitizers.cmake
│   ├── FindStdAtomic.cmake
│   ├── FindSystemTap-SDT.cmake
│   ├── FindValgrind.cmake
│   ├── Findc-ares.cmake
│   ├── Finddpdk.cmake
│   ├── Findhwloc.cmake
│   ├── Findlksctp-tools.cmake
│   ├── Findlz4.cmake
│   ├── Findragel.cmake
│   ├── Findrt.cmake
│   ├── Finducontext.cmake
│   ├── Findyaml-cpp.cmake
│   ├── SeastarConfig.cmake.in
│   ├── SeastarDependencies.cmake
│   ├── TriStateOption.cmake
│   ├── check-seastar-include-style.py
│   └── code_tests/
│       ├── LinuxMembarrier_test.cc
│       ├── Sanitizers_fiber_test.cc
│       ├── Source_location_default_argument.cc
│       ├── Source_location_test.cc
│       ├── rt_test.cc
│       └── stdout_test.cc
├── coding-style.md
├── configure.py
├── cooking.sh
├── cooking_recipe.cmake
├── debug/
│   └── task-latency.stap
├── demos/
│   ├── CMakeLists.txt
│   ├── block_discard_demo.cc
│   ├── coroutines_demo.cc
│   ├── echo_demo.cc
│   ├── file_demo.cc
│   ├── hello-cxx-module.cc
│   ├── hello-world.cc
│   ├── http_client_demo.cc
│   ├── ip_demo.cc
│   ├── l3_demo.cc
│   ├── line_count_demo.cc
│   ├── rpc_demo.cc
│   ├── scheduling_group_demo.cc
│   ├── sharded_parameter_demo.cc
│   ├── tcp_demo.cc
│   ├── tcp_sctp_client_demo.cc
│   ├── tcp_sctp_server_demo.cc
│   ├── tls_echo_server.hh
│   ├── tls_echo_server_demo.cc
│   ├── tls_simple_client_demo.cc
│   ├── tutorial_examples.cc
│   ├── udp_client_demo.cc
│   ├── udp_server_demo.cc
│   ├── udp_zero_copy_demo.cc
│   ├── websocket_client_demo.cc
│   └── websocket_server_demo.cc
├── doc/
│   ├── CMakeLists.txt
│   ├── Doxyfile.in
│   ├── DoxygenLayout.xml
│   ├── compatibility.md
│   ├── contributing.md
│   ├── generator.md
│   ├── htmlsplit.py
│   ├── io-properties-file.md
│   ├── io-scheduler.md
│   ├── io-tester.md
│   ├── lambda-coroutine-fiasco.md
│   ├── md2html
│   ├── md2pdf
│   ├── mini-tutorial.md
│   ├── native-stack.md
│   ├── network-configuration.md
│   ├── network-connection-load-balancing.md
│   ├── prometheus.md
│   ├── rpc-compression.md
│   ├── rpc-streaming.md
│   ├── rpc.md
│   ├── shared-token-bucket.md
│   ├── signal.md
│   ├── template.css
│   ├── template.tex
│   ├── testing.md
│   ├── tutorial.md
│   └── websocket.md
├── docker/
│   └── dev/
│       └── Dockerfile
├── include/
│   └── seastar/
│       ├── core/
│       │   ├── abort_on_ebadf.hh
│       │   ├── abort_on_expiry.hh
│       │   ├── abort_source.hh
│       │   ├── abortable_fifo.hh
│       │   ├── alien.hh
│       │   ├── align.hh
│       │   ├── aligned_buffer.hh
│       │   ├── app-template.hh
│       │   ├── bitops.hh
│       │   ├── bitset-iter.hh
│       │   ├── byteorder.hh
│       │   ├── cacheline.hh
│       │   ├── checked_ptr.hh
│       │   ├── chunked_fifo.hh
│       │   ├── circular_buffer.hh
│       │   ├── circular_buffer_fixed_capacity.hh
│       │   ├── condition-variable.hh
│       │   ├── coroutine.hh
│       │   ├── deleter.hh
│       │   ├── disk_params.hh
│       │   ├── distributed.hh
│       │   ├── do_with.hh
│       │   ├── dpdk_rte.hh
│       │   ├── enum.hh
│       │   ├── exception_hacks.hh
│       │   ├── execution_stage.hh
│       │   ├── expiring_fifo.hh
│       │   ├── fair_queue.hh
│       │   ├── file-types.hh
│       │   ├── file.hh
│       │   ├── format.hh
│       │   ├── fsnotify.hh
│       │   ├── fsqual.hh
│       │   ├── fstream.hh
│       │   ├── function_traits.hh
│       │   ├── future-util.hh
│       │   ├── future.hh
│       │   ├── gate.hh
│       │   ├── idle_cpu_handler.hh
│       │   ├── internal/
│       │   │   ├── api-level.hh
│       │   │   ├── buffer_allocator.hh
│       │   │   ├── current_task.hh
│       │   │   ├── estimated_histogram.hh
│       │   │   ├── io_desc.hh
│       │   │   ├── io_intent.hh
│       │   │   ├── io_request.hh
│       │   │   ├── io_sink.hh
│       │   │   ├── linux-aio.hh
│       │   │   ├── poll.hh
│       │   │   ├── pollable_fd.hh
│       │   │   ├── run_in_background.hh
│       │   │   ├── stall_detector.hh
│       │   │   ├── systemwide_memory_barrier.hh
│       │   │   └── uname.hh
│       │   ├── io_intent.hh
│       │   ├── io_priority_class.hh
│       │   ├── io_queue.hh
│       │   ├── iostream-impl.hh
│       │   ├── iostream.hh
│       │   ├── layered_file.hh
│       │   ├── loop.hh
│       │   ├── lowres_clock.hh
│       │   ├── make_task.hh
│       │   ├── manual_clock.hh
│       │   ├── map_reduce.hh
│       │   ├── memory.hh
│       │   ├── metrics.hh
│       │   ├── metrics_api.hh
│       │   ├── metrics_registration.hh
│       │   ├── metrics_types.hh
│       │   ├── on_internal_error.hh
│       │   ├── pipe.hh
│       │   ├── polymorphic_temporary_buffer.hh
│       │   ├── posix.hh
│       │   ├── preempt.hh
│       │   ├── prefetch.hh
│       │   ├── print.hh
│       │   ├── prometheus.hh
│       │   ├── queue.hh
│       │   ├── ragel.hh
│       │   ├── reactor.hh
│       │   ├── reactor_config.hh
│       │   ├── relabel_config.hh
│       │   ├── report_exception.hh
│       │   ├── resource.hh
│       │   ├── rwlock.hh
│       │   ├── scattered_message.hh
│       │   ├── scheduling.hh
│       │   ├── scheduling_specific.hh
│       │   ├── scollectd.hh
│       │   ├── scollectd_api.hh
│       │   ├── seastar.hh
│       │   ├── semaphore.hh
│       │   ├── shard_id.hh
│       │   ├── sharded.hh
│       │   ├── shared_future.hh
│       │   ├── shared_mutex.hh
│       │   ├── shared_ptr.hh
│       │   ├── shared_ptr_debug_helper.hh
│       │   ├── shared_ptr_incomplete.hh
│       │   ├── signal.hh
│       │   ├── simple-stream.hh
│       │   ├── slab.hh
│       │   ├── sleep.hh
│       │   ├── smp.hh
│       │   ├── smp_options.hh
│       │   ├── sstring.hh
│       │   ├── stall_sampler.hh
│       │   ├── stream.hh
│       │   ├── task.hh
│       │   ├── temporary_buffer.hh
│       │   ├── thread.hh
│       │   ├── thread_cputime_clock.hh
│       │   ├── thread_impl.hh
│       │   ├── timed_out_error.hh
│       │   ├── timer-set.hh
│       │   ├── timer.hh
│       │   ├── transfer.hh
│       │   ├── unaligned.hh
│       │   ├── units.hh
│       │   ├── vector-data-sink.hh
│       │   ├── weak_ptr.hh
│       │   ├── when_all.hh
│       │   ├── when_any.hh
│       │   ├── with_scheduling_group.hh
│       │   └── with_timeout.hh
│       ├── coroutine/
│       │   ├── all.hh
│       │   ├── as_future.hh
│       │   ├── exception.hh
│       │   ├── generator.hh
│       │   ├── maybe_yield.hh
│       │   ├── parallel_for_each.hh
│       │   ├── switch_to.hh
│       │   └── try_future.hh
│       ├── http/
│       │   ├── api_docs.hh
│       │   ├── client.hh
│       │   ├── common.hh
│       │   ├── connection_factory.hh
│       │   ├── exception.hh
│       │   ├── file_handler.hh
│       │   ├── function_handlers.hh
│       │   ├── handlers.hh
│       │   ├── httpd.hh
│       │   ├── internal/
│       │   │   └── content_source.hh
│       │   ├── json_path.hh
│       │   ├── matcher.hh
│       │   ├── matchrules.hh
│       │   ├── mime_types.hh
│       │   ├── reply.hh
│       │   ├── request.hh
│       │   ├── retry_strategy.hh
│       │   ├── routes.hh
│       │   ├── short_streams.hh
│       │   ├── transformers.hh
│       │   ├── types.hh
│       │   └── url.hh
│       ├── json/
│       │   ├── formatter.hh
│       │   └── json_elements.hh
│       ├── net/
│       │   ├── api.hh
│       │   ├── arp.hh
│       │   ├── byteorder.hh
│       │   ├── config.hh
│       │   ├── const.hh
│       │   ├── dhcp.hh
│       │   ├── dns.hh
│       │   ├── dpdk.hh
│       │   ├── ethernet.hh
│       │   ├── inet_address.hh
│       │   ├── ip.hh
│       │   ├── ip_checksum.hh
│       │   ├── ipv4_address.hh
│       │   ├── ipv6_address.hh
│       │   ├── native-stack.hh
│       │   ├── net.hh
│       │   ├── packet-data-source.hh
│       │   ├── packet-util.hh
│       │   ├── packet.hh
│       │   ├── posix-stack.hh
│       │   ├── proxy.hh
│       │   ├── socket_defs.hh
│       │   ├── stack.hh
│       │   ├── tcp-stack.hh
│       │   ├── tcp.hh
│       │   ├── tls.hh
│       │   ├── toeplitz.hh
│       │   ├── udp.hh
│       │   ├── unix_address.hh
│       │   ├── virtio-interface.hh
│       │   └── virtio.hh
│       ├── rpc/
│       │   ├── lz4_compressor.hh
│       │   ├── lz4_fragmented_compressor.hh
│       │   ├── multi_algo_compressor_factory.hh
│       │   ├── rpc.hh
│       │   ├── rpc_impl.hh
│       │   └── rpc_types.hh
│       ├── testing/
│       │   ├── entry_point.hh
│       │   ├── exchanger.hh
│       │   ├── linux_perf_event.hh
│       │   ├── on_internal_error.hh
│       │   ├── perf_tests.hh
│       │   ├── random.hh
│       │   ├── seastar_test.hh
│       │   ├── test_case.hh
│       │   ├── test_fixture.hh
│       │   ├── test_runner.hh
│       │   └── thread_test_case.hh
│       ├── util/
│       │   ├── alloc_failure_injector.hh
│       │   ├── assert.hh
│       │   ├── backtrace.hh
│       │   ├── bool_class.hh
│       │   ├── closeable.hh
│       │   ├── conversions.hh
│       │   ├── critical_alloc_section.hh
│       │   ├── defer.hh
│       │   ├── eclipse.hh
│       │   ├── exceptions.hh
│       │   ├── file.hh
│       │   ├── function_input_iterator.hh
│       │   ├── indirect.hh
│       │   ├── integrated-length.hh
│       │   ├── internal/
│       │   │   ├── array_map.hh
│       │   │   ├── iovec_utils.hh
│       │   │   └── magic.hh
│       │   ├── iostream.hh
│       │   ├── is_smart_ptr.hh
│       │   ├── later.hh
│       │   ├── lazy.hh
│       │   ├── log-cli.hh
│       │   ├── log-impl.hh
│       │   ├── log-level.hh
│       │   ├── log.hh
│       │   ├── memory-data-sink.hh
│       │   ├── memory-data-source.hh
│       │   ├── memory_diagnostics.hh
│       │   ├── noncopyable_function.hh
│       │   ├── optimized_optional.hh
│       │   ├── print_safe.hh
│       │   ├── process.hh
│       │   ├── program-options.hh
│       │   ├── read_first_line.hh
│       │   ├── reference_wrapper.hh
│       │   ├── sampler.hh
│       │   ├── shared_token_bucket.hh
│       │   ├── short_streams.hh
│       │   ├── spinlock.hh
│       │   ├── std-compat.hh
│       │   ├── string_utils.hh
│       │   ├── tmp_file.hh
│       │   ├── transform_iterator.hh
│       │   ├── tuple_utils.hh
│       │   ├── used_size.hh
│       │   └── variant_utils.hh
│       └── websocket/
│           ├── client.hh
│           ├── common.hh
│           ├── parser.hh
│           └── server.hh
├── install-dependencies.sh
├── kvm/
│   ├── README.md
│   ├── register.sh
│   └── scripts/
│       └── bootstrap.sh
├── licenses/
│   ├── cmake.txt
│   ├── dpdk.txt
│   └── freebsd.txt
├── pkgconfig/
│   ├── seastar-testing.pc.in
│   └── seastar.pc.in
├── scripts/
│   ├── addr2line.py
│   ├── dpdk_nic_bind.py
│   ├── io-trace-parse.py
│   ├── perftune.py
│   ├── perftune.yaml
│   ├── posix_net_conf.sh
│   ├── pyproject.toml
│   ├── run_with_dpdk.sh
│   ├── seastar-addr2line
│   ├── seastar-cpu-map.sh
│   ├── seastar-json2code.py
│   ├── stall-analyser.py
│   └── tap.sh
├── seastar_cmake.py
├── src/
│   ├── core/
│   │   ├── alien.cc
│   │   ├── app-template.cc
│   │   ├── cgroup.hh
│   │   ├── condition-variable.cc
│   │   ├── disk_params.cc
│   │   ├── dpdk_rte.cc
│   │   ├── exception_hacks.cc
│   │   ├── execution_stage.cc
│   │   ├── fair_queue.cc
│   │   ├── file-impl.hh
│   │   ├── file.cc
│   │   ├── fsnotify.cc
│   │   ├── fsqual.cc
│   │   ├── fstream.cc
│   │   ├── future-util.cc
│   │   ├── future.cc
│   │   ├── io_queue.cc
│   │   ├── linux-aio.cc
│   │   ├── memory.cc
│   │   ├── metrics.cc
│   │   ├── on_internal_error.cc
│   │   ├── posix.cc
│   │   ├── prefault.hh
│   │   ├── program_options.cc
│   │   ├── program_options.hh
│   │   ├── prometheus-impl.hh
│   │   ├── prometheus.cc
│   │   ├── reactor.cc
│   │   ├── reactor_backend.cc
│   │   ├── reactor_backend.hh
│   │   ├── resource.cc
│   │   ├── scollectd-impl.hh
│   │   ├── scollectd.cc
│   │   ├── semaphore.cc
│   │   ├── sharded.cc
│   │   ├── signal.cc
│   │   ├── smp.cc
│   │   ├── sstring.cc
│   │   ├── syscall_result.hh
│   │   ├── syscall_work_queue.hh
│   │   ├── systemwide_memory_barrier.cc
│   │   ├── thread.cc
│   │   ├── thread_pool.cc
│   │   ├── thread_pool.hh
│   │   ├── uname.cc
│   │   └── vla.hh
│   ├── http/
│   │   ├── api_docs.cc
│   │   ├── chunk_parsers.rl
│   │   ├── client.cc
│   │   ├── common.cc
│   │   ├── file_handler.cc
│   │   ├── httpd.cc
│   │   ├── json_path.cc
│   │   ├── matcher.cc
│   │   ├── mime_types.cc
│   │   ├── reply.cc
│   │   ├── request.cc
│   │   ├── request_parser.rl
│   │   ├── response_parser.rl
│   │   ├── retry_strategy.cc
│   │   ├── routes.cc
│   │   ├── transformers.cc
│   │   └── url.cc
│   ├── json/
│   │   ├── formatter.cc
│   │   └── json_elements.cc
│   ├── net/
│   │   ├── arp.cc
│   │   ├── config.cc
│   │   ├── dhcp.cc
│   │   ├── dns.cc
│   │   ├── dpdk.cc
│   │   ├── ethernet.cc
│   │   ├── inet_address.cc
│   │   ├── ip.cc
│   │   ├── ip_checksum.cc
│   │   ├── native-stack-impl.hh
│   │   ├── native-stack.cc
│   │   ├── net.cc
│   │   ├── packet.cc
│   │   ├── posix-stack.cc
│   │   ├── proxy.cc
│   │   ├── socket_address.cc
│   │   ├── stack.cc
│   │   ├── tcp.cc
│   │   ├── tls.cc
│   │   ├── udp.cc
│   │   ├── unix_address.cc
│   │   └── virtio.cc
│   ├── proto/
│   │   └── metrics2.proto
│   ├── rpc/
│   │   ├── lz4_compressor.cc
│   │   ├── lz4_fragmented_compressor.cc
│   │   └── rpc.cc
│   ├── seastar.cppm
│   ├── testing/
│   │   ├── entry_point.cc
│   │   ├── random.cc
│   │   ├── seastar_test.cc
│   │   └── test_runner.cc
│   ├── util/
│   │   ├── alloc_failure_injector.cc
│   │   ├── backtrace.cc
│   │   ├── conversions.cc
│   │   ├── exceptions.cc
│   │   ├── file.cc
│   │   ├── log.cc
│   │   ├── process.cc
│   │   ├── program-options.cc
│   │   ├── read_first_line.cc
│   │   ├── short_streams.cc
│   │   └── tmp_file.cc
│   └── websocket/
│       ├── client.cc
│       ├── common.cc
│       ├── parser.cc
│       └── server.cc
├── test.py
└── tests/
    ├── CMakeLists.txt
    ├── fuzz/
    │   ├── CMakeLists.txt
    │   └── sstring_fuzz.cc
    ├── manual/
    │   ├── iosched.py
    │   ├── iosched_reproducers/
    │   │   ├── one_cpu_starved_shard_can_still_saturate_io.sh
    │   │   ├── one_cpu_starved_shard_has_reasonable_fairness.sh
    │   │   ├── scylla_tablet_migration.sh
    │   │   └── tau_nemesis.sh
    │   └── rl-iosched.py
    ├── perf/
    │   ├── CMakeLists.txt
    │   ├── allocator_perf.cc
    │   ├── container_perf.cc
    │   ├── coroutine_perf.cc
    │   ├── fair_queue_perf.cc
    │   ├── fstream_perf.cc
    │   ├── future_util_perf.cc
    │   ├── http_client_perf.cc
    │   ├── linux_perf_event.cc
    │   ├── metrics_perf.cc
    │   ├── perf-tests.md
    │   ├── perf_tests.cc
    │   ├── perf_tests_perf.cc
    │   ├── rpc_perf.cc
    │   ├── shared_token_bucket.cc
    │   ├── smp_submit_to_perf.cc
    │   └── thread_context_switch_test.cc
    └── unit/
        ├── CMakeLists.txt
        ├── abort_source_test.cc
        ├── abortable_fifo_test.cc
        ├── alien_test.cc
        ├── alloc_test.cc
        ├── allocator_test.cc
        ├── api.json
        ├── app-template_test.cc
        ├── cert.cfg.in
        ├── checked_ptr_test.cc
        ├── chunk_parsers_test.cc
        ├── chunked_fifo_test.cc
        ├── circular_buffer_fixed_capacity_test.cc
        ├── circular_buffer_test.cc
        ├── closeable_test.cc
        ├── condition_variable_test.cc
        ├── conf-example.yaml
        ├── connect_test.cc
        ├── content_source_test.cc
        ├── coroutines_test.cc
        ├── defer_test.cc
        ├── deleter_test.cc
        ├── directory_test.cc
        ├── distributed_test.cc
        ├── dns_test.cc
        ├── epoll_test.cc
        ├── exception_logging_test.cc
        ├── execution_stage_test.cc
        ├── expected_exception.hh
        ├── expiring_fifo_test.cc
        ├── fair_queue_test.cc
        ├── file_io_test.cc
        ├── file_utils_test.cc
        ├── foreign_ptr_test.cc
        ├── fsnotifier_test.cc
        ├── fstream_test.cc
        ├── futures_test.cc
        ├── gate_test.cc
        ├── generator_test.cc
        ├── httpd_test.cc
        ├── https-server.py
        ├── io_queue_test.cc
        ├── ipv6_test.cc
        ├── json2code_test.py
        ├── json_formatter_test.cc
        ├── libc_wrapper_test.cc
        ├── linux_perf_event_test.cc
        ├── locking_test.cc
        ├── log_buf_test.cc
        ├── loopback_socket.hh
        ├── lowres_clock_test.cc
        ├── memory-data-sink.hh
        ├── metrics_test.cc
        ├── metrics_tester.cc
        ├── mkcert.gmk
        ├── mkmtls.gmk
        ├── mock_file.hh
        ├── net_config_test.cc
        ├── network_interface_test.cc
        ├── noncopyable_function_test.cc
        ├── output_stream_test.cc
        ├── packet_test.cc
        ├── pipe_test.cc
        ├── program_options_test.cc
        ├── prometheus_http_test.cc
        ├── prometheus_test.py
        ├── prometheus_text_test.cc
        ├── proxy_protocol_test.cc
        ├── queue_test.cc
        ├── request_parser_test.cc
        ├── rest_api_httpd.cc
        ├── rpc_test.cc
        ├── scheduling_group_nesting_test.cc
        ├── scheduling_group_test.cc
        ├── semaphore_test.cc
        ├── sharded_test.cc
        ├── shared_ptr_test.cc
        ├── shared_token_bucket_test.cc
        ├── signal_test.cc
        ├── simple_stream_test.cc
        ├── slab_test.cc
        ├── smp_test.cc
        ├── socket_test.cc
        ├── source_location_test.cc
        ├── spawn_test.cc
        ├── sstring_test.cc
        ├── stall_detector_test.cc
        ├── stream_reader_test.cc
        ├── temporary_buffer_test.cc
        ├── test_fixture_test.cc
        ├── thread_test.cc
        ├── timer_test.cc
        ├── tl-generator.hh
        ├── tls-ca-bundle.pem
        ├── tls_test.cc
        ├── tmpdir.hh
        ├── tuple_utils_test.cc
        ├── uname_test.cc
        ├── unix_domain_test.cc
        ├── unwind_test.cc
        ├── variant_utils_test.cc
        ├── weak_ptr_test.cc
        └── websocket_test.cc

SYMBOL INDEX (10340 symbols across 523 files)

FILE: apps/httpd/main.cc
  class handl (line 45) | class handl : public httpd::handler_base {
    method handle (line 47) | virtual future<std::unique_ptr<http::reply> > handle(const sstring& path,
  function set_routes (line 55) | void set_routes(routes& r) {
  function main (line 80) | int main(int ac, char** av) {

FILE: apps/io_tester/io_tester.cc
  class context (line 74) | class context
    method context (line 1212) | context(sstring dir, directory_entry_type dtype, std::vector<job_confi...
    method stop (line 1223) | future<> stop() {
    method start (line 1229) | future<> start() {
    method issue_requests (line 1235) | future<> issue_requests() {
    method emit_results (line 1243) | future<> emit_results(YAML::Emitter& out) {
  type request_type (line 75) | enum class request_type { seqread, overwrite, randread, randwrite, appen...
  type std (line 77) | namespace std {
    type hash<request_type> (line 80) | struct hash<request_type> {
  function allocate_and_fill_buffer (line 88) | auto allocate_and_fill_buffer(size_t buffer_size) {
  function create_and_fill_file (line 98) | future<file> create_and_fill_file(sstring name, uint64_t fsize, open_fla...
  function busyloop_sleep (line 124) | future<> busyloop_sleep(std::chrono::steady_clock::time_point until, std...
  function timer_sleep (line 133) | future<> timer_sleep(std::chrono::steady_clock::time_point until, std::c...
  class pause_distribution (line 139) | class pause_distribution {
    method Dur (line 145) | Dur get_as() {
  class uniform_process (line 154) | class uniform_process : public pause_distribution {
    method uniform_process (line 158) | uniform_process(std::chrono::duration<double> period)
    method get (line 163) | std::chrono::duration<double> get() override {
  function make_uniform_pause (line 168) | std::unique_ptr<pause_distribution> make_uniform_pause(std::chrono::dura...
  class poisson_process (line 172) | class poisson_process : public pause_distribution {
    method poisson_process (line 178) | poisson_process(std::chrono::duration<double> period)
    method get (line 184) | std::chrono::duration<double> get() override {
  function make_poisson_pause (line 189) | std::unique_ptr<pause_distribution> make_poisson_pause(std::chrono::dura...
  type byte_size (line 193) | struct byte_size {
  type duration_time (line 197) | struct duration_time {
  class shard_config (line 201) | class shard_config {
    method shard_config (line 204) | shard_config()
    method shard_config (line 206) | shard_config(std::unordered_set<unsigned> s) : _shards(std::move(s)) {}
    method is_set (line 208) | bool is_set(unsigned cpu) const {
  type shard_info (line 213) | struct shard_info {
  type options (line 230) | struct options {
  class class_data (line 241) | class class_data
    method class_data (line 304) | class_data(job_config cfg)
    method think_tick (line 323) | void think_tick() {
    method issue_request (line 333) | future<> issue_request(char* buf, io_intent* intent, std::chrono::stea...
    method issue_requests_in_parallel (line 343) | future<> issue_requests_in_parallel(std::chrono::steady_clock::time_po...
    method issue_requests_at_rate (line 356) | future<> issue_requests_at_rate(std::chrono::steady_clock::time_point ...
    method issue_requests (line 395) | future<> issue_requests(std::chrono::steady_clock::time_point stop) {
    method think (line 408) | future<> think() {
    method start (line 426) | future<> start(sstring dir, directory_entry_type type) {
    method stop (line 436) | future<> stop() {
    method sstring (line 442) | const sstring name() const {
    method sstring (line 447) | sstring type_str() const {
    method request_type (line 463) | request_type req_type() const {
    method sstring (line 467) | sstring think_time() const {
    method req_size (line 475) | size_t req_size() const {
    method parallelism (line 479) | unsigned parallelism() const {
    method rps (line 483) | unsigned rps() const {
    method batch (line 487) | unsigned batch() const {
    method limit (line 491) | unsigned limit() const noexcept {
    method shares (line 495) | unsigned shares() const {
    method total_duration (line 499) | std::chrono::duration<float> total_duration() const {
    method file_size_mb (line 503) | uint64_t file_size_mb() const {
    method total_data (line 507) | uint64_t total_data() const {
    method max_latency (line 511) | uint64_t max_latency() const {
    method average_latency (line 515) | uint64_t average_latency() const {
    method quantile_latency (line 519) | uint64_t quantile_latency(double q) const {
    method requests (line 523) | uint64_t requests() const noexcept {
    method add_result (line 527) | void add_result(size_t data, std::chrono::microseconds latency) {
    method stop_hook (line 535) | virtual future<> stop_hook() {
  type job_config (line 243) | struct job_config {
  type sched_group_config (line 261) | struct sched_group_config {
  function maybe_remove_file (line 273) | future<> maybe_remove_file(sstring fname) {
  function maybe_close_file (line 277) | future<> maybe_close_file(file& f) {
  class class_data (line 281) | class class_data {
    method class_data (line 304) | class_data(job_config cfg)
    method think_tick (line 323) | void think_tick() {
    method issue_request (line 333) | future<> issue_request(char* buf, io_intent* intent, std::chrono::stea...
    method issue_requests_in_parallel (line 343) | future<> issue_requests_in_parallel(std::chrono::steady_clock::time_po...
    method issue_requests_at_rate (line 356) | future<> issue_requests_at_rate(std::chrono::steady_clock::time_point ...
    method issue_requests (line 395) | future<> issue_requests(std::chrono::steady_clock::time_point stop) {
    method think (line 408) | future<> think() {
    method start (line 426) | future<> start(sstring dir, directory_entry_type type) {
    method stop (line 436) | future<> stop() {
    method sstring (line 442) | const sstring name() const {
    method sstring (line 447) | sstring type_str() const {
    method request_type (line 463) | request_type req_type() const {
    method sstring (line 467) | sstring think_time() const {
    method req_size (line 475) | size_t req_size() const {
    method parallelism (line 479) | unsigned parallelism() const {
    method rps (line 483) | unsigned rps() const {
    method batch (line 487) | unsigned batch() const {
    method limit (line 491) | unsigned limit() const noexcept {
    method shares (line 495) | unsigned shares() const {
    method total_duration (line 499) | std::chrono::duration<float> total_duration() const {
    method file_size_mb (line 503) | uint64_t file_size_mb() const {
    method total_data (line 507) | uint64_t total_data() const {
    method max_latency (line 511) | uint64_t max_latency() const {
    method average_latency (line 515) | uint64_t average_latency() const {
    method quantile_latency (line 519) | uint64_t quantile_latency(double q) const {
    method requests (line 523) | uint64_t requests() const noexcept {
    method add_result (line 527) | void add_result(size_t data, std::chrono::microseconds latency) {
    method stop_hook (line 535) | virtual future<> stop_hook() {
  class io_class_data (line 540) | class io_class_data : public class_data {
    method on_io_completed (line 550) | future<size_t> on_io_completed(future<size_t> f) {
    method is_random (line 560) | bool is_random() const {
    method get_pos (line 564) | uint64_t get_pos() {
    method io_class_data (line 582) | io_class_data(job_config cfg)
    method do_start (line 589) | future<> do_start(sstring path, directory_entry_type type) override {
    method update_queue_length (line 596) | void update_queue_length() {
    method do_start_path (line 601) | future<> do_start_path(sstring path, directory_entry_type type) {
    method do_start_on_directory (line 617) | future<> do_start_on_directory(sstring dir) {
    method do_start_on_bdev (line 641) | future<> do_start_on_bdev(sstring name) {
    method do_start_on_dev_null (line 660) | future<> do_start_on_dev_null() {
    method get_one_metrics (line 670) | std::optional<double> get_one_metrics(sstring m_name, bool check_class...
    method emit_one_metrics (line 686) | void emit_one_metrics(YAML::Emitter& out, sstring m_name, bool check_c...
    method emit_metrics (line 692) | void emit_metrics(YAML::Emitter& out) {
    method emit_results (line 704) | virtual void emit_results(YAML::Emitter& out) override {
  class read_io_class_data (line 732) | class read_io_class_data : public io_class_data {
    method read_io_class_data (line 734) | read_io_class_data(job_config cfg) : io_class_data(std::move(cfg)) {}
    method issue_request (line 736) | future<size_t> issue_request(char *buf, io_intent* intent) override {
  class write_io_class_data (line 742) | class write_io_class_data : public io_class_data {
    method write_io_class_data (line 744) | write_io_class_data(job_config cfg) : io_class_data(std::move(cfg)) {}
    method issue_request (line 746) | future<size_t> issue_request(char *buf, io_intent* intent) override {
  class vectorized_read_io_class_data (line 752) | class vectorized_read_io_class_data : public io_class_data {
    method vectorized_read_io_class_data (line 758) | vectorized_read_io_class_data(job_config cfg)
    method issue_request (line 773) | future<size_t> issue_request(char *buf, io_intent* intent) override {
    method allocate_buffers (line 781) | void allocate_buffers() {
  class vectorized_write_io_class_data (line 793) | class vectorized_write_io_class_data : public io_class_data {
    method vectorized_write_io_class_data (line 799) | vectorized_write_io_class_data(job_config cfg)
    method issue_request (line 814) | future<size_t> issue_request(char *buf, io_intent* intent) override {
    method allocate_buffers (line 822) | void allocate_buffers() {
  class unlink_class_data (line 834) | class unlink_class_data : public class_data {
    method unlink_class_data (line 840) | unlink_class_data(job_config cfg) : class_data(std::move(cfg)) {
    method do_start (line 846) | future<> do_start(sstring path, directory_entry_type type) override {
    method issue_request (line 853) | future<size_t> issue_request(char *buf, io_intent* intent) override {
    method emit_results (line 868) | void emit_results(YAML::Emitter& out) override {
    method stop_hook (line 882) | future<> stop_hook() override {
    method files_count (line 893) | uint64_t files_count() const {
    method max_concurrency (line 897) | uint64_t max_concurrency() const {
    method all_files_removed (line 903) | bool all_files_removed() const {
    method sstring (line 907) | sstring get_filename(uint64_t file_id) const {
    method do_start_on_directory (line 911) | future<> do_start_on_directory(sstring path) {
  class cpu_class_data (line 932) | class cpu_class_data : public class_data {
    method cpu_class_data (line 934) | cpu_class_data(job_config cfg) : class_data(std::move(cfg)) {}
    method do_start (line 936) | future<> do_start(sstring dir, directory_entry_type type) override {
    method issue_request (line 940) | future<size_t> issue_request(char *buf, io_intent* intent) override {
    method emit_results (line 950) | virtual void emit_results(YAML::Emitter& out) override {
  type YAML (line 975) | namespace YAML {
    type convert<byte_size> (line 977) | struct convert<byte_size> {
      method decode (line 978) | static bool decode(const Node& node, byte_size& bs) {
    type convert<duration_time> (line 996) | struct convert<duration_time> {
      method decode (line 997) | static bool decode(const Node& node, duration_time& dt) {
    type convert<shard_config> (line 1025) | struct convert<shard_config> {
      method decode (line 1026) | static bool decode(const Node& node, shard_config& shards) {
    type convert<request_type> (line 1039) | struct convert<request_type> {
      method decode (line 1040) | static bool decode(const Node& node, request_type& rt) {
    type convert<shard_info> (line 1060) | struct convert<shard_info> {
      method decode (line 1061) | static bool decode(const Node& node, shard_info& sl) {
    type convert<options> (line 1109) | struct convert<options> {
      method decode (line 1110) | static bool decode(const Node& node, options& op) {
    type convert<job_config> (line 1153) | struct convert<job_config> {
      method decode (line 1154) | static bool decode(const Node& node, job_config& cl) {
    type convert<sched_group_config> (line 1189) | struct convert<sched_group_config> {
      method decode (line 1190) | static bool decode(const Node& node, sched_group_config& sc) {
  class context (line 1203) | class context {
    method context (line 1212) | context(sstring dir, directory_entry_type dtype, std::vector<job_confi...
    method stop (line 1223) | future<> stop() {
    method start (line 1229) | future<> start() {
    method issue_requests (line 1235) | future<> issue_requests() {
    method emit_results (line 1243) | future<> emit_results(YAML::Emitter& out) {
  function show_results (line 1260) | static void show_results(sharded<context>& ctx) {
  function main (line 1277) | int main(int ac, char** av) {

FILE: apps/io_tester/ioinfo.cc
  function main (line 31) | int main(int ac, char** av) {

FILE: apps/iotune/iotune.cc
  function check_device_properties (line 67) | void check_device_properties(fs::path dev_sys_file) {
  type evaluation_directory (line 102) | struct evaluation_directory {
    method scan_device (line 112) | void scan_device(unsigned dev_maj, unsigned dev_min) {
    method scan_device (line 116) | void scan_device(std::string dev_str) {
    method scan_device (line 120) | void scan_device(fs::path sys_file) {
    method evaluation_directory (line 166) | evaluation_directory(sstring name, unsigned force_io_depth)
    method max_iodepth (line 172) | unsigned max_iodepth() const {
    method path (line 176) | fs::path path() const {
    method sstring (line 180) | const sstring& name() const {
    method disks_per_array (line 184) | unsigned disks_per_array() const {
    method minimum_io_size (line 188) | uint64_t minimum_io_size() const {
    method reported_physical_block_size (line 192) | std::optional<uint64_t> reported_physical_block_size() const {
    method discover_directory (line 196) | future<> discover_directory() {
    method available_space (line 206) | uint64_t available_space() const {
  type io_rates (line 211) | struct io_rates {
    method io_rates (line 214) | io_rates operator+(const io_rates& a) const {
    method io_rates (line 218) | io_rates& operator+=(const io_rates& a) {
  type row_stats (line 225) | struct row_stats {
    method stdev_percents (line 230) | float stdev_percents() const {
  function row_stats (line 236) | static row_stats get_row_stats_for(const std::vector<T>& v) {
    method stdev_percents (line 230) | float stdev_percents() const {
  class invalid_position (line 248) | class invalid_position : public std::exception {
  type position_generator (line 255) | struct position_generator {
  class sequential_issuer (line 261) | class sequential_issuer : public position_generator {
    method sequential_issuer (line 266) | sequential_issuer(size_t buffer_size, uint64_t size_limit)
    method is_sequential (line 271) | virtual bool is_sequential() const {
    method get_pos (line 275) | virtual uint64_t get_pos() {
  class random_issuer (line 289) | class random_issuer : public position_generator {
    method random_issuer (line 294) | random_issuer(size_t buffer_size, uint64_t last_position)
    method is_sequential (line 300) | virtual bool is_sequential() const {
    method get_pos (line 304) | virtual uint64_t get_pos() {
  class request_issuer (line 313) | class request_issuer {
  class write_request_issuer (line 320) | class write_request_issuer : public request_issuer {
    method write_request_issuer (line 323) | explicit write_request_issuer(file f) : _file(f) {}
    method issue_request (line 324) | future<size_t> issue_request(uint64_t pos, char* buf, uint64_t size) o...
  class read_request_issuer (line 329) | class read_request_issuer : public request_issuer {
    method read_request_issuer (line 332) | explicit read_request_issuer(file f) : _file(f) {}
    method issue_request (line 333) | future<size_t> issue_request(uint64_t pos, char* buf, uint64_t size) o...
  function warmup_period (line 338) | std::chrono::duration<double>
  class io_worker (line 345) | class io_worker {
    class requests_rate_meter (line 346) | class requests_rate_meter {
      method requests_rate_meter (line 360) | requests_rate_meter(std::chrono::duration<double> duration, std::vec...
    method is_sequential (line 409) | bool is_sequential() const {
    method should_stop (line 413) | bool should_stop() const {
    method io_worker (line 417) | io_worker(size_t buffer_size, std::chrono::duration<double> duration, ...
    method get_buffer (line 428) | std::unique_ptr<char[], free_deleter> get_buffer() {
    method issue_request (line 432) | future<> issue_request(char* buf) {
    method max_offset (line 445) | uint64_t max_offset() const noexcept { return _max_offset; }
    method io_rates (line 447) | io_rates get_io_rates() const {
  class test_file (line 459) | class test_file {
    type pattern (line 461) | enum class pattern { sequential, random }
    type access_type (line 462) | enum class access_type { read, write }
    method get_position_generator (line 470) | std::unique_ptr<position_generator> get_position_generator(size_t buff...
    method calculate_buffer_size (line 478) | uint64_t calculate_buffer_size(pattern access_pattern, uint64_t buffer...
    method test_file (line 492) | test_file(const ::evaluation_directory& dir, uint64_t maximum_size, ui...
    method create_data_file (line 499) | future<> create_data_file() {
    method do_workload (line 519) | future<io_rates> do_workload(std::unique_ptr<io_worker> worker_ptr, un...
    method read_workload (line 549) | future<io_rates> read_workload(size_t buffer_size, pattern access_patt...
    method write_workload (line 555) | future<io_rates> write_workload(size_t buffer_size, pattern access_pat...
    method stop (line 566) | future<> stop() {
  class iotune_multi_shard_context (line 571) | class iotune_multi_shard_context {
    method per_shard_io_depth (line 576) | unsigned per_shard_io_depth() const {
    method stop (line 589) | future<> stop() {
    method start (line 593) | future<> start() {
    method get_serial_rates (line 600) | future<row_stats> get_serial_rates() {
    method get_sharded_worst_rates (line 606) | future<row_stats> get_sharded_worst_rates() {
    method create_data_file (line 617) | future<> create_data_file() {
    method write_sequential_data (line 623) | future<io_rates> write_sequential_data(unsigned shard, size_t buffer_s...
    method warm_up_sequential_data (line 629) | future<> warm_up_sequential_data(size_t buffer_size, std::chrono::dura...
    method read_sequential_data (line 638) | future<io_rates> read_sequential_data(unsigned shard, size_t buffer_si...
    method write_random_data (line 644) | future<io_rates> write_random_data(size_t buffer_size, std::chrono::du...
    method read_random_data (line 655) | future<io_rates> read_random_data(size_t buffer_size, std::chrono::dur...
    method saturate (line 668) | future<uint64_t> saturate(float rate_threshold, size_t buffer_size, st...
    method saturate_write (line 684) | future<uint64_t> saturate_write(float rate_threshold, size_t buffer_si...
    method saturate_read (line 688) | future<uint64_t> saturate_read(float rate_threshold, size_t buffer_siz...
    method detect_physical_block_size (line 700) | future<uint64_t> detect_physical_block_size(std::chrono::duration<doub...
    method iotune_multi_shard_context (line 774) | iotune_multi_shard_context(::evaluation_directory dir, uint64_t random...
  type disk_descriptor (line 781) | struct disk_descriptor {
  function string_to_file (line 792) | void string_to_file(sstring conf_file, sstring buf) {
  function write_configuration_file (line 800) | void write_configuration_file(sstring conf_file, std::string format, sst...
  function write_property_file (line 810) | void write_property_file(sstring conf_file, std::vector<disk_descriptor>...
  function mountpoint_of (line 842) | fs::path mountpoint_of(sstring filename) {
  function main (line 860) | int main(int ac, char** av) {

FILE: apps/lib/stop_signal.hh
  type seastar_apps_lib (line 31) | namespace seastar_apps_lib {
    class stop_signal (line 51) | class stop_signal {
      method signaled (line 55) | void signaled() {
      method stop_signal (line 63) | stop_signal() {
      method wait (line 72) | seastar::future<> wait() {
      method stopping (line 75) | bool stopping() const {

FILE: apps/memcached/memcache.cc
  type seastar (line 61) | namespace seastar { void append_buffers(jagged_array_of_buffers& vb, std...
    function append_buffers (line 1457) | void append_buffers(jagged_array_of_buffers& vb, std::span<temporary_b...
  type memcache (line 63) | namespace memcache {
    type expiration (line 94) | struct expiration {
      method expiration (line 101) | expiration() {}
      method expiration (line 103) | expiration(clock_type::duration wc_to_clock_type_delta, uint32_t s) {
      method ever_expires (line 127) | bool ever_expires() {
      method time_point (line 131) | time_point to_time_point() {
    class item (line 136) | class item : public slab_item_base {
      method item (line 158) | item(uint32_t slab_page_index, item_key&& key, sstring&& ascii_prefix,
      method item (line 180) | item(const item&) = delete;
      method item (line 181) | item(item&&) = delete;
      method get_timeout (line 183) | clock_type::time_point get_timeout() {
      method version_type (line 187) | version_type version() {
      method key (line 191) | const std::string_view key() const {
      method ascii_prefix (line 195) | const std::string_view ascii_prefix() const {
      method value (line 200) | const std::string_view value() const {
      method key_size (line 206) | size_t key_size() const {
      method ascii_prefix_size (line 210) | size_t ascii_prefix_size() const {
      method value_size (line 214) | size_t value_size() const {
      method data_as_integral (line 218) | optional<uint64_t> data_as_integral() {
      method cancel (line 239) | bool cancel() {
      method get_slab_page_index (line 244) | uint32_t get_slab_page_index() const {
      method is_unlocked (line 247) | bool is_unlocked() const {
      method hash_value (line 257) | std::size_t hash_value(const item &i) {
      method intrusive_ptr_add_ref (line 261) | inline void intrusive_ptr_add_ref(item* it) {
      method intrusive_ptr_release (line 269) | inline void intrusive_ptr_release(item* it) {
    type item_key_cmp (line 282) | struct item_key_cmp
      method compare (line 285) | bool compare(const item_key& key, const item& it) const {
    type cache_stats (line 302) | struct cache_stats {
    type cas_result (line 346) | enum class cas_result {
    type remote_origin_tag (line 350) | struct remote_origin_tag {
      method T (line 352) | static inline
    type local_origin_tag (line 358) | struct local_origin_tag {
      method T (line 360) | static inline
    type item_insertion_data (line 366) | struct item_insertion_data {
    class cache (line 373) | class cache {
      method item_size (line 392) | size_t item_size(item& item_ref) {
      method item_size (line 400) | size_t item_size(item_insertion_data& insertion) {
      method erase (line 421) | void erase(item& item_ref) {
      method expire (line 437) | void expire() {
      method cache_iterator (line 457) | inline
      method cache_iterator (line 463) | inline
      method add_new (line 485) | inline
      method maybe_rehash (line 500) | void maybe_rehash() {
      method cache (line 515) | cache(uint64_t per_cpu_slab_size, uint64_t slab_page_size)
      method flush_all (line 544) | void flush_all() {
      method flush_at (line 551) | void flush_at(uint32_t time) {
      method set (line 557) | bool set(item_insertion_data& insertion) {
      method add (line 571) | bool add(item_insertion_data& insertion) {
      method replace (line 583) | bool replace(item_insertion_data& insertion) {
      method remove (line 594) | bool remove(const item_key& key) {
      method item_ptr (line 606) | item_ptr get(const item_key& key) {
      method cas_result (line 618) | cas_result cas(item_insertion_data& insertion, item::version_type ve...
      method size (line 634) | size_t size() {
      method bucket_count (line 638) | size_t bucket_count() {
      method cache_stats (line 642) | cache_stats stats() {
      method incr (line 648) | std::pair<item_ptr, bool> incr(item_key& key, uint64_t delta) {
      method decr (line 671) | std::pair<item_ptr, bool> decr(item_key& key, uint64_t delta) {
      method print_hash_stats (line 693) | std::pair<unsigned, foreign_ptr<lw_shared_ptr<std::string>>> print_h...
      method stop (line 734) | future<> stop() { return make_ready_future<>(); }
      method get_wc_to_clock_type_delta (line 735) | clock_type::duration get_wc_to_clock_type_delta() { return _wc_to_cl...
    class sharded_cache (line 738) | class sharded_cache {
      method get_cpu (line 742) | inline
      method sharded_cache (line 747) | sharded_cache(sharded<cache>& peers) : _peers(peers) {}
      method flush_all (line 749) | future<> flush_all() {
      method flush_at (line 753) | future<> flush_at(uint32_t time) {
      method get_wc_to_clock_type_delta (line 757) | auto get_wc_to_clock_type_delta() { return _peers.local().get_wc_to_...
      method set (line 760) | future<bool> set(item_insertion_data& insertion) {
      method add (line 769) | future<bool> add(item_insertion_data& insertion) {
      method replace (line 778) | future<bool> replace(item_insertion_data& insertion) {
      method remove (line 787) | future<bool> remove(const item_key& key) {
      method get (line 793) | future<item_ptr> get(const item_key& key) {
      method cas (line 799) | future<cas_result> cas(item_insertion_data& insertion, item::version...
      method stats (line 807) | future<cache_stats> stats() {
      method incr (line 812) | future<std::pair<item_ptr, bool>> incr(item_key& key, uint64_t delta) {
      method decr (line 822) | future<std::pair<item_ptr, bool>> decr(item_key& key, uint64_t delta) {
      method print_hash_stats (line 831) | future<> print_hash_stats(output_stream<char>& out) {
    type system_stats (line 841) | struct system_stats {
      method system_stats (line 849) | system_stats() {
      method system_stats (line 852) | system_stats(clock_type::time_point start_time)
      method system_stats (line 855) | system_stats self() {
      method stop (line 866) | future<> stop() { return make_ready_future<>(); }
    class ascii_protocol (line 869) | class ascii_protocol {
      method append (line 894) | static void append(std::vector<temporary_buffer<char>>& bufs, const ...
      method append (line 900) | static void append(std::vector<temporary_buffer<char>>& bufs, const ...
      method append (line 901) | static void append(std::vector<temporary_buffer<char>>& bufs, const ...
      method serialize (line 904) | static void serialize(std::vector<temporary_buffer<char>>& bufs, ite...
      method handle_get (line 924) | future<> handle_get(output_stream<char>& out) {
      method print_stat (line 951) | static future<> print_stat(output_stream<char>& out, const char* key...
      method print_stats (line 959) | future<> print_stats(output_stream<char>& out) {
      method ascii_protocol (line 1042) | ascii_protocol(sharded_cache& cache, sharded<system_stats>& system_s...
      method prepare_insertion (line 1047) | void prepare_insertion() {
      method handle (line 1056) | future<> handle(input_stream<char>& in, output_stream<char>& out) {
    class udp_server (line 1234) | class udp_server {
      type header (line 1245) | struct header {
        method adjust_endianness (line 1252) | auto adjust_endianness(Adjuster a) {
      type connection (line 1257) | struct connection {
        method output_stream_options (line 1265) | static output_stream_options make_opts() noexcept {
        method connection (line 1271) | connection(ipv4_addr src, input_stream<char>&& in, size_t out_size,
        method respond (line 1279) | future<> respond(udp_channel& chan) {
      method udp_server (line 1295) | udp_server(sharded_cache& c, sharded<system_stats>& system_stats, ui...
      method set_max_datagram_size (line 1301) | void set_max_datagram_size(size_t max_datagram_size) {
      method as_input_stream (line 1306) | input_stream<char> as_input_stream(std::span<temporary_buffer<char>>...
      method start (line 1318) | void start() {
      method stop (line 1352) | future<> stop() {
    class tcp_server (line 1361) | class tcp_server {
      type connection (line 1368) | struct connection {
        method connection (line 1375) | connection(connected_socket&& socket, socket_address addr, sharded...
      method tcp_server (line 1391) | tcp_server(sharded_cache& cache, sharded<system_stats>& system_stats...
      method start (line 1397) | void start() {
      method stop (line 1418) | future<> stop() {
    class stats_printer (line 1426) | class stats_printer {
      method stats_printer (line 1431) | stats_printer(sharded_cache& cache)
      method start (line 1434) | void start() {
      method stop (line 1451) | future<> stop() { return make_ready_future<>(); }
  type seastar (line 1456) | namespace seastar {
    function append_buffers (line 1457) | void append_buffers(jagged_array_of_buffers& vb, std::span<temporary_b...
  function main (line 1466) | int main(int ac, char** av) {

FILE: apps/memcached/memcached.hh
  type memcache (line 23) | namespace memcache {
    class item (line 27) | class item
    class cache (line 28) | class cache
    class item_key (line 30) | class item_key {
      method item_key (line 35) | item_key() = default;
      method item_key (line 36) | item_key(item_key&) = default;
      method item_key (line 37) | item_key(sstring key)
      method item_key (line 41) | item_key(item_key&& other)
      method hash (line 47) | size_t hash() const {
      method sstring (line 50) | const sstring& key() const {
  type std (line 65) | namespace std {
    type hash<memcache::item_key> (line 68) | struct hash<memcache::item_key> {

FILE: apps/memcached/tests/test.py
  function run (line 27) | def run(args, cmd):

FILE: apps/memcached/tests/test_ascii_parser.cc
  function make_packet (line 36) | static std::vector<temporary_buffer<char>> make_packet(std::vector<std::...
  function parse (line 48) | static auto parse(std::vector<temporary_buffer<char>>&& bufs) {
  function SEASTAR_TEST_CASE (line 66) | SEASTAR_TEST_CASE(test_set_command_is_parsed) {
  function SEASTAR_TEST_CASE (line 80) | SEASTAR_TEST_CASE(test_empty_data_is_parsed) {
  function SEASTAR_TEST_CASE (line 94) | SEASTAR_TEST_CASE(test_superflous_data_is_an_error) {
  function SEASTAR_TEST_CASE (line 102) | SEASTAR_TEST_CASE(test_not_enough_data_is_an_error) {
  function SEASTAR_TEST_CASE (line 110) | SEASTAR_TEST_CASE(test_u32_parsing) {
  function SEASTAR_TEST_CASE (line 143) | SEASTAR_TEST_CASE(test_parsing_of_split_data) {
  function as_strings (line 227) | static std::vector<sstring> as_strings(std::vector<item_key>& keys) {
  function SEASTAR_TEST_CASE (line 235) | SEASTAR_TEST_CASE(test_get_parsing) {
  function SEASTAR_TEST_CASE (line 260) | SEASTAR_TEST_CASE(test_catches_errors_in_get) {
  function SEASTAR_TEST_CASE (line 272) | SEASTAR_TEST_CASE(test_parser_returns_eof_state_when_no_command_follows) {
  function SEASTAR_TEST_CASE (line 288) | SEASTAR_TEST_CASE(test_incomplete_command_is_an_error) {
  function SEASTAR_TEST_CASE (line 304) | SEASTAR_TEST_CASE(test_multiple_requests_in_one_stream) {

FILE: apps/memcached/tests/test_memcached.py
  class TimeoutError (line 33) | class TimeoutError(Exception):
  function tcp_connection (line 37) | def tcp_connection(timeout=1):
  function slow (line 47) | def slow(f):
  function recv_all (line 54) | def recv_all(s):
  function tcp_call (line 63) | def tcp_call(msg, timeout=1):
  function udp_call_for_fragments (line 73) | def udp_call_for_fragments(msg, timeout=1):
  function udp_call (line 107) | def udp_call(msg, **kwargs):
  class MemcacheTest (line 110) | class MemcacheTest(unittest.TestCase):
    method set (line 111) | def set(self, key, value, flags=0, expiry=0):
    method delete (line 114) | def delete(self, key):
    method assertHasKey (line 117) | def assertHasKey(self, key):
    method assertNoKey (line 122) | def assertNoKey(self, key):
    method setKey (line 127) | def setKey(self, key):
    method getItemVersion (line 130) | def getItemVersion(self, key):
    method getStat (line 134) | def getStat(self, name, call_fn=None):
    method flush (line 140) | def flush(self):
    method tearDown (line 143) | def tearDown(self):
  class TcpSpecificTests (line 146) | class TcpSpecificTests(MemcacheTest):
    method test_recovers_from_errors_in_the_stream (line 147) | def test_recovers_from_errors_in_the_stream(self):
    method test_incomplete_command_results_in_error (line 152) | def test_incomplete_command_results_in_error(self):
    method test_stream_closed_results_in_error (line 160) | def test_stream_closed_results_in_error(self):
    method test_unsuccesful_parsing_does_not_leave_data_behind (line 167) | def test_unsuccesful_parsing_does_not_leave_data_behind(self):
    method test_flush_all_no_reply (line 174) | def test_flush_all_no_reply(self):
    method test_set_no_reply (line 177) | def test_set_no_reply(self):
    method test_delete_no_reply (line 181) | def test_delete_no_reply(self):
    method test_add_no_reply (line 185) | def test_add_no_reply(self):
    method test_replace_no_reply (line 189) | def test_replace_no_reply(self):
    method test_cas_noreply (line 194) | def test_cas_noreply(self):
    method test_connection_statistics (line 211) | def test_connection_statistics(self):
  class UdpSpecificTests (line 227) | class UdpSpecificTests(MemcacheTest):
    method test_large_response_is_split_into_mtu_chunks (line 228) | def test_large_response_is_split_into_mtu_chunks(self):
  class TestCommands (line 244) | class TestCommands(MemcacheTest):
    method test_basic_commands (line 245) | def test_basic_commands(self):
    method test_error_handling (line 253) | def test_error_handling(self):
    method test_expiry (line 257) | def test_expiry(self):
    method test_expiry_at_epoch_time (line 264) | def test_expiry_at_epoch_time(self):
    method test_multiple_keys_in_get (line 271) | def test_multiple_keys_in_get(self):
    method test_flush_all (line 279) | def test_flush_all(self):
    method test_keys_set_after_flush_remain (line 284) | def test_keys_set_after_flush_remain(self):
    method test_flush_all_with_timeout_flushes_all_keys_even_those_set_after_flush (line 291) | def test_flush_all_with_timeout_flushes_all_keys_even_those_set_after_...
    method test_subsequent_flush_is_merged (line 301) | def test_subsequent_flush_is_merged(self):
    method test_immediate_flush_cancels_delayed_flush (line 313) | def test_immediate_flush_cancels_delayed_flush(self):
    method test_flushing_in_the_past (line 322) | def test_flushing_in_the_past(self):
    method test_memcache_does_not_crash_when_flushing_with_already_expred_items (line 333) | def test_memcache_does_not_crash_when_flushing_with_already_expred_ite...
    method test_response_spanning_many_datagrams (line 338) | def test_response_spanning_many_datagrams(self):
    method test_version (line 361) | def test_version(self):
    method test_add (line 364) | def test_add(self):
    method test_replace (line 369) | def test_replace(self):
    method test_cas_and_gets (line 375) | def test_cas_and_gets(self):
    method test_curr_items_stat (line 389) | def test_curr_items_stat(self):
    method test_how_stats_change_with_different_commands (line 396) | def test_how_stats_change_with_different_commands(self):
    method test_incr (line 502) | def test_incr(self):
    method test_decr (line 521) | def test_decr(self):
    method test_incr_and_decr_on_invalid_input (line 543) | def test_incr_and_decr_on_invalid_input(self):
  function wait_for_memcache_tcp (line 553) | def wait_for_memcache_tcp(timeout=4):
  function wait_for_memcache_udp (line 567) | def wait_for_memcache_udp(timeout=4):

FILE: apps/rpc_tester/rpc_tester.cc
  type serializer (line 53) | struct serializer {}
  function write_arithmetic_type (line 56) | inline
  function T (line 63) | inline
  function write (line 72) | inline void write(serializer, Output& output, int32_t v) { return write_...
  function write (line 74) | inline void write(serializer, Output& output, uint32_t v) { return write...
  function write (line 76) | inline void write(serializer, Output& output, int64_t v) { return write_...
  function write (line 78) | inline void write(serializer, Output& output, uint64_t v) { return write...
  function write (line 80) | inline void write(serializer, Output& output, double v) { return write_a...
  function read (line 82) | inline int32_t read(serializer, Input& input, rpc::type<int32_t>) { retu...
  function read (line 84) | inline uint32_t read(serializer, Input& input, rpc::type<uint32_t>) { re...
  function read (line 86) | inline uint64_t read(serializer, Input& input, rpc::type<uint64_t>) { re...
  function read (line 88) | inline uint64_t read(serializer, Input& input, rpc::type<int64_t>) { ret...
  function read (line 90) | inline double read(serializer, Input& input, rpc::type<double>) { return...
  function write (line 93) | inline void write(serializer, Output& out, const sstring& v) {
  function sstring (line 99) | inline sstring read(serializer, Input& in, rpc::type<sstring>) {
  function write (line 109) | inline void write(serializer, Output& out, const payload_t& v) {
  function payload_t (line 115) | inline payload_t read(serializer, Input& in, rpc::type<payload_t>) {
  class pause_distribution (line 123) | class pause_distribution {
    method Dur (line 129) | Dur get_as() {
  class steady_process (line 136) | class steady_process : public pause_distribution {
    method steady_process (line 139) | steady_process(std::chrono::duration<double> period) : _pause(period) { }
    method get (line 140) | std::chrono::duration<double> get() override { return _pause; }
  function make_steady_pause (line 143) | std::unique_ptr<pause_distribution> make_steady_pause(std::chrono::durat...
  class uniform_process (line 147) | class uniform_process : public pause_distribution {
    method uniform_process (line 153) | uniform_process(std::chrono::duration<double> min, std::chrono::durati...
    method get (line 156) | std::chrono::duration<double> get() override {
  type duration_range (line 161) | struct duration_range {
  function make_uniform_pause (line 166) | std::unique_ptr<pause_distribution> make_uniform_pause(duration_range ra...
  type client_config (line 170) | struct client_config {
  type server_config (line 174) | struct server_config {
  type job_config (line 178) | struct job_config {
  type config (line 199) | struct config {
  type duration_time (line 205) | struct duration_time {
  type byte_size (line 209) | struct byte_size {
  type YAML (line 213) | namespace YAML {
    type convert<client_config> (line 216) | struct convert<client_config> {
      method decode (line 217) | static bool decode(const Node& node, client_config& cfg) {
    type convert<server_config> (line 226) | struct convert<server_config> {
      method decode (line 227) | static bool decode(const Node& node, server_config& cfg) {
    type convert<job_config> (line 236) | struct convert<job_config> {
      method decode (line 237) | static bool decode(const Node& node, job_config& cfg) {
    type convert<config> (line 285) | struct convert<config> {
      method decode (line 286) | static bool decode(const Node& node, config& cfg) {
    type convert<duration_time> (line 301) | struct convert<duration_time> {
      method decode (line 302) | static bool decode(const Node& node, duration_time& dt) {
    type convert<byte_size> (line 333) | struct convert<byte_size> {
      method decode (line 334) | static bool decode(const Node& node, byte_size& bs) {
  type rpc_verb (line 352) | enum class rpc_verb : int32_t {
  class job (line 364) | class job {
  class job_rpc (line 372) | class job_rpc : public job {
    method call_echo (line 385) | future<> call_echo(unsigned dummy) {
    method call_write (line 394) | future<> call_write(unsigned dummy, const payload_t& pl) {
    method job_rpc (line 402) | job_rpc(job_config cfg, rpc_protocol& rpc, client_config ccfg, socket_...
    method name (line 430) | virtual std::string name() const override { return _cfg.name; }
    method run (line 432) | virtual future<> run() override {
    method emit_result (line 468) | virtual void emit_result(YAML::Emitter& out) const override {
  class job_rpc_streaming (line 481) | class job_rpc_streaming : public job {
    method job_rpc_streaming (line 496) | job_rpc_streaming(job_config cfg, rpc_protocol& rpc, client_config ccf...
    method name (line 517) | virtual std::string name() const override { return _cfg.name; }
    method stream_data (line 520) | future<> stream_data(rpc::sink<payload_t> sink, const payload_t& paylo...
    method run_streaming_worker (line 550) | future<> run_streaming_worker(unsigned worker_id, const payload_t& pay...
    method run_worker_with_delay (line 571) | future<> run_worker_with_delay(unsigned worker_id, const payload_t& pa...
    method run (line 580) | virtual future<> run() override {
    method emit_result (line 597) | virtual void emit_result(YAML::Emitter& out) const override {
    method process_bi_source (line 613) | static future<> process_bi_source(rpc::source<payload_t> source, rpc::...
    method process_uni_source (line 646) | static future<> process_uni_source(rpc::source<payload_t> source, rpc:...
  class job_cpu (line 684) | class job_cpu : public job {
    method make_pause (line 691) | std::unique_ptr<pause_distribution> make_pause() {
    method make_sleep (line 699) | std::unique_ptr<pause_distribution> make_sleep() {
    method job_cpu (line 710) | job_cpu(job_config cfg)
    method name (line 717) | virtual std::string name() const override { return _cfg.name; }
    method emit_result (line 718) | virtual void emit_result(YAML::Emitter& out) const override {
    method run (line 722) | virtual future<> run() override {
  class context (line 745) | class context {
    method make_job (line 755) | std::unique_ptr<job> make_job(job_config cfg, std::optional<socket_add...
    method run_jobs (line 769) | future<> run_jobs() {
    method isolate_connection (line 775) | rpc::isolation_config isolate_connection(std::string group_name) {
    method context (line 784) | context(std::optional<socket_address> laddr, std::optional<socket_addr...
    method start (line 848) | future<> start() {
    method stop (line 856) | future<> stop() {
    method run (line 870) | future<> run() {
    method emit_result (line 882) | future<> emit_result(YAML::Emitter& out) const {
  function main (line 894) | int main(int ac, char** av) {

FILE: apps/seawreck/seawreck.cc
  function http_debug (line 34) | void http_debug(const char* fmt, Args&&... args) {
  class http_client (line 40) | class http_client {
    method http_client (line 53) | http_client(unsigned duration, unsigned total_conn, unsigned reqs_per_...
    class connection (line 61) | class connection {
      method connection (line 70) | connection(connected_socket&& fd, http_client* client)
      method nr_done (line 77) | uint64_t nr_done() {
      method do_req (line 81) | future<> do_req() {
    method total_reqs (line 114) | future<uint64_t> total_reqs() {
    method done (line 119) | bool done(uint64_t nr_done) {
    method connect (line 127) | future<> connect(ipv4_addr server_addr) {
    method run (line 140) | future<> run() {
    method stop (line 167) | future<> stop() {
  function main (line 174) | int main(int ac, char** av) {

FILE: cmake/check-seastar-include-style.py
  function check_includes (line 26) | def check_includes(files, dirname):
  function main (line 40) | def main():

FILE: cmake/code_tests/LinuxMembarrier_test.cc
  function main (line 5) | int main() {

FILE: cmake/code_tests/Sanitizers_fiber_test.cc
  function main (line 8) | int main() {

FILE: cmake/code_tests/Source_location_default_argument.cc
  function test_source_location (line 3) | int test_source_location(int line,
  function main (line 8) | int main() {

FILE: cmake/code_tests/Source_location_test.cc
  type format_info (line 13) | struct format_info {
    method format_info (line 14) | format_info(source_location loc = source_location::current()) noexcept
  type format_info (line 20) | struct format_info { }
    method format_info (line 14) | format_info(source_location loc = source_location::current()) noexcept
  function main (line 23) | int main()

FILE: cmake/code_tests/rt_test.cc
  function main (line 6) | int main() {

FILE: cmake/code_tests/stdout_test.cc
  type logger_type (line 3) | enum class logger_type {
  function main (line 8) | int main() {}

FILE: configure.py
  function add_tristate (line 31) | def add_tristate(arg_parser, name, dest, help, default=None):
  function try_compile (line 38) | def try_compile(compiler, source='', flags=[]):
  function ensure_tmp_dir_exists (line 42) | def ensure_tmp_dir_exists():
  function try_compile_and_link (line 47) | def try_compile_and_link(compiler, source='', flags=[]):
  function standard_supported (line 65) | def standard_supported(standard, compiler='g++'):
  function find_compiler_cache (line 69) | def find_compiler_cache(preference):
  function find_compiler (line 105) | def find_compiler(name):
  function resolve_compilers_for_compiler_cache (line 128) | def resolve_compilers_for_compiler_cache(args, compiler_cache):
  function identify_best_standard (line 232) | def identify_best_standard(cpp_standards, compiler):
  function get_valid_ingredients (line 263) | def get_valid_ingredients():
  function configure_mode (line 273) | def configure_mode(mode):

FILE: demos/block_discard_demo.cc
  type file_test (line 35) | struct file_test {
    method file_test (line 36) | file_test(file&& f) : f(std::move(f)) {}
  function main (line 41) | int main(int ac, char** av) {

FILE: demos/coroutines_demo.cc
  function main (line 35) | int main(int argc, char** argv) {

FILE: demos/echo_demo.cc
  function dump_packet (line 35) | void dump_packet(const packet& p) {
  function echo_packet (line 46) | future<> echo_packet(net::qp& netif, packet p) {
  function usage (line 83) | void usage()
  function main (line 91) | int main(int ac, char** av) {

FILE: demos/file_demo.cc
  function verify_data_file (line 50) | future<> verify_data_file(file& f, temporary_buffer<char>& rbuf, const t...
  function open_data_file (line 58) | future<file> open_data_file(sstring meta_filename, temporary_buffer<char...
  function demo_with_file (line 70) | future<> demo_with_file() {
  function demo_with_file_close_on_failure (line 112) | future<> demo_with_file_close_on_failure() {
  function demo_with_io_intent (line 175) | future<> demo_with_io_intent(std::chrono::duration<double> d) {
  function main (line 237) | int main(int ac, char** av) {

FILE: demos/hello-cxx-module.cc
  function main (line 27) | int main(int argc, char** argv) {

FILE: demos/hello-world.cc
  function main (line 29) | int main(int argc, char** argv) {

FILE: demos/http_client_demo.cc
  type printer (line 38) | struct printer {
  function main (line 48) | int main(int ac, char** av) {

FILE: demos/ip_demo.cc
  function main (line 33) | int main(int ac, char** av) {

FILE: demos/l3_demo.cc
  function dump_arp_packets (line 31) | void dump_arp_packets(l3_protocol& proto) {
  function main (line 39) | int main(int ac, char** av) {

FILE: demos/line_count_demo.cc
  type reader (line 35) | struct reader {
    method reader (line 37) | reader(file f)
  function main (line 57) | int main(int ac, char** av) {

FILE: demos/rpc_demo.cc
  type serializer (line 34) | struct serializer {
  function write_arithmetic_type (line 38) | inline
  function T (line 45) | inline
  function write (line 54) | inline void write(serializer, Output& output, int32_t v) { return write_...
  function write (line 56) | inline void write(serializer, Output& output, uint32_t v) { return write...
  function write (line 58) | inline void write(serializer, Output& output, int64_t v) { return write_...
  function write (line 60) | inline void write(serializer, Output& output, uint64_t v) { return write...
  function write (line 62) | inline void write(serializer, Output& output, double v) { return write_a...
  function read (line 64) | inline int32_t read(serializer, Input& input, rpc::type<int32_t>) { retu...
  function read (line 66) | inline uint32_t read(serializer, Input& input, rpc::type<uint32_t>) { re...
  function read (line 68) | inline uint64_t read(serializer, Input& input, rpc::type<uint64_t>) { re...
  function read (line 70) | inline uint64_t read(serializer, Input& input, rpc::type<int64_t>) { ret...
  function read (line 72) | inline double read(serializer, Input& input, rpc::type<double>) { return...
  function write (line 75) | inline void write(serializer, Output& out, const sstring& v) {
  function sstring (line 81) | inline sstring read(serializer, Input& in, rpc::type<sstring>) {
  class mycomp (line 91) | class mycomp : public rpc::compressor::factory {
    method sstring (line 94) | virtual const sstring& supported() const override {
    method negotiate (line 98) | virtual std::unique_ptr<rpc::compressor> negotiate(sstring feature, bo...
  function main (line 104) | int main(int ac, char** av) {

FILE: demos/scheduling_group_demo.cc
  function compute_intensive_task (line 41) | future<>
  function heavy_task (line 51) | future<>
  function light_task (line 59) | future<>
  function medium_task (line 67) | future<>
  function run_compute_intensive_tasks (line 77) | future<>
  function run_compute_intensive_tasks_in_threads (line 91) | future<>
  function run_with_duty_cycle (line 105) | future<>
  function var_fn (line 135) | auto var_fn(T& var) {
  function main (line 139) | int main(int ac, char** av) {

FILE: demos/sharded_parameter_demo.cc
  class service_one (line 32) | class service_one {
    method get_capacity (line 36) | int get_capacity() const { return _capacity; }
  class service_two (line 40) | class service_two {
    method service_two (line 43) | service_two(service_one& s1, int resource_allocation) : _resource_allo...
    method get_resource_allocation (line 44) | int get_resource_allocation() const { return _resource_allocation; }
  function main (line 47) | int main(int ac, char** av) {

FILE: demos/tcp_demo.cc
  type tcp_test (line 32) | struct tcp_test {
    type connection (line 36) | struct connection {
      method connection (line 38) | explicit connection(tcp::connection tc) : tcp_conn(std::move(tc)) {}
      method run (line 39) | void run() {
    method tcp_test (line 54) | tcp_test(ipv4& inet) : inet(inet), _listener(inet.get_tcp().listen(100...
    method run (line 55) | void run() {
  function main (line 64) | int main(int ac, char** av) {

FILE: demos/tcp_sctp_client_demo.cc
  class client (line 39) | class client
    class connection (line 56) | class connection {
      method connection (line 63) | connection(connected_socket&& fd)
      method do_read (line 68) | future<> do_read() {
      method do_write (line 79) | future<> do_write(int end) {
      method ping (line 91) | future<> ping(int times) {
      method rxrx (line 114) | future<size_t> rxrx() {
      method txtx (line 126) | future<size_t> txtx() {
    method ping_test (line 137) | future<> ping_test(connection *conn) {
    method rxrx_test (line 145) | future<> rxrx_test(connection *conn) {
    method txtx_test (line 153) | future<> txtx_test(connection *conn) {
    method ping_report (line 161) | void ping_report(lowres_clock::time_point started, lowres_clock::time_...
    method rxtx_report (line 183) | void rxtx_report(lowres_clock::time_point started, lowres_clock::time_...
    method start (line 206) | future<> start(ipv4_addr server_addr, std::string test, unsigned ncon) {
    method stop (line 228) | future<> stop() {
  class client (line 44) | class client {
    class connection (line 56) | class connection {
      method connection (line 63) | connection(connected_socket&& fd)
      method do_read (line 68) | future<> do_read() {
      method do_write (line 79) | future<> do_write(int end) {
      method ping (line 91) | future<> ping(int times) {
      method rxrx (line 114) | future<size_t> rxrx() {
      method txtx (line 126) | future<size_t> txtx() {
    method ping_test (line 137) | future<> ping_test(connection *conn) {
    method rxrx_test (line 145) | future<> rxrx_test(connection *conn) {
    method txtx_test (line 153) | future<> txtx_test(connection *conn) {
    method ping_report (line 161) | void ping_report(lowres_clock::time_point started, lowres_clock::time_...
    method rxtx_report (line 183) | void rxtx_report(lowres_clock::time_point started, lowres_clock::time_...
    method start (line 206) | future<> start(ipv4_addr server_addr, std::string test, unsigned ncon) {
    method stop (line 228) | future<> stop() {
  function main (line 238) | int main(int ac, char ** av) {

FILE: demos/tcp_sctp_server_demo.cc
  class tcp_server (line 48) | class tcp_server {
    method listen (line 55) | future<> listen(ipv4_addr addr) {
    method stop (line 74) | future<> stop() {
    method do_accepts (line 79) | future<> do_accepts(std::vector<server_socket>& listeners) {
    method do_stop (line 104) | static future<> do_stop(std::vector<server_socket>& listeners, std::op...
    class connection (line 113) | class connection {
      method connection (line 118) | connection(tcp_server& server, connected_socket&& fd, socket_address...
      method process (line 122) | future<> process() {
      method read (line 125) | future<> read() {
      method do_write (line 159) | future<> do_write(int end) {
      method tx_test (line 169) | future<> tx_test() {
      method do_read (line 176) | future<> do_read() {
      method rx_test (line 185) | future<> rx_test() {
  function main (line 195) | int main(int ac, char** av) {

FILE: demos/tls_echo_server.hh
  type streams (line 34) | struct streams {
    method streams (line 39) | streams(connected_socket cs) : s(std::move(cs)), in(s.input()), out(s....
  class echoserver (line 43) | class echoserver {
    method echoserver (line 50) | echoserver(bool verbose = false)
    method listen (line 55) | future<> listen(socket_address addr, sstring crtfile, sstring keyfile,...
    method stop (line 116) | future<> stop() {

FILE: demos/tls_echo_server_demo.cc
  function main (line 35) | int main(int ac, char** av) {

FILE: demos/tls_simple_client_demo.cc
  function main (line 36) | int main(int ac, char** av) {

FILE: demos/tutorial_examples.cc
  function service_loop (line 29) | seastar::future<> service_loop() {
  function service_loop_2 (line 43) | seastar::future<> service_loop_2() {
  function handle_connection_3 (line 64) | seastar::future<> handle_connection_3(seastar::connected_socket s,
  function service_loop_3 (line 89) | seastar::future<> service_loop_3() {
  function main (line 111) | int main(int ac, char** av) {

FILE: demos/udp_client_demo.cc
  class client (line 32) | class client {
    method start (line 40) | void start(ipv4_addr server_addr) {
  function main (line 79) | int main(int ac, char ** av) {

FILE: demos/udp_server_demo.cc
  class udp_server (line 34) | class udp_server {
    method start (line 41) | void start(uint16_t port) {
    method stop (line 62) | future<> stop() {
  function main (line 77) | int main(int ac, char ** av) {

FILE: demos/udp_zero_copy_demo.cc
  function to_seconds (line 39) | typename Duration::rep to_seconds(Duration d) {
  class server (line 43) | class server {
    method server (line 63) | server()
    method send (line 66) | future<> send(ipv4_addr dst, std::vector<temporary_buffer<char>> bufs) {
    method start (line 71) | void start(int chunk_size, bool copy, size_t mem_size) {
  function main (line 120) | int main(int ac, char ** av) {

FILE: demos/websocket_client_demo.cc
  function main (line 36) | int main(int argc, char** argv) {

FILE: demos/websocket_server_demo.cc
  function main (line 37) | int main(int argc, char** argv) {

FILE: doc/htmlsplit.py
  function add_elem_to_body (line 40) | def add_elem_to_body(tree, e):
  function add_nav_to_body (line 45) | def add_nav_to_body(tree, chap_num):
  function handle_toc (line 71) | def handle_toc(toc):
  function fix_links (line 94) | def fix_links(e):
  function remove_ns_prefix (line 105) | def remove_ns_prefix(tree):
  function get_chap_num (line 112) | def get_chap_num(element):

FILE: include/seastar/core/abort_on_ebadf.hh
  type seastar (line 25) | namespace seastar {

FILE: include/seastar/core/abort_on_expiry.hh
  type seastar (line 29) | namespace seastar {
    class abort_on_expiry (line 37) | class abort_on_expiry {
      method abort_on_expiry (line 46) | abort_on_expiry(time_point timeout) : _tr([this] {
      method abort_on_expiry (line 51) | abort_on_expiry(abort_on_expiry&&) = delete;

FILE: include/seastar/core/abort_source.hh
  type seastar (line 37) | namespace seastar {
    class abort_requested_exception (line 45) | class abort_requested_exception : public std::exception {
    class abort_source (line 55) | class abort_source {
      class subscription (line 63) | class subscription : public bi::list_base_hook<bi::link_mode<bi::aut...
        method subscription (line 69) | explicit subscription(abort_source& as, subscription_callback_type...
        type naive_cb_tag (line 76) | struct naive_cb_tag {}
        method subscription (line 77) | explicit subscription(naive_cb_tag, abort_source& as, naive_subscr...
        method on_abort (line 90) | void on_abort(const std::optional<std::exception_ptr>& ex) noexcept {
        method subscription (line 98) | subscription() = default;
        method subscription (line 100) | subscription(subscription&& other) noexcept(std::is_nothrow_move_c...
        method subscription (line 107) | subscription& operator=(subscription&& other) noexcept(std::is_not...
      method do_request_abort (line 127) | void do_request_abort(std::optional<std::exception_ptr> ex) noexcept {
      method abort_source (line 141) | abort_source() = default;
      method abort_source (line 144) | abort_source(abort_source&&) = default;
      method abort_source (line 145) | abort_source& operator=(abort_source&&) = default;
      method subscribe (line 165) | [[nodiscard]]
      method request_abort (line 177) | void request_abort() noexcept {
      method request_abort_ex (line 184) | void request_abort_ex(std::exception_ptr ex) noexcept {
      method request_abort_ex (line 192) | void request_abort_ex(Exception&& e) noexcept {
      method abort_requested (line 197) | bool abort_requested() const noexcept {
      method check (line 203) | void check() const {
      method get_default_exception (line 216) | virtual std::exception_ptr get_default_exception() const noexcept {
  type fmt::formatter<seastar::abort_requested_exception> (line 229) | struct fmt::formatter<seastar::abort_requested_exception> : fmt::formatt...
    method format (line 230) | auto format(const seastar::abort_requested_exception& e, fmt::format_c...

FILE: include/seastar/core/abortable_fifo.hh
  type seastar (line 33) | namespace seastar {
    type internal (line 35) | namespace internal {
      type noop_aborter (line 46) | struct noop_aborter {
      class abortable_fifo (line 61) | class abortable_fifo {
        type entry (line 63) | struct entry {
          method entry (line 66) | entry(T&& payload_) : payload(std::move(payload_)) {}
          method entry (line 67) | entry(const T& payload_) : payload(payload_) {}
          method entry (line 68) | entry(T payload_, abortable_fifo& ef, abort_source& as)
          method entry (line 80) | entry() = default;
          method entry (line 81) | entry(entry&& x) = delete;
          method entry (line 82) | entry(const entry& x) = delete;
        method drop_expired_front (line 97) | void drop_expired_front() noexcept {
        method abortable_fifo (line 106) | abortable_fifo() noexcept = default;
        method abortable_fifo (line 107) | abortable_fifo(OnAbort on_abort) noexcept(std::is_nothrow_move_con...
        method abortable_fifo (line 109) | abortable_fifo(abortable_fifo&& o) noexcept
        method abortable_fifo (line 115) | abortable_fifo& operator=(abortable_fifo&& o) noexcept {
        method empty (line 128) | bool empty() const noexcept {
        method T (line 139) | T& front() noexcept {
        method T (line 148) | const T& front() const noexcept {
        method size (line 158) | size_t size() const noexcept {
        method reserve (line 166) | void reserve(size_t size) {
        method push_back (line 172) | void push_back(const T& payload) {
        method push_back (line 183) | void push_back(T&& payload) {
        method push_back (line 194) | void push_back(T&& payload, abort_source& as) {
        method T (line 213) | T& emplace_back(U&&... args) {
        method make_back_abortable (line 232) | void make_back_abortable(abort_source& as) {
        method pop_front (line 257) | void pop_front() noexcept {

FILE: include/seastar/core/alien.hh
  type seastar (line 39) | namespace seastar {
    class reactor (line 41) | class reactor
    type alien (line 44) | namespace alien {
      class message_queue (line 46) | class message_queue {
        type work_item (line 49) | struct work_item
        type lf_queue_remote (line 50) | struct lf_queue_remote {
        type lf_queue (line 55) | struct lf_queue : lf_queue_remote, lf_queue_base {
          method lf_queue (line 56) | lf_queue(reactor* remote)
        type work_item (line 72) | struct work_item {
        type async_work_item (line 77) | struct async_work_item : work_item {
          method async_work_item (line 79) | async_work_item(Func&& func) : _func(std::move(func)) {}
          method process (line 80) | void process() override {
        method submit (line 92) | void submit(Func&& func) {
      type internal (line 100) | namespace internal {
        type qs_deleter (line 102) | struct qs_deleter {
          method qs_deleter (line 104) | qs_deleter(unsigned n = 0) : count(n) {}
        type return_type_of (line 153) | struct return_type_of {
          method set (line 155) | static void set(std::promise<void>& p, return_value_t<Func>&&) {
        type return_type_of<Func, false> (line 160) | struct return_type_of<Func, false> {
          method set (line 163) | static void set(std::promise<type>& p, return_value_t<Func>&& t) {
      class instance (line 114) | class instance {
      type internal (line 123) | namespace internal {
        type qs_deleter (line 102) | struct qs_deleter {
          method qs_deleter (line 104) | qs_deleter(unsigned n = 0) : count(n) {}
        type return_type_of (line 153) | struct return_type_of {
          method set (line 155) | static void set(std::promise<void>& p, return_value_t<Func>&&) {
        type return_type_of<Func, false> (line 160) | struct return_type_of<Func, false> {
          method set (line 163) | static void set(std::promise<type>& p, return_value_t<Func>&& t) {
      function run_on (line 143) | void run_on(instance& instance, unsigned shard, Func func) {
      type internal (line 147) | namespace internal {
        type qs_deleter (line 102) | struct qs_deleter {
          method qs_deleter (line 104) | qs_deleter(unsigned n = 0) : count(n) {}
        type return_type_of (line 153) | struct return_type_of {
          method set (line 155) | static void set(std::promise<void>& p, return_value_t<Func>&&) {
        type return_type_of<Func, false> (line 160) | struct return_type_of<Func, false> {
          method set (line 163) | static void set(std::promise<type>& p, return_value_t<Func>&& t) {
      function submit_to (line 180) | std::future<T> submit_to(instance& instance, unsigned shard, Func fu...

FILE: include/seastar/core/align.hh
  type seastar (line 27) | namespace seastar {
    function T (line 31) | inline constexpr
    function T (line 37) | inline constexpr
    function T (line 44) | inline constexpr
    function T (line 50) | inline constexpr

FILE: include/seastar/core/aligned_buffer.hh
  type seastar (line 25) | namespace seastar {
    type internal (line 27) | namespace internal {
    type free_deleter (line 32) | struct free_deleter {
    function allocate_aligned_buffer (line 37) | inline

FILE: include/seastar/core/app-template.hh
  type seastar (line 34) | namespace seastar {
    class smp (line 36) | class smp
    type alien (line 38) | namespace alien {
      class instance (line 40) | class instance
    class app_template (line 44) | class app_template {
      type config (line 46) | struct config {
        method config (line 79) | config() {}
      type seastar_options (line 83) | struct seastar_options : public program_options::option_group {
      type positional_option (line 137) | struct positional_option {

FILE: include/seastar/core/bitops.hh
  type seastar (line 27) | namespace seastar {
    function count_leading_zeros (line 30) | inline
    function count_leading_zeros (line 35) | inline
    function count_leading_zeros (line 40) | inline
    function count_trailing_zeros (line 45) | inline
    function count_trailing_zeros (line 50) | inline
    function count_trailing_zeros (line 55) | inline
    function log2ceil (line 61) | inline constexpr unsigned log2ceil(T n) {
    function log2floor (line 69) | inline constexpr unsigned log2floor(T n) {

FILE: include/seastar/core/bitset-iter.hh
  type seastar (line 19) | namespace seastar {
    type bitsets (line 21) | namespace bitsets {
      function get_first_set (line 105) | inline size_t get_first_set(const std::bitset<N>& bitset) noexcept
      function get_last_set (line 116) | inline size_t get_last_set(const std::bitset<N>& bitset) noexcept
      class set_iterator (line 124) | class set_iterator
        method advance (line 127) | void advance() noexcept
        method set_iterator (line 145) | set_iterator() noexcept
        method set_iterator (line 150) | set_iterator(std::bitset<N> bitset, int offset = 0) noexcept
        method set_iterator (line 159) | set_iterator& operator++() noexcept
        method set_iterator (line 165) | set_iterator operator++(int) noexcept
      class set_range (line 192) | class set_range
        method set_range (line 198) | constexpr set_range(std::bitset<N> bitset, int offset = 0) noexcept
        method iterator (line 204) | iterator begin() const noexcept { return iterator(_bitset, _offset...
        method iterator (line 205) | iterator end() const noexcept { return iterator(0); }
      function for_each_set (line 212) | inline set_range<N> for_each_set(std::bitset<N> bitset, int offset =...

FILE: include/seastar/core/byteorder.hh
  type seastar (line 28) | namespace seastar {
    function T (line 32) | inline T cpu_to_le(T x) noexcept {
    function T (line 36) | inline T le_to_cpu(T x) noexcept {
    function T (line 41) | inline T cpu_to_be(T x) noexcept {
    function T (line 45) | inline T be_to_cpu(T x) noexcept {
    function T (line 50) | inline T cpu_to_le(const unaligned<T>& v) noexcept {
    function T (line 55) | inline T le_to_cpu(const unaligned<T>& v) noexcept {
    function T (line 60) | inline
    function write_le (line 69) | inline
    function T (line 77) | inline
    function write_be (line 86) | inline
    function T (line 94) | inline
    function produce_be (line 103) | inline

FILE: include/seastar/core/cacheline.hh
  type seastar (line 26) | namespace seastar {

FILE: include/seastar/core/checked_ptr.hh
  type seastar (line 30) | namespace seastar {
    class checked_ptr_is_null_exception (line 34) | class checked_ptr_is_null_exception : public std::exception {}
    type default_null_deref_action (line 41) | struct default_null_deref_action {
    type internal (line 50) | namespace internal {
      function T (line 71) | inline T* checked_ptr_do_get(T* ptr) noexcept {
    class checked_ptr (line 97) | class checked_ptr {
      method check (line 110) | void check() const {
      method checked_ptr (line 117) | checked_ptr() noexcept(noexcept(Ptr(nullptr))) = default;
      method checked_ptr (line 118) | checked_ptr(std::nullptr_t) noexcept(std::is_nothrow_default_constru...
      method checked_ptr (line 119) | checked_ptr(Ptr&& ptr) noexcept(std::is_nothrow_move_constructible_v...
      method checked_ptr (line 120) | checked_ptr(const Ptr& p) noexcept(std::is_nothrow_copy_constructibl...
      method pointer (line 128) | pointer get() const {
      method Ptr (line 135) | const Ptr& operator->() const {
      method Ptr (line 142) | Ptr& operator->() {
      method element_type (line 149) | const element_type& operator*() const {
      method element_type (line 156) | element_type& operator*() {
      method hash (line 175) | size_t hash() const {
  type std (line 183) | namespace std {
    type hash<seastar::checked_ptr<T>> (line 186) | struct hash<seastar::checked_ptr<T>> {

FILE: include/seastar/core/chunked_fifo.hh
  type seastar (line 31) | namespace seastar {
    class chunked_fifo (line 90) | class chunked_fifo {
      method maybe_item (line 94) | maybe_item() noexcept {}
      type chunk (line 98) | struct chunk {
        type chunk (line 100) | struct chunk
        method size (line 106) | size_t size() const {
      class basic_iterator (line 139) | class basic_iterator {
        method basic_iterator (line 159) | basic_iterator() noexcept = default;
        method basic_iterator (line 162) | inline basic_iterator(const basic_iterator<OtherIsConst>& o) noexcept
      method chunked_fifo (line 177) | chunked_fifo() noexcept = default;
    function T (line 512) | inline
    function T (line 519) | inline
    function T (line 526) | inline T&

FILE: include/seastar/core/circular_buffer.hh
  type seastar (line 30) | namespace seastar {
    class circular_buffer (line 59) | class circular_buffer {
      type impl (line 60) | struct impl : Alloc {
        method impl (line 67) | impl(Alloc a) noexcept : Alloc(std::move(a)) { }
        method reset (line 68) | void reset() {
      method circular_buffer (line 87) | circular_buffer() noexcept requires std::default_initializable<Alloc...
      method circular_buffer (line 90) | circular_buffer(const circular_buffer& X) = delete;
      method circular_buffer (line 92) | circular_buffer& operator=(const circular_buffer&) = delete;
      type cbiterator (line 127) | struct cbiterator {
        method ValueType (line 134) | ValueType& operator*() const noexcept { return cb->_impl.storage[c...
        method ValueType (line 135) | ValueType* operator->() const noexcept { return &cb->_impl.storage...
        method difference_type (line 190) | difference_type operator-(const cbiterator<CB, ValueType>& rhs) co...
        method cbiterator (line 193) | cbiterator() = default;
        method cbiterator (line 197) | cbiterator(CB* b, size_t i) noexcept : cb(b), idx(i) {}
      method iterator (line 206) | iterator begin() noexcept {
      method const_iterator (line 209) | const_iterator begin() const noexcept {
      method iterator (line 212) | iterator end() noexcept {
      method const_iterator (line 215) | const_iterator end() const noexcept {
      method const_iterator (line 218) | const_iterator cbegin() const noexcept {
      method const_iterator (line 221) | const_iterator cend() const noexcept {
    function T (line 422) | inline
    function T (line 429) | inline
    function T (line 436) | inline
    function T (line 443) | inline
    function T (line 466) | inline
    function T (line 473) | inline
    function T (line 480) | inline

FILE: include/seastar/core/circular_buffer_fixed_capacity.hh
  type seastar (line 42) | namespace seastar {
    class circular_buffer_fixed_capacity (line 52) | class circular_buffer_fixed_capacity {
      method maybe_storage (line 57) | maybe_storage() noexcept {}
      method mask (line 62) | static size_t mask(size_t idx) { return idx % Capacity; }
      method T (line 63) | T* obj(size_t idx) { return &_storage[mask(idx)].data; }
      method T (line 64) | const T* obj(size_t idx) const { return &_storage[mask(idx)].data; }
      class cbiterator (line 78) | class cbiterator {
        method cbiterator (line 83) | cbiterator(holder* start, size_t idx) noexcept : _start(start), _i...
        method ValueType (line 92) | ValueType& operator*() const { return _start[mask(_idx)].data; }
        method ValueType (line 93) | ValueType* operator->() const { return &operator*(); }
        method cbiterator (line 95) | cbiterator& operator++() {
        method cbiterator (line 100) | cbiterator operator++(int) {
        method cbiterator (line 106) | cbiterator& operator--() {
        method cbiterator (line 111) | cbiterator operator--(int) {
        method cbiterator (line 116) | cbiterator operator+(difference_type n) const {
        method cbiterator (line 119) | cbiterator operator+(difference_type n, cbiterator i) {
        method cbiterator (line 122) | cbiterator operator-(difference_type n) const {
        method cbiterator (line 125) | cbiterator& operator+=(difference_type n) {
        method cbiterator (line 129) | cbiterator& operator-=(difference_type n) {
        method difference_type (line 151) | difference_type operator-(const cbiterator& rhs) const {
      method circular_buffer_fixed_capacity (line 160) | circular_buffer_fixed_capacity() = default;
      method iterator (line 181) | iterator begin() {
      method const_iterator (line 184) | const_iterator begin() const {
      method iterator (line 187) | iterator end() {
      method const_iterator (line 190) | const_iterator end() const {
      method const_iterator (line 193) | const_iterator cbegin() const {
      method const_iterator (line 196) | const_iterator cend() const {
    function T (line 265) | inline
    function T (line 291) | inline
    function T (line 300) | inline
    function T (line 307) | inline
    function T (line 330) | inline
    function calc_circular_buffer_capacity (line 380) | constexpr inline size_t calc_circular_buffer_capacity() {

FILE: include/seastar/core/condition-variable.hh
  type seastar (line 34) | namespace seastar {
    class broken_condition_variable (line 42) | class broken_condition_variable : public std::exception {
    class condition_variable_timed_out (line 50) | class condition_variable_timed_out : public std::exception {
    class condition_variable (line 69) | class condition_variable {
      type waiter (line 73) | struct waiter : public boost::intrusive::list_base_hook<boost::intru...
        method waiter (line 74) | waiter() = default;
        method waiter (line 75) | waiter(waiter&&) = default;
        method waiter (line 76) | waiter(const waiter&) = delete;
        method waiter (line 77) | waiter& operator=(const waiter&) = delete;
      type promise_waiter (line 85) | struct promise_waiter : public waiter, public promise<> {
        method signal (line 86) | void signal() noexcept override {
        method set_exception (line 93) | void set_exception(std::exception_ptr ep) noexcept override {
      type awaiter (line 100) | struct [[nodiscard("must co_await a when() call")]] awaiter : public...
        method awaiter (line 104) | awaiter(condition_variable* cv)
        method signal (line 108) | void signal() noexcept override {
        method set_exception (line 111) | void set_exception(std::exception_ptr ep) noexcept override {
      type timeout_awaiter (line 124) | struct [[nodiscard("must co_await a when() call")]] timeout_awaiter ...
        method timeout_awaiter (line 130) | timeout_awaiter(condition_variable* cv, time_point timeout)
        method signal (line 134) | void signal() noexcept override {
        method set_exception (line 138) | void set_exception(std::exception_ptr ep) noexcept override {
      type predicate_awaiter (line 153) | struct [[nodiscard("must co_await a when() call")]] predicate_awaite...
        method predicate_awaiter (line 156) | predicate_awaiter(Func func, Args&& ...args)
        method signal (line 160) | void signal() noexcept override {
      method condition_variable (line 201) | condition_variable() noexcept = default;
      method condition_variable (line 202) | condition_variable(condition_variable&& rhs) noexcept = default;
      method wait (line 210) | future<> wait() noexcept {
      method wait (line 228) | future<> wait(std::chrono::time_point<Clock, Duration> timeout) noex...
      method wait (line 251) | future<> wait(std::chrono::duration<Rep, Period> timeout) noexcept {
      method wait (line 264) | future<> wait(Pred&& pred) noexcept {
      method wait (line 281) | future<> wait(std::chrono::time_point<Clock, Duration> timeout, Pred...
      method wait (line 298) | future<> wait(std::chrono::duration<Rep, Period> timeout, Pred&& pre...
      method awaiter (line 308) | awaiter when() noexcept {
        method awaiter (line 104) | awaiter(condition_variable* cv)
        method signal (line 108) | void signal() noexcept override {
        method set_exception (line 111) | void set_exception(std::exception_ptr ep) noexcept override {
      method when (line 321) | timeout_awaiter<Clock, Duration> when(std::chrono::time_point<Clock,...
      method when (line 334) | auto when(std::chrono::duration<Rep, Period> timeout) noexcept {
      method when (line 348) | auto when(Pred&& pred) noexcept {
      method when (line 364) | auto when(std::chrono::time_point<Clock, Duration> timeout, Pred&& p...
      method when (line 380) | auto when(std::chrono::duration<Rep, Period> timeout, Pred&& pred) n...
      method has_waiters (line 386) | bool has_waiters() const noexcept {

FILE: include/seastar/core/coroutine.hh
  type seastar (line 46) | namespace seastar {
    type internal (line 48) | namespace internal {
      function execute_involving_handle_destruction_in_await_suspend (line 51) | inline
      function execute_involving_handle_destruction_in_await_suspend (line 62) | inline
      class coroutine_allocators (line 72) | class coroutine_allocators {
      class coroutine_traits_base (line 89) | class coroutine_traits_base {
        class promise_type (line 91) | class promise_type final : public seastar::task, public coroutine_...
          method promise_type (line 94) | promise_type() = default;
          method promise_type (line 95) | promise_type(promise_type&&) = delete;
          method promise_type (line 96) | promise_type(const promise_type&) = delete;
          method return_value (line 99) | void return_value(U&&... value) {
          method return_value (line 103) | void return_value(coroutine::exception ce) noexcept {
          method set_exception (line 107) | void set_exception(std::exception_ptr&& eptr) noexcept {
          method return_value (line 111) | [[deprecated("Forwarding coroutine returns are deprecated as too...
          method unhandled_exception (line 116) | void unhandled_exception() noexcept {
          method get_return_object (line 120) | seastar::future<T> get_return_object() noexcept {
          method initial_suspend (line 124) | std::suspend_never initial_suspend() noexcept { return { }; }
          method final_suspend (line 125) | std::suspend_never final_suspend() noexcept { return { }; }
          method run_and_dispose (line 127) | virtual void run_and_dispose() noexcept override {
          method task (line 132) | task* waiting_task() noexcept override { return _promise.waiting...
          method scheduling_group (line 134) | scheduling_group set_scheduling_group(scheduling_group sg) noexc...
      class coroutine_traits_base<> (line 141) | class coroutine_traits_base<> {
        class promise_type (line 143) | class promise_type final : public seastar::task, public coroutine_...
          method promise_type (line 146) | promise_type() = default;
          method promise_type (line 147) | promise_type(promise_type&&) = delete;
          method promise_type (line 148) | promise_type(const promise_type&) = delete;
          method return_void (line 150) | void return_void() noexcept {
          method set_exception (line 154) | void set_exception(std::exception_ptr&& eptr) noexcept {
          method unhandled_exception (line 158) | void unhandled_exception() noexcept {
          method get_return_object (line 162) | seastar::future<> get_return_object() noexcept {
          method initial_suspend (line 166) | std::suspend_never initial_suspend() noexcept { return { }; }
          method final_suspend (line 167) | std::suspend_never final_suspend() noexcept { return { }; }
          method run_and_dispose (line 169) | virtual void run_and_dispose() noexcept override {
          method task (line 174) | task* waiting_task() noexcept override { return _promise.waiting...
          method scheduling_group (line 176) | scheduling_group set_scheduling_group(scheduling_group new_sg) n...
      type awaiter (line 183) | struct awaiter {
        method awaiter (line 186) | explicit awaiter(seastar::future<T>&& f) noexcept : _future(std::m...
        method awaiter (line 188) | awaiter(const awaiter&) = delete;
        method awaiter (line 189) | awaiter(awaiter&&) = delete;
        method await_ready (line 191) | bool await_ready() const noexcept {
        method await_suspend (line 196) | void await_suspend(std::coroutine_handle<U> hndl SEASTAR_COROUTINE...
        method T (line 205) | T await_resume() { return _future.get(); }
      type awaiter<CheckPreempt, void> (line 209) | struct awaiter<CheckPreempt, void> {
        method awaiter (line 212) | explicit awaiter(seastar::future<>&& f) noexcept : _future(std::mo...
        method awaiter (line 214) | awaiter(const awaiter&) = delete;
        method awaiter (line 215) | awaiter(awaiter&&) = delete;
        method await_ready (line 217) | bool await_ready() const noexcept {
        method await_suspend (line 222) | void await_suspend(std::coroutine_handle<U> hndl SEASTAR_COROUTINE...
        method await_resume (line 231) | void await_resume() { _future.get(); }
    type coroutine (line 242) | namespace coroutine {
      type without_preemption_check (line 248) | struct [[nodiscard]] without_preemption_check : public seastar::futu...
        method without_preemption_check (line 249) | explicit without_preemption_check(seastar::future<T>&& f) noexcept...
      class lambda (line 273) | class lambda {
        method lambda (line 278) | explicit lambda(Func&& func) : _func(&func) {}
  type std (line 300) | namespace std {
  class coroutine_traits<seastar::future<T>, Args...> (line 303) | class coroutine_traits<seastar::future<T>, Args...> : public seastar::in...

FILE: include/seastar/core/deleter.hh
  type seastar (line 30) | namespace seastar {
    class deleter (line 48) | class deleter final {
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    type deleter::impl (line 111) | struct deleter::impl {
      method impl (line 114) | impl(deleter next) : next(std::move(next)) {}
    function deleter (line 130) | inline
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    type lambda_deleter_impl (line 141) | struct lambda_deleter_impl final : deleter::impl {
      method lambda_deleter_impl (line 143) | lambda_deleter_impl(deleter next, Deleter&& del)
    type object_deleter_impl (line 149) | struct object_deleter_impl final : deleter::impl {
      method object_deleter_impl (line 151) | object_deleter_impl(deleter next, Object&& obj)
    function deleter (line 171) | deleter
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    function deleter (line 182) | deleter
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    type free_deleter_impl (line 188) | struct free_deleter_impl final : deleter::impl {
      method free_deleter_impl (line 190) | free_deleter_impl(void* obj) : impl(deleter()), obj(obj) {}
      method free_deleter_impl (line 191) | free_deleter_impl(const free_deleter_impl&) = delete;
      method free_deleter_impl (line 192) | free_deleter_impl(free_deleter_impl&&) = delete;
    function deleter (line 197) | inline
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    function deleter (line 244) | inline
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    function deleter (line 259) | inline
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    function deleter (line 268) | inline
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {
    function deleter (line 277) | inline
      type impl (line 51) | struct impl
      type raw_object_tag (line 52) | struct raw_object_tag {}
      method deleter (line 59) | deleter() noexcept = default;
      method deleter (line 60) | deleter(const deleter&) = delete;
      method deleter (line 62) | deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }
      method deleter (line 64) | explicit deleter(impl* i) noexcept : _impl(i) {}
      method deleter (line 65) | deleter(raw_object_tag, void* object) noexcept
      method deleter (line 71) | deleter& operator=(deleter&) = delete;
      method reset (line 81) | void reset(impl* i) {
      method is_raw_object (line 90) | static bool is_raw_object(impl* i) noexcept {
      method is_raw_object (line 94) | bool is_raw_object() const noexcept {
      method impl (line 104) | impl* from_raw_object(void* object) noexcept {

FILE: include/seastar/core/disk_params.hh
  type seastar (line 30) | namespace seastar {
    type smp_options (line 32) | struct smp_options
    type internal (line 34) | namespace internal {
      type disk_params (line 36) | struct disk_params {
      class disk_config_params (line 50) | class disk_config_params {
        method disk_config_params (line 60) | explicit disk_config_params(unsigned max_queues) noexcept
        method per_io_group (line 64) | uint64_t per_io_group(uint64_t qty, unsigned nr_groups) const noex...
        method num_io_groups (line 68) | unsigned num_io_groups() const noexcept { return _num_io_groups; }
        method latency_goal (line 70) | std::chrono::duration<double> latency_goal() const {
        method stall_threshold (line 74) | std::chrono::milliseconds stall_threshold() const {
        method latency_goal_opt (line 78) | double latency_goal_opt(const reactor_options& opts) const {
        type io_queue::config (line 86) | struct io_queue::config
        type io_queue::config (line 87) | struct io_queue::config
        method queue_ids (line 89) | auto queue_ids() {

FILE: include/seastar/core/distributed.hh
  type seastar (line 26) | namespace seastar {

FILE: include/seastar/core/do_with.hh
  type seastar (line 29) | namespace seastar {
    type internal (line 34) | namespace internal {
      class do_with_state (line 37) | class do_with_state final : public continuation_base_from_future<Fut...
        method do_with_state (line 42) | explicit do_with_state(T&&... args) : _held(std::forward<T>(args)....
        method run_and_dispose (line 43) | virtual void run_and_dispose() noexcept override {
        method task (line 47) | task* waiting_task() noexcept override {
        method HeldState (line 50) | HeldState& data() {
        method Future (line 53) | Future get_future() {
      function cherry_pick_tuple (line 63) | inline
      type subtuple (line 70) | struct subtuple
      function do_with_impl (line 78) | inline
    type internal (line 61) | namespace internal {
      class do_with_state (line 37) | class do_with_state final : public continuation_base_from_future<Fut...
        method do_with_state (line 42) | explicit do_with_state(T&&... args) : _held(std::forward<T>(args)....
        method run_and_dispose (line 43) | virtual void run_and_dispose() noexcept override {
        method task (line 47) | task* waiting_task() noexcept override {
        method HeldState (line 50) | HeldState& data() {
        method Future (line 53) | Future get_future() {
      function cherry_pick_tuple (line 63) | inline
      type subtuple (line 70) | struct subtuple
      function do_with_impl (line 78) | inline
    function do_with (line 129) | inline
    function with_lock (line 144) | inline
  type subtuple<Tuple, std::index_sequence<Idx...>> (line 73) | struct subtuple<Tuple, std::index_sequence<Idx...>> {

FILE: include/seastar/core/dpdk_rte.hh
  type seastar (line 40) | namespace seastar {
    type dpdk (line 42) | namespace dpdk {
      class eal (line 45) | class eal {

FILE: include/seastar/core/enum.hh
  type seastar (line 34) | namespace seastar {
    class enum_hash (line 38) | class enum_hash {

FILE: include/seastar/core/exception_hacks.hh
  type seastar (line 24) | namespace seastar {

FILE: include/seastar/core/execution_stage.hh
  type seastar (line 38) | namespace seastar {
    type internal (line 73) | namespace internal {
      type reference_wrapper_for_es (line 83) | struct reference_wrapper_for_es : reference_wrapper<T> {
        method reference_wrapper_for_es (line 84) | reference_wrapper_for_es(reference_wrapper <T> rw) noexcept
      type wrap_for_es (line 89) | struct wrap_for_es {
      type wrap_for_es<T&> (line 94) | struct wrap_for_es<T&> {
      type wrap_for_es<T&&> (line 99) | struct wrap_for_es<T&&> {
      function unwrap_for_es (line 104) | decltype(auto) unwrap_for_es(T&& object) {
      function unwrap_for_es (line 109) | std::reference_wrapper<T> unwrap_for_es(reference_wrapper_for_es<T> ...
      class execution_stage_manager (line 187) | class execution_stage_manager {
        method execution_stage_manager (line 191) | execution_stage_manager() = default;
        method execution_stage_manager (line 192) | execution_stage_manager(const execution_stage_manager&) = delete;
        method execution_stage_manager (line 193) | execution_stage_manager(execution_stage_manager&&) = delete;
      class concrete_execution_stage_base (line 208) | class concrete_execution_stage_base : public execution_stage {
        type work_item (line 220) | struct work_item {
          method work_item (line 224) | work_item(typename internal::wrap_for_es<Args>::type... args) : ...
          method work_item (line 226) | work_item(work_item&& other) = delete;
          method work_item (line 227) | work_item(const work_item&) = delete;
          method work_item (line 228) | work_item(work_item&) = delete;
        method unwrap (line 234) | auto unwrap(input_type&& in) {
        method do_flush (line 240) | virtual void do_flush() noexcept override {
        method concrete_execution_stage_base (line 257) | explicit concrete_execution_stage_base(const sstring& name, schedu...
        method concrete_execution_stage_base (line 263) | explicit concrete_execution_stage_base(const sstring& name, noncop...
        method return_type (line 288) | return_type operator()(typename internal::wrap_for_es<Args>::type....
      type concrete_execution_stage_helper (line 442) | struct concrete_execution_stage_helper
    class execution_stage (line 117) | class execution_stage {
      type stats (line 119) | struct stats {
      method execution_stage (line 138) | execution_stage(const execution_stage&) = delete;
      method sstring (line 149) | const sstring& name() const noexcept { return _name; }
      method stats (line 152) | const stats& get_stats() const noexcept { return _stats; }
      method poll (line 166) | bool poll() const noexcept {
      method scheduling_group (line 171) | scheduling_group get_scheduling_group() const noexcept { return _sg; }
      method update_name_and_metric_group (line 174) | void update_name_and_metric_group() {
    type internal (line 185) | namespace internal {
      type reference_wrapper_for_es (line 83) | struct reference_wrapper_for_es : reference_wrapper<T> {
        method reference_wrapper_for_es (line 84) | reference_wrapper_for_es(reference_wrapper <T> rw) noexcept
      type wrap_for_es (line 89) | struct wrap_for_es {
      type wrap_for_es<T&> (line 94) | struct wrap_for_es<T&> {
      type wrap_for_es<T&&> (line 99) | struct wrap_for_es<T&&> {
      function unwrap_for_es (line 104) | decltype(auto) unwrap_for_es(T&& object) {
      function unwrap_for_es (line 109) | std::reference_wrapper<T> unwrap_for_es(reference_wrapper_for_es<T> ...
      class execution_stage_manager (line 187) | class execution_stage_manager {
        method execution_stage_manager (line 191) | execution_stage_manager() = default;
        method execution_stage_manager (line 192) | execution_stage_manager(const execution_stage_manager&) = delete;
        method execution_stage_manager (line 193) | execution_stage_manager(execution_stage_manager&&) = delete;
      class concrete_execution_stage_base (line 208) | class concrete_execution_stage_base : public execution_stage {
        type work_item (line 220) | struct work_item {
          method work_item (line 224) | work_item(typename internal::wrap_for_es<Args>::type... args) : ...
          method work_item (line 226) | work_item(work_item&& other) = delete;
          method work_item (line 227) | work_item(const work_item&) = delete;
          method work_item (line 228) | work_item(work_item&) = delete;
        method unwrap (line 234) | auto unwrap(input_type&& in) {
        method do_flush (line 240) | virtual void do_flush() noexcept override {
        method concrete_execution_stage_base (line 257) | explicit concrete_execution_stage_base(const sstring& name, schedu...
        method concrete_execution_stage_base (line 263) | explicit concrete_execution_stage_base(const sstring& name, noncop...
        method return_type (line 288) | return_type operator()(typename internal::wrap_for_es<Args>::type....
      type concrete_execution_stage_helper (line 442) | struct concrete_execution_stage_helper
    class concrete_execution_stage (line 314) | class concrete_execution_stage final : public internal::concrete_execu...
    class inheriting_execution_stage (line 319) | class inheriting_execution_stage {
      type per_scheduling_group_stats (line 321) | struct per_scheduling_group_stats {
    class inheriting_concrete_execution_stage (line 338) | class inheriting_concrete_execution_stage final : public inheriting_ex...
      class per_group_stage_type (line 342) | class per_group_stage_type final : public internal::concrete_executi...
        method sstring (line 343) | static sstring format_name(const sstring& name, scheduling_group s...
        method per_group_stage_type (line 348) | per_group_stage_type(const sstring& base_name, scheduling_group sg...
        method per_group_stage_type (line 353) | per_group_stage_type(const sstring& name, noncopyable_function<Ret...
        method update_name (line 357) | void update_name() override {
      method per_group_stage_type (line 369) | per_group_stage_type make_stage_for_group(scheduling_group sg) {
        method sstring (line 343) | static sstring format_name(const sstring& name, scheduling_group s...
        method per_group_stage_type (line 348) | per_group_stage_type(const sstring& base_name, scheduling_group sg...
        method per_group_stage_type (line 353) | per_group_stage_type(const sstring& name, noncopyable_function<Ret...
        method update_name (line 357) | void update_name() override {
      method inheriting_concrete_execution_stage (line 384) | inheriting_concrete_execution_stage(const sstring& name, noncopyable...
      method return_type (line 408) | return_type operator()(typename internal::wrap_for_es<Args>::type......
      method get_stats (line 425) | inheriting_execution_stage::stats get_stats() const noexcept {
    type internal (line 439) | namespace internal {
      type reference_wrapper_for_es (line 83) | struct reference_wrapper_for_es : reference_wrapper<T> {
        method reference_wrapper_for_es (line 84) | reference_wrapper_for_es(reference_wrapper <T> rw) noexcept
      type wrap_for_es (line 89) | struct wrap_for_es {
      type wrap_for_es<T&> (line 94) | struct wrap_for_es<T&> {
      type wrap_for_es<T&&> (line 99) | struct wrap_for_es<T&&> {
      function unwrap_for_es (line 104) | decltype(auto) unwrap_for_es(T&& object) {
      function unwrap_for_es (line 109) | std::reference_wrapper<T> unwrap_for_es(reference_wrapper_for_es<T> ...
      class execution_stage_manager (line 187) | class execution_stage_manager {
        method execution_stage_manager (line 191) | execution_stage_manager() = default;
        method execution_stage_manager (line 192) | execution_stage_manager(const execution_stage_manager&) = delete;
        method execution_stage_manager (line 193) | execution_stage_manager(execution_stage_manager&&) = delete;
      class concrete_execution_stage_base (line 208) | class concrete_execution_stage_base : public execution_stage {
        type work_item (line 220) | struct work_item {
          method work_item (line 224) | work_item(typename internal::wrap_for_es<Args>::type... args) : ...
          method work_item (line 226) | work_item(work_item&& other) = delete;
          method work_item (line 227) | work_item(const work_item&) = delete;
          method work_item (line 228) | work_item(work_item&) = delete;
        method unwrap (line 234) | auto unwrap(input_type&& in) {
        method do_flush (line 240) | virtual void do_flush() noexcept override {
        method concrete_execution_stage_base (line 257) | explicit concrete_execution_stage_base(const sstring& name, schedu...
        method concrete_execution_stage_base (line 263) | explicit concrete_execution_stage_base(const sstring& name, noncop...
        method return_type (line 288) | return_type operator()(typename internal::wrap_for_es<Args>::type....
      type concrete_execution_stage_helper (line 442) | struct concrete_execution_stage_helper
    function make_execution_stage (line 484) | auto make_execution_stage(const sstring& name, scheduling_group sg, Fu...
    function make_execution_stage (line 523) | auto make_execution_stage(const sstring& name, Function&& fn) {
    function make_execution_stage (line 551) | concrete_execution_stage<Ret, Object*, Args...>
    function make_execution_stage (line 557) | concrete_execution_stage<Ret, const Object*, Args...>
    function make_execution_stage (line 563) | concrete_execution_stage<Ret, Object*, Args...>
    function make_execution_stage (line 569) | concrete_execution_stage<Ret, const Object*, Args...>
  type concrete_execution_stage_helper<Ret, std::tuple<Args...>> (line 445) | struct concrete_execution_stage_helper<Ret, std::tuple<Args...>> {

FILE: include/seastar/core/expiring_fifo.hh
  type seastar (line 33) | namespace seastar {
    type dummy_expiry (line 36) | struct dummy_expiry {
    type promise_expiry (line 41) | struct promise_expiry {
    class expiring_fifo (line 56) | class expiring_fifo {
      type entry (line 61) | struct entry {
        method entry (line 64) | entry(T&& payload_) : payload(std::move(payload_)) {}
        method entry (line 65) | entry(const T& payload_) : payload(payload_) {}
        method entry (line 66) | entry(T payload_, expiring_fifo& ef, time_point timeout)
        method entry (line 77) | entry(entry&& x) = delete;
        method entry (line 78) | entry(const entry& x) = delete;
      method drop_expired_front (line 93) | void drop_expired_front() noexcept {
      method expiring_fifo (line 102) | expiring_fifo() noexcept = default;
      method expiring_fifo (line 103) | expiring_fifo(OnExpiry on_expiry) noexcept(std::is_nothrow_move_cons...
      method expiring_fifo (line 105) | expiring_fifo(expiring_fifo&& o) noexcept
      method expiring_fifo (line 111) | expiring_fifo& operator=(expiring_fifo&& o) noexcept {
      method empty (line 124) | bool empty() const noexcept {
      method T (line 135) | T& front() noexcept {
      method T (line 144) | const T& front() const noexcept {
      method size (line 154) | size_t size() const noexcept {
      method reserve (line 162) | void reserve(size_t size) {
      method push_back (line 168) | void push_back(const T& payload) {
      method push_back (line 179) | void push_back(T&& payload) {
      method push_back (line 191) | void push_back(T&& payload, time_point timeout) {
      method pop_front (line 206) | void pop_front() noexcept {

FILE: include/seastar/core/fair_queue.hh
  type seastar (line 40) | namespace seastar {
    type testing (line 42) | namespace testing {
      class fair_queue_test (line 43) | class fair_queue_test
    class fair_queue_ticket (line 53) | class fair_queue_ticket {
      method fair_queue_ticket (line 62) | fair_queue_ticket() noexcept {}
    class fair_queue_entry (line 109) | class fair_queue_entry {
      method fair_queue_entry (line 122) | explicit fair_queue_entry(capacity_t c) noexcept
      method capacity_t (line 129) | capacity_t capacity() const noexcept { return _capacity; }
    class fair_queue (line 151) | class fair_queue {
      type config (line 157) | struct config {
      class priority_class_group_data (line 167) | class priority_class_group_data
        method priority_class_group_data (line 224) | priority_class_group_data(uint32_t shares, priority_class_group_da...
        method priority_class_group_data (line 231) | priority_class_group_data(const priority_class_group_data&) = delete;
        method priority_class_group_data (line 232) | priority_class_group_data(priority_class_group_data&&) = delete;
        method reserve (line 237) | void reserve() {
      class priority_entry (line 169) | class priority_entry {
        method priority_entry (line 182) | priority_entry(uint32_t shares, priority_class_group_data* p) noex...
        method update_shares (line 191) | void update_shares(uint32_t shares) noexcept {
      type class_compare (line 198) | struct class_compare {
      class priority_queue (line 202) | class priority_queue : public std::priority_queue<priority_entry_ptr...
        method reserve (line 205) | void reserve(size_t len) {
        method assert_enough_capacity (line 209) | void assert_enough_capacity() const noexcept {
      class priority_class_group_data (line 214) | class priority_class_group_data final : public priority_entry {
        method priority_class_group_data (line 224) | priority_class_group_data(uint32_t shares, priority_class_group_da...
        method priority_class_group_data (line 231) | priority_class_group_data(const priority_class_group_data&) = delete;
        method priority_class_group_data (line 232) | priority_class_group_data(priority_class_group_data&&) = delete;
        method reserve (line 237) | void reserve() {
      class priority_class_data (line 244) | class priority_class_data
      method fair_queue (line 265) | fair_queue(fair_queue&&) = delete;
      method sstring (line 268) | sstring label() const noexcept { return _config.label; }
      method fair_queue_ticket (line 286) | [[deprecated("Ticket resources are not accounted for any longer")]]
      method fair_queue_ticket (line 290) | [[deprecated("Ticket resources are not accounted for any longer")]]
      method capacity_t (line 312) | capacity_t queued_capacity() const noexcept { return _queued_capacit...
  type fmt::formatter<seastar::fair_queue_ticket> (line 322) | struct fmt::formatter<seastar::fair_queue_ticket> : fmt::ostream_formatt...

FILE: include/seastar/core/file-types.hh
  type seastar (line 28) | namespace seastar {
    type open_flags (line 37) | enum class open_flags {
    function open_flags (line 47) | inline constexpr open_flags operator|(open_flags a, open_flags b) {
    function open_flags (line 55) | inline constexpr open_flags operator&(open_flags a, open_flags b) {
    type directory_entry_type (line 72) | enum class directory_entry_type {
    type internal::linux_abi (line 83) | namespace internal::linux_abi {
      type linux_dirent64 (line 91) | struct linux_dirent64 {
    type fs_type (line 102) | enum class fs_type {
    type access_flags (line 114) | enum class access_flags {
    function access_flags (line 124) | inline constexpr access_flags operator|(access_flags a, access_flags b) {
    function access_flags (line 128) | inline constexpr access_flags operator&(access_flags a, access_flags b) {
    type file_permissions (line 133) | enum class file_permissions {
    function file_permissions (line 155) | inline constexpr file_permissions operator|(file_permissions a, file_p...
    function file_permissions (line 159) | inline constexpr file_permissions operator&(file_permissions a, file_p...

FILE: include/seastar/core/file.hh
  type seastar (line 49) | namespace seastar {
    type directory_entry (line 56) | struct directory_entry {
    type group_details (line 64) | struct group_details {
    type stat_data (line 72) | struct stat_data {
    type file_open_options (line 95) | struct file_open_options {
    class file (line 111) | class file
      method file (line 195) | file() noexcept : _file_impl(nullptr) {}
      method file (line 197) | file(shared_ptr<file_impl> impl) noexcept
      method file (line 213) | file(const file& x) = default;
      method file (line 215) | file(file&& x) noexcept : _file_impl(std::move(x._file_impl)) {}
      method file (line 220) | file& operator=(const file& x) noexcept = default;
      method file (line 222) | file& operator=(file&& x) noexcept = default;
      method disk_read_dma_alignment (line 233) | uint64_t disk_read_dma_alignment() const noexcept {
      method disk_write_dma_alignment (line 238) | uint64_t disk_write_dma_alignment() const noexcept {
      method disk_overwrite_dma_alignment (line 248) | uint64_t disk_overwrite_dma_alignment() const noexcept {
      method memory_dma_alignment (line 253) | uint64_t memory_dma_alignment() const noexcept {
      method disk_read_max_length (line 261) | size_t disk_read_max_length() const noexcept {
      method disk_write_max_length (line 269) | size_t disk_write_max_length() const noexcept {
      method dma_read (line 288) | future<size_t>
      method dma_read (line 309) | future<temporary_buffer<CharType>> dma_read(uint64_t pos, size_t len...
      class eof_error (line 317) | class eof_error : public std::exception {}
      method dma_read_exactly (line 332) | future<temporary_buffer<CharType>>
      method dma_read (line 351) | future<size_t> dma_read(uint64_t pos, std::vector<iovec> iov, io_int...
      method dma_write (line 366) | future<size_t> dma_write(uint64_t pos, const CharType* buffer, size_...
      method dma_write (line 382) | future<size_t> dma_write(uint64_t pos, std::vector<iovec> iov, io_in...
      type stat (line 393) | struct stat
      type stat (line 399) | struct stat
      method dma_read_bulk (line 544) | future<temporary_buffer<CharType>>
    class file_impl (line 112) | class file_impl
      type stat (line 153) | struct stat
      type stat (line 154) | struct stat
    class io_intent (line 113) | class io_intent
    class file_handle (line 114) | class file_handle
      method file_handle (line 647) | explicit file_handle(std::unique_ptr<file_handle_impl> impl) : _impl...
    class file_data_sink_impl (line 115) | class file_data_sink_impl
    class file_data_source_impl (line 116) | class file_data_source_impl
    class file_handle_impl (line 126) | class file_handle_impl {
    class file_impl (line 133) | class file_impl {
      type stat (line 153) | struct stat
      type stat (line 154) | struct stat
    type stat (line 169) | struct stat
    class file (line 182) | class file {
      method file (line 195) | file() noexcept : _file_impl(nullptr) {}
      method file (line 197) | file(shared_ptr<file_impl> impl) noexcept
      method file (line 213) | file(const file& x) = default;
      method file (line 215) | file(file&& x) noexcept : _file_impl(std::move(x._file_impl)) {}
      method file (line 220) | file& operator=(const file& x) noexcept = default;
      method file (line 222) | file& operator=(file&& x) noexcept = default;
      method disk_read_dma_alignment (line 233) | uint64_t disk_read_dma_alignment() const noexcept {
      method disk_write_dma_alignment (line 238) | uint64_t disk_write_dma_alignment() const noexcept {
      method disk_overwrite_dma_alignment (line 248) | uint64_t disk_overwrite_dma_alignment() const noexcept {
      method memory_dma_alignment (line 253) | uint64_t memory_dma_alignment() const noexcept {
      method disk_read_max_length (line 261) | size_t disk_read_max_length() const noexcept {
      method disk_write_max_length (line 269) | size_t disk_write_max_length() const noexcept {
      method dma_read (line 288) | future<size_t>
      method dma_read (line 309) | future<temporary_buffer<CharType>> dma_read(uint64_t pos, size_t len...
      class eof_error (line 317) | class eof_error : public std::exception {}
      method dma_read_exactly (line 332) | future<temporary_buffer<CharType>>
      method dma_read (line 351) | future<size_t> dma_read(uint64_t pos, std::vector<iovec> iov, io_int...
      method dma_write (line 366) | future<size_t> dma_write(uint64_t pos, const CharType* buffer, size_...
      method dma_write (line 382) | future<size_t> dma_write(uint64_t pos, std::vector<iovec> iov, io_in...
      type stat (line 393) | struct stat
      type stat (line 399) | struct stat
      method dma_read_bulk (line 544) | future<temporary_buffer<CharType>>
    function with_file (line 598) | futurize_t<std::invoke_result_t<Func, file&>> with_file(future<file> f...
    function with_file_close_on_failure (line 621) | futurize_t<std::invoke_result_t<Func, file&>> with_file_close_on_failu...
    class file_handle (line 644) | class file_handle {
      method file_handle (line 647) | explicit file_handle(std::unique_ptr<file_handle_impl> impl) : _impl...
    class cancelled_error (line 668) | class cancelled_error : public std::exception {

FILE: include/seastar/core/format.hh
  type seastar (line 27) | namespace seastar {
    function sstring (line 39) | sstring

FILE: include/seastar/core/fsnotify.hh
  type seastar::experimental (line 30) | namespace seastar::experimental {
    class fsnotifier (line 53) | class fsnotifier {
      class impl (line 54) | class impl
      class watch (line 57) | class watch
        method watch_token (line 124) | watch_token token() const {
      type flags (line 66) | enum class flags : uint32_t {
      class watch (line 106) | class watch {
        method watch_token (line 124) | watch_token token() const {
      type event (line 150) | struct event {

FILE: include/seastar/core/fsqual.hh
  type seastar (line 26) | namespace seastar {

FILE: include/seastar/core/fstream.hh
  type seastar (line 39) | namespace seastar {
    class file_input_stream_history (line 42) | class file_input_stream_history {
      type window (line 44) | struct window {
    type file_input_stream_options (line 56) | struct file_input_stream_options {
    type file_output_stream_options (line 98) | struct file_output_stream_options {

FILE: include/seastar/core/function_traits.hh
  type seastar (line 27) | namespace seastar {
    type function_traits (line 30) | struct function_traits
    type function_traits (line 74) | struct function_traits : public function_traits<decltype(&T::operator())>
    type function_traits<T&> (line 78) | struct function_traits<T&> : public function_traits<std::remove_refere...
    type function_traits<std::reference_wrapper<T>> (line 82) | struct function_traits<std::reference_wrapper<T>> : public function_tr...
  type function_traits<Ret(Args...)> (line 33) | struct function_traits<Ret(Args...)>
    type arg (line 42) | struct arg
  type function_traits<Ret(*)(Args...)> (line 50) | struct function_traits<Ret(*)(Args...)> : public function_traits<Ret(Arg...
  type function_traits<Ret(T::*)(Args...)> (line 54) | struct function_traits<Ret(T::*)(Args...)> : public function_traits<Ret(...
  type function_traits<Ret(T::*)(Args...) const> (line 58) | struct function_traits<Ret(T::*)(Args...) const> : public function_trait...
  type function_traits<Ret(*)(Args...) noexcept> (line 62) | struct function_traits<Ret(*)(Args...) noexcept> : public function_trait...
  type function_traits<Ret(T::*)(Args...) noexcept> (line 66) | struct function_traits<Ret(T::*)(Args...) noexcept> : public function_tr...
  type function_traits<Ret(T::*)(Args...) const noexcept> (line 70) | struct function_traits<Ret(T::*)(Args...) const noexcept> : public funct...

FILE: include/seastar/core/future.hh
  type seastar (line 46) | namespace seastar {
    type nested_exception (line 48) | struct nested_exception : public std::exception {
    class promise (line 149) | class promise
      method promise (line 931) | promise() noexcept : internal::promise_base_with_type<T>(&_local_sta...
      method promise (line 935) | promise(promise&& x) noexcept : internal::promise_base_with_type<T>(...
      method promise (line 938) | promise(const promise&) = delete;
      method promise (line 939) | promise& operator=(promise&& x) noexcept {
      method set_to_current_exception (line 952) | void set_to_current_exception() noexcept {
      method set_value (line 981) | void set_value(A&&... a) noexcept {
      method set_exception (line 991) | void set_exception(std::exception_ptr&& ex) noexcept {
      method set_exception (line 995) | void set_exception(const std::exception_ptr& ex) noexcept {
      method set_exception (line 1005) | void set_exception(Exception&& e) noexcept {
    class future (line 152) | class future
      method future (line 1232) | future(future_for_get_promise_marker) noexcept { }
      method future (line 1234) | future(promise<T>* pr) noexcept : future_base(pr, &_state), _state(s...
      method future (line 1236) | future(ready_future_marker m, A&&... a) noexcept : _state(m, std::fo...
      method future (line 1237) | future(future_state_base::current_exception_future_marker m) noexcep...
      method future (line 1238) | future(future_state_base::nested_exception_marker m, future_state_ba...
      method future (line 1239) | future(future_state_base::nested_exception_marker m, future_state_ba...
      method future (line 1240) | future(exception_future_marker m, std::exception_ptr&& ex) noexcept ...
      method future (line 1241) | future(exception_future_marker m, future_state_base&& state) noexcep...
      method future (line 1242) | [[gnu::always_inline]]
      method get_promise (line 1246) | internal::promise_base_with_type<T> get_promise() noexcept {
      method schedule (line 1253) | void schedule(continuation_base<T>* tws) noexcept {
      method schedule (line 1257) | void schedule(Pr&& pr, Func&& func, Wrapper&& wrapper, std::source_l...
      method future_state (line 1279) | [[gnu::always_inline]]
      method rethrow_with_nested (line 1287) | future<T> rethrow_with_nested(future_state_base&& n) noexcept {
      method rethrow_with_nested (line 1291) | future<T> rethrow_with_nested() noexcept {
      method future (line 1304) | [[gnu::always_inline]]
      method future (line 1306) | future(const future&) = delete;
      method future (line 1307) | future& operator=(future&& x) noexcept {
      method value_type (line 1323) | [[gnu::always_inline]]
      method get_exception (line 1329) | [[gnu::always_inline]]
      method wait (line 1341) | void wait() noexcept {
      method available (line 1351) | [[gnu::always_inline]]
      method failed (line 1359) | [[gnu::always_inline]]
      method Result (line 1387) | Result
      method Result (line 1431) | Result
      method Result (line 1447) | Result then_impl_nrvo(Func&& func, std::source_location sl) noexcept {
      method Result (line 1467) | Result
      method then_wrapped (line 1498) | futurize_t<FuncResult>
      method then_wrapped (line 1510) | futurize_t<FuncResult>
      method then_wrapped_maybe_erase (line 1524) | futurize_t<FuncResult>
      method then_wrapped_nrvo (line 1545) | futurize_t<FuncResult>
      method then_wrapped_common (line 1560) | futurize_t<FuncResult>
      method forward_to (line 1578) | void forward_to(internal::promise_base_with_type<T>&& pr) noexcept {
      method forward_to (line 1597) | void forward_to(promise<T>&& pr) noexcept {
      method finally (line 1629) | future<T> finally(Func&& func, std::source_location sl = std::source...
      type finally_body (line 1641) | struct finally_body
      type finally_body<Func, true> (line 1644) | struct finally_body<Func, true> {
        method finally_body (line 1647) | finally_body(Func&& func) noexcept : _func(std::forward<Func>(func))
      type finally_body<Func, false> (line 1664) | struct finally_body<Func, false> {
        method finally_body (line 1667) | finally_body(Func&& func) noexcept : _func(std::forward<Func>(func))
      method or_terminate (line 1684) | future<> or_terminate(std::source_location sl = std::source_location...
      method discard_result (line 1698) | future<> discard_result(std::source_location sl = std::source_locati...
      method handle_exception (line 1722) | future<T> handle_exception(Func&& func, std::source_location sl = st...
      method handle_exception_type (line 1750) | future<T> handle_exception_type(Func&& func, std::source_location sl...
      method ignore_ready_future (line 1775) | void ignore_ready_future() noexcept {
      method set_task (line 1782) | void set_task(task& t) noexcept {
      method set_callback (line 1787) | void set_callback(continuation_base<T>* callback) noexcept {
    class shared_future (line 155) | class shared_future
    type future_state_base (line 157) | struct future_state_base
      type state (line 410) | enum class state : uintptr_t {
      method any (line 425) | any() noexcept { st = state::future; }
      method any (line 426) | any(state s) noexcept { st = s; }
      method set_exception (line 427) | void set_exception(std::exception_ptr&& e) noexcept {
      method any (line 431) | any(std::exception_ptr&& e) noexcept {
      method valid (line 435) | bool valid() const noexcept { return st != state::invalid && st != s...
      method available (line 436) | bool available() const noexcept { return st == state::result || st >...
      method failed (line 437) | bool failed() const noexcept { return __builtin_expect(st >= state::...
      method take_exception (line 440) | std::exception_ptr take_exception() noexcept {
      method move_it (line 454) | void move_it(any&& x) noexcept {
      method any (line 474) | any(any&& x) noexcept {
      method any (line 477) | any& operator=(any&& x) noexcept {
      method has_result (line 485) | bool has_result() const noexcept {
      method future_state_base (line 492) | future_state_base() noexcept = default;
      method future_state_base (line 493) | future_state_base(state st) noexcept : _u(st) { }
      method future_state_base (line 494) | future_state_base(std::exception_ptr&& ex) noexcept : _u(std::move(e...
      method future_state_base (line 495) | future_state_base(future_state_base&& x) noexcept : _u(std::move(x._...
      type current_exception_future_marker (line 500) | struct current_exception_future_marker {}
      type nested_exception_marker (line 502) | struct nested_exception_marker {}
      method valid (line 512) | bool valid() const noexcept { return _u.valid(); }
      method available (line 513) | bool available() const noexcept { return _u.available(); }
      method failed (line 514) | bool failed() const noexcept { return _u.failed(); }
      method set_exception (line 518) | void set_exception(std::exception_ptr&& ex) noexcept {
      method future_state_base (line 522) | future_state_base& operator=(future_state_base&& x) noexcept = default;
      method set_exception (line 523) | void set_exception(future_state_base&& state) noexcept {
      method get_exception (line 527) | std::exception_ptr get_exception() && noexcept {
    function as_ready_future (line 171) | inline
    function make_exception_future (line 190) | future<T> make_exception_future(const std::exception_ptr& ex) noexcept {
    function make_exception_future (line 195) | future<T> make_exception_future(std::exception_ptr& ex) noexcept {
    function make_exception_future (line 200) | future<T> make_exception_future(const std::exception_ptr&& ex) noexcept {
    type broken_promise (line 215) | struct broken_promise : std::logic_error {
    type internal (line 230) | namespace internal {
      class promise_base_with_type (line 232) | class promise_base_with_type
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class promise_base (line 233) | class promise_base
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      type monostate (line 235) | struct monostate {}
      type future_stored_type (line 238) | struct future_stored_type
      type future_stored_type<> (line 241) | struct future_stored_type<> {
      type future_stored_type<T> (line 246) | struct future_stored_type<T> {
      type get0_return_type (line 259) | struct get0_return_type
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type get0_return_type<internal::monostate> (line 262) | struct get0_return_type<internal::monostate> {
        method type (line 264) | static type get0(internal::monostate) { }
      type get0_return_type (line 268) | struct get0_return_type {
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type uninitialized_wrapper (line 282) | struct uninitialized_wrapper {
        method any (line 285) | any() noexcept {}
        method uninitialized_wrapper (line 292) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 295) | void
        method uninitialized_set (line 299) | void uninitialized_set(tuple_type&& v) {
        method uninitialized_set (line 302) | void uninitialized_set(const tuple_type& v) {
      type uninitialized_wrapper<internal::monostate> (line 314) | struct uninitialized_wrapper<internal::monostate> {
        method uninitialized_wrapper (line 317) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 318) | void uninitialized_set() {
        method uninitialized_set (line 320) | void uninitialized_set(internal::monostate) {
        method uninitialized_set (line 322) | void uninitialized_set(std::tuple<>&& v) {
        method uninitialized_set (line 324) | void uninitialized_set(const std::tuple<>& v) {
      type is_trivially_move_constructible_and_destructible (line 335) | struct is_trivially_move_constructible_and_destructible {
      type all_true (line 340) | struct all_true : std::false_type {}
      type all_true<> (line 343) | struct all_true<> : std::true_type {}
      type is_tuple_effectively_trivially_move_constructible_and_destructible_helper (line 349) | struct is_tuple_effectively_trivially_move_constructible_and_destruc...
      class future_base (line 760) | class future_base
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      class promise_base (line 762) | class promise_base {
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      class promise_base_with_type (line 864) | class promise_base_with_type : protected internal::promise_base {
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class future_base (line 1074) | class future_base {
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      type future_result (line 1126) | struct future_result  {
      type future_result<Func, void> (line 1133) | struct future_result<Func, void> {
      function future_invoke (line 1143) | auto future_invoke(Func&& func, T&& v) {
      type result_of_apply (line 1152) | struct result_of_apply {
      type futurize_base (line 1825) | struct futurize_base {
        method type (line 1833) | static inline type convert(T&& value) { return make_ready_future<T...
        method type (line 1834) | static inline type convert(type&& value) { return std::move(value); }
      type futurize_base<void> (line 1842) | struct futurize_base<void> {
        method type (line 1847) | static inline type convert(type&& value) {
      type futurize_base<future<T>> (line 1855) | struct futurize_base<future<T>> : public futurize_base<T> {}
      type futurize_base<future<>> (line 1858) | struct futurize_base<future<>> : public futurize_base<void> {}
      function set_callback (line 2073) | inline
    function func_to_rvalue (line 369) | static constexpr auto func_to_rvalue(Func&& func) {
    type future_state_base (line 408) | struct future_state_base {
      type state (line 410) | enum class state : uintptr_t {
      method any (line 425) | any() noexcept { st = state::future; }
      method any (line 426) | any(state s) noexcept { st = s; }
      method set_exception (line 427) | void set_exception(std::exception_ptr&& e) noexcept {
      method any (line 431) | any(std::exception_ptr&& e) noexcept {
      method valid (line 435) | bool valid() const noexcept { return st != state::invalid && st != s...
      method available (line 436) | bool available() const noexcept { return st == state::result || st >...
      method failed (line 437) | bool failed() const noexcept { return __builtin_expect(st >= state::...
      method take_exception (line 440) | std::exception_ptr take_exception() noexcept {
      method move_it (line 454) | void move_it(any&& x) noexcept {
      method any (line 474) | any(any&& x) noexcept {
      method any (line 477) | any& operator=(any&& x) noexcept {
      method has_result (line 485) | bool has_result() const noexcept {
      method future_state_base (line 492) | future_state_base() noexcept = default;
      method future_state_base (line 493) | future_state_base(state st) noexcept : _u(st) { }
      method future_state_base (line 494) | future_state_base(std::exception_ptr&& ex) noexcept : _u(std::move(e...
      method future_state_base (line 495) | future_state_base(future_state_base&& x) noexcept : _u(std::move(x._...
      type current_exception_future_marker (line 500) | struct current_exception_future_marker {}
      type nested_exception_marker (line 502) | struct nested_exception_marker {}
      method valid (line 512) | bool valid() const noexcept { return _u.valid(); }
      method available (line 513) | bool available() const noexcept { return _u.available(); }
      method failed (line 514) | bool failed() const noexcept { return _u.failed(); }
      method set_exception (line 518) | void set_exception(std::exception_ptr&& ex) noexcept {
      method future_state_base (line 522) | future_state_base& operator=(future_state_base&& x) noexcept = default;
      method set_exception (line 523) | void set_exception(future_state_base&& state) noexcept {
      method get_exception (line 527) | std::exception_ptr get_exception() && noexcept {
    type internal (line 546) | namespace internal {
      class promise_base_with_type (line 232) | class promise_base_with_type
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class promise_base (line 233) | class promise_base
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      type monostate (line 235) | struct monostate {}
      type future_stored_type (line 238) | struct future_stored_type
      type future_stored_type<> (line 241) | struct future_stored_type<> {
      type future_stored_type<T> (line 246) | struct future_stored_type<T> {
      type get0_return_type (line 259) | struct get0_return_type
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type get0_return_type<internal::monostate> (line 262) | struct get0_return_type<internal::monostate> {
        method type (line 264) | static type get0(internal::monostate) { }
      type get0_return_type (line 268) | struct get0_return_type {
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type uninitialized_wrapper (line 282) | struct uninitialized_wrapper {
        method any (line 285) | any() noexcept {}
        method uninitialized_wrapper (line 292) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 295) | void
        method uninitialized_set (line 299) | void uninitialized_set(tuple_type&& v) {
        method uninitialized_set (line 302) | void uninitialized_set(const tuple_type& v) {
      type uninitialized_wrapper<internal::monostate> (line 314) | struct uninitialized_wrapper<internal::monostate> {
        method uninitialized_wrapper (line 317) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 318) | void uninitialized_set() {
        method uninitialized_set (line 320) | void uninitialized_set(internal::monostate) {
        method uninitialized_set (line 322) | void uninitialized_set(std::tuple<>&& v) {
        method uninitialized_set (line 324) | void uninitialized_set(const std::tuple<>& v) {
      type is_trivially_move_constructible_and_destructible (line 335) | struct is_trivially_move_constructible_and_destructible {
      type all_true (line 340) | struct all_true : std::false_type {}
      type all_true<> (line 343) | struct all_true<> : std::true_type {}
      type is_tuple_effectively_trivially_move_constructible_and_destructible_helper (line 349) | struct is_tuple_effectively_trivially_move_constructible_and_destruc...
      class future_base (line 760) | class future_base
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      class promise_base (line 762) | class promise_base {
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      class promise_base_with_type (line 864) | class promise_base_with_type : protected internal::promise_base {
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class future_base (line 1074) | class future_base {
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      type future_result (line 1126) | struct future_result  {
      type future_result<Func, void> (line 1133) | struct future_result<Func, void> {
      function future_invoke (line 1143) | auto future_invoke(Func&& func, T&& v) {
      type result_of_apply (line 1152) | struct result_of_apply {
      type futurize_base (line 1825) | struct futurize_base {
        method type (line 1833) | static inline type convert(T&& value) { return make_ready_future<T...
        method type (line 1834) | static inline type convert(type&& value) { return std::move(value); }
      type futurize_base<void> (line 1842) | struct futurize_base<void> {
        method type (line 1847) | static inline type convert(type&& value) {
      type futurize_base<future<T>> (line 1855) | struct futurize_base<future<T>> : public futurize_base<T> {}
      type futurize_base<future<>> (line 1858) | struct futurize_base<future<>> : public futurize_base<void> {}
      function set_callback (line 2073) | inline
    type ready_future_marker (line 559) | struct ready_future_marker {}
    type exception_future_marker (line 560) | struct exception_future_marker {}
    type future_for_get_promise_marker (line 561) | struct future_for_get_promise_marker {}
    type future_state (line 565) | struct future_state :  public future_state_base, private internal::uni...
      method future_state (line 572) | future_state() noexcept = default;
      method move_it (line 573) | void move_it(future_state&& x) noexcept {
      method future_state (line 591) | [[gnu::always_inline]]
      method clear (line 596) | void clear() noexcept {
      method future_state (line 607) | future_state& operator=(future_state&& x) noexcept {
      method future_state (line 616) | future_state(ready_future_marker, A&&... a) noexcept : future_state_...
      method set (line 624) | void set(A&&... a) noexcept {
      method future_state (line 628) | future_state(exception_future_marker, std::exception_ptr&& ex) noexc...
      method future_state (line 629) | future_state(exception_future_marker, future_state_base&& state) noe...
      method future_state (line 630) | future_state(current_exception_future_marker m) noexcept : future_st...
      method future_state (line 631) | future_state(nested_exception_marker m, future_state_base&& old) noe...
      method future_state (line 632) | future_state(nested_exception_marker m, future_state_base&& n, futur...
      method T (line 633) | T&& get_value() && noexcept {
      method T (line 637) | T&& take_value() && noexcept {
      method U (line 643) | const U& get_value() const& noexcept(copy_noexcept) {
      method T (line 647) | T&& take() && {
      method T (line 655) | T&& get() && {
      method T (line 662) | const T& get() const& {
      method get0_return_type (line 670) | static get0_return_type get0(T&& x) {
      method get0_return_type (line 674) | get0_return_type get0() {
    class continuation_base (line 680) | class continuation_base : public task {
      method continuation_base (line 687) | continuation_base() noexcept = default;
      method set_state (line 688) | void set_state(future_state&& state) noexcept {
      method task (line 695) | virtual task* waiting_task() noexcept override { return nullptr; }
    type continuation_base_from_future (line 703) | struct continuation_base_from_future
    class continuation_base_with_promise (line 714) | class continuation_base_with_promise : public continuation_base<T> {
      method continuation_base_with_promise (line 717) | continuation_base_with_promise(Promise&& pr) noexcept : _pr(std::mov...
    type continuation (line 725) | struct continuation final : continuation_base_with_promise<Promise, T> {
      method continuation (line 736) | continuation(Promise&& pr, Func&& func, Wrapper&& wrapper) noexcept
      method run_and_dispose (line 740) | virtual void run_and_dispose() noexcept override {
    type internal (line 752) | namespace internal {
      class promise_base_with_type (line 232) | class promise_base_with_type
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class promise_base (line 233) | class promise_base
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      type monostate (line 235) | struct monostate {}
      type future_stored_type (line 238) | struct future_stored_type
      type future_stored_type<> (line 241) | struct future_stored_type<> {
      type future_stored_type<T> (line 246) | struct future_stored_type<T> {
      type get0_return_type (line 259) | struct get0_return_type
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type get0_return_type<internal::monostate> (line 262) | struct get0_return_type<internal::monostate> {
        method type (line 264) | static type get0(internal::monostate) { }
      type get0_return_type (line 268) | struct get0_return_type {
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type uninitialized_wrapper (line 282) | struct uninitialized_wrapper {
        method any (line 285) | any() noexcept {}
        method uninitialized_wrapper (line 292) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 295) | void
        method uninitialized_set (line 299) | void uninitialized_set(tuple_type&& v) {
        method uninitialized_set (line 302) | void uninitialized_set(const tuple_type& v) {
      type uninitialized_wrapper<internal::monostate> (line 314) | struct uninitialized_wrapper<internal::monostate> {
        method uninitialized_wrapper (line 317) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 318) | void uninitialized_set() {
        method uninitialized_set (line 320) | void uninitialized_set(internal::monostate) {
        method uninitialized_set (line 322) | void uninitialized_set(std::tuple<>&& v) {
        method uninitialized_set (line 324) | void uninitialized_set(const std::tuple<>& v) {
      type is_trivially_move_constructible_and_destructible (line 335) | struct is_trivially_move_constructible_and_destructible {
      type all_true (line 340) | struct all_true : std::false_type {}
      type all_true<> (line 343) | struct all_true<> : std::true_type {}
      type is_tuple_effectively_trivially_move_constructible_and_destructible_helper (line 349) | struct is_tuple_effectively_trivially_move_constructible_and_destruc...
      class future_base (line 760) | class future_base
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      class promise_base (line 762) | class promise_base {
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      class promise_base_with_type (line 864) | class promise_base_with_type : protected internal::promise_base {
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class future_base (line 1074) | class future_base {
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      type future_result (line 1126) | struct future_result  {
      type future_result<Func, void> (line 1133) | struct future_result<Func, void> {
      function future_invoke (line 1143) | auto future_invoke(Func&& func, T&& v) {
      type result_of_apply (line 1152) | struct result_of_apply {
      type futurize_base (line 1825) | struct futurize_base {
        method type (line 1833) | static inline type convert(T&& value) { return make_ready_future<T...
        method type (line 1834) | static inline type convert(type&& value) { return std::move(value); }
      type futurize_base<void> (line 1842) | struct futurize_base<void> {
        method type (line 1847) | static inline type convert(type&& value) {
      type futurize_base<future<T>> (line 1855) | struct futurize_base<future<T>> : public futurize_base<T> {}
      type futurize_base<future<>> (line 1858) | struct futurize_base<future<>> : public futurize_base<void> {}
      function set_callback (line 2073) | inline
    class promise (line 923) | class promise : private internal::promise_base_with_type<T> {
      method promise (line 931) | promise() noexcept : internal::promise_base_with_type<T>(&_local_sta...
      method promise (line 935) | promise(promise&& x) noexcept : internal::promise_base_with_type<T>(...
      method promise (line 938) | promise(const promise&) = delete;
      method promise (line 939) | promise& operator=(promise&& x) noexcept {
      method set_to_current_exception (line 952) | void set_to_current_exception() noexcept {
      method set_value (line 981) | void set_value(A&&... a) noexcept {
      method set_exception (line 991) | void set_exception(std::exception_ptr&& ex) noexcept {
      method set_exception (line 995) | void set_exception(const std::exception_ptr& ex) noexcept {
      method set_exception (line 1005) | void set_exception(Exception&& e) noexcept {
    type is_future (line 1026) | struct is_future : std::false_type {}
    type futurize (line 1039) | struct futurize
      method type (line 1884) | static inline type invoke(Func&& func, internal::monostate) noexcept {
      method type (line 1888) | static type current_exception_as_future() noexcept {
      method type (line 1893) | static type from_tuple(tuple_type&& value) {
      method type (line 1897) | static type from_tuple(const tuple_type& value) {
      method type (line 1902) | static type from_tuple(value_type&& value) {
      method type (line 1906) | static type from_tuple(const value_type& value) {
    type internal (line 1073) | namespace internal {
      class promise_base_with_type (line 232) | class promise_base_with_type
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class promise_base (line 233) | class promise_base
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      type monostate (line 235) | struct monostate {}
      type future_stored_type (line 238) | struct future_stored_type
      type future_stored_type<> (line 241) | struct future_stored_type<> {
      type future_stored_type<T> (line 246) | struct future_stored_type<T> {
      type get0_return_type (line 259) | struct get0_return_type
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type get0_return_type<internal::monostate> (line 262) | struct get0_return_type<internal::monostate> {
        method type (line 264) | static type get0(internal::monostate) { }
      type get0_return_type (line 268) | struct get0_return_type {
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type uninitialized_wrapper (line 282) | struct uninitialized_wrapper {
        method any (line 285) | any() noexcept {}
        method uninitialized_wrapper (line 292) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 295) | void
        method uninitialized_set (line 299) | void uninitialized_set(tuple_type&& v) {
        method uninitialized_set (line 302) | void uninitialized_set(const tuple_type& v) {
      type uninitialized_wrapper<internal::monostate> (line 314) | struct uninitialized_wrapper<internal::monostate> {
        method uninitialized_wrapper (line 317) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 318) | void uninitialized_set() {
        method uninitialized_set (line 320) | void uninitialized_set(internal::monostate) {
        method uninitialized_set (line 322) | void uninitialized_set(std::tuple<>&& v) {
        method uninitialized_set (line 324) | void uninitialized_set(const std::tuple<>& v) {
      type is_trivially_move_constructible_and_destructible (line 335) | struct is_trivially_move_constructible_and_destructible {
      type all_true (line 340) | struct all_true : std::false_type {}
      type all_true<> (line 343) | struct all_true<> : std::true_type {}
      type is_tuple_effectively_trivially_move_constructible_and_destructible_helper (line 349) | struct is_tuple_effectively_trivially_move_constructible_and_destruc...
      class future_base (line 760) | class future_base
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      class promise_base (line 762) | class promise_base {
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      class promise_base_with_type (line 864) | class promise_base_with_type : protected internal::promise_base {
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class future_base (line 1074) | class future_base {
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      type future_result (line 1126) | struct future_result  {
      type future_result<Func, void> (line 1133) | struct future_result<Func, void> {
      function future_invoke (line 1143) | auto future_invoke(Func&& func, T&& v) {
      type result_of_apply (line 1152) | struct result_of_apply {
      type futurize_base (line 1825) | struct futurize_base {
        method type (line 1833) | static inline type convert(T&& value) { return make_ready_future<T...
        method type (line 1834) | static inline type convert(type&& value) { return std::move(value); }
      type futurize_base<void> (line 1842) | struct futurize_base<void> {
        method type (line 1847) | static inline type convert(type&& value) {
      type futurize_base<future<T>> (line 1855) | struct futurize_base<future<T>> : public futurize_base<T> {}
      type futurize_base<future<>> (line 1858) | struct futurize_base<future<>> : public futurize_base<void> {}
      function set_callback (line 2073) | inline
    function task (line 1176) | task* continuation_base_with_promise<Promise, T>::waiting_task() noexc...
    class future (line 1220) | class [[nodiscard]] future : private internal::future_base {
      method future (line 1232) | future(future_for_get_promise_marker) noexcept { }
      method future (line 1234) | future(promise<T>* pr) noexcept : future_base(pr, &_state), _state(s...
      method future (line 1236) | future(ready_future_marker m, A&&... a) noexcept : _state(m, std::fo...
      method future (line 1237) | future(future_state_base::current_exception_future_marker m) noexcep...
      method future (line 1238) | future(future_state_base::nested_exception_marker m, future_state_ba...
      method future (line 1239) | future(future_state_base::nested_exception_marker m, future_state_ba...
      method future (line 1240) | future(exception_future_marker m, std::exception_ptr&& ex) noexcept ...
      method future (line 1241) | future(exception_future_marker m, future_state_base&& state) noexcep...
      method future (line 1242) | [[gnu::always_inline]]
      method get_promise (line 1246) | internal::promise_base_with_type<T> get_promise() noexcept {
      method schedule (line 1253) | void schedule(continuation_base<T>* tws) noexcept {
      method schedule (line 1257) | void schedule(Pr&& pr, Func&& func, Wrapper&& wrapper, std::source_l...
      method future_state (line 1279) | [[gnu::always_inline]]
      method rethrow_with_nested (line 1287) | future<T> rethrow_with_nested(future_state_base&& n) noexcept {
      method rethrow_with_nested (line 1291) | future<T> rethrow_with_nested() noexcept {
      method future (line 1304) | [[gnu::always_inline]]
      method future (line 1306) | future(const future&) = delete;
      method future (line 1307) | future& operator=(future&& x) noexcept {
      method value_type (line 1323) | [[gnu::always_inline]]
      method get_exception (line 1329) | [[gnu::always_inline]]
      method wait (line 1341) | void wait() noexcept {
      method available (line 1351) | [[gnu::always_inline]]
      method failed (line 1359) | [[gnu::always_inline]]
      method Result (line 1387) | Result
      method Result (line 1431) | Result
      method Result (line 1447) | Result then_impl_nrvo(Func&& func, std::source_location sl) noexcept {
      method Result (line 1467) | Result
      method then_wrapped (line 1498) | futurize_t<FuncResult>
      method then_wrapped (line 1510) | futurize_t<FuncResult>
      method then_wrapped_maybe_erase (line 1524) | futurize_t<FuncResult>
      method then_wrapped_nrvo (line 1545) | futurize_t<FuncResult>
      method then_wrapped_common (line 1560) | futurize_t<FuncResult>
      method forward_to (line 1578) | void forward_to(internal::promise_base_with_type<T>&& pr) noexcept {
      method forward_to (line 1597) | void forward_to(promise<T>&& pr) noexcept {
      method finally (line 1629) | future<T> finally(Func&& func, std::source_location sl = std::source...
      type finally_body (line 1641) | struct finally_body
      type finally_body<Func, true> (line 1644) | struct finally_body<Func, true> {
        method finally_body (line 1647) | finally_body(Func&& func) noexcept : _func(std::forward<Func>(func))
      type finally_body<Func, false> (line 1664) | struct finally_body<Func, false> {
        method finally_body (line 1667) | finally_body(Func&& func) noexcept : _func(std::forward<Func>(func))
      method or_terminate (line 1684) | future<> or_terminate(std::source_location sl = std::source_location...
      method discard_result (line 1698) | future<> discard_result(std::source_location sl = std::source_locati...
      method handle_exception (line 1722) | future<T> handle_exception(Func&& func, std::source_location sl = st...
      method handle_exception_type (line 1750) | future<T> handle_exception_type(Func&& func, std::source_location sl...
      method ignore_ready_future (line 1775) | void ignore_ready_future() noexcept {
      method set_task (line 1782) | void set_task(task& t) noexcept {
      method set_callback (line 1787) | void set_callback(continuation_base<T>* callback) noexcept {
    type internal (line 1823) | namespace internal {
      class promise_base_with_type (line 232) | class promise_base_with_type
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class promise_base (line 233) | class promise_base
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      type monostate (line 235) | struct monostate {}
      type future_stored_type (line 238) | struct future_stored_type
      type future_stored_type<> (line 241) | struct future_stored_type<> {
      type future_stored_type<T> (line 246) | struct future_stored_type<T> {
      type get0_return_type (line 259) | struct get0_return_type
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type get0_return_type<internal::monostate> (line 262) | struct get0_return_type<internal::monostate> {
        method type (line 264) | static type get0(internal::monostate) { }
      type get0_return_type (line 268) | struct get0_return_type {
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type uninitialized_wrapper (line 282) | struct uninitialized_wrapper {
        method any (line 285) | any() noexcept {}
        method uninitialized_wrapper (line 292) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 295) | void
        method uninitialized_set (line 299) | void uninitialized_set(tuple_type&& v) {
        method uninitialized_set (line 302) | void uninitialized_set(const tuple_type& v) {
      type uninitialized_wrapper<internal::monostate> (line 314) | struct uninitialized_wrapper<internal::monostate> {
        method uninitialized_wrapper (line 317) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 318) | void uninitialized_set() {
        method uninitialized_set (line 320) | void uninitialized_set(internal::monostate) {
        method uninitialized_set (line 322) | void uninitialized_set(std::tuple<>&& v) {
        method uninitialized_set (line 324) | void uninitialized_set(const std::tuple<>& v) {
      type is_trivially_move_constructible_and_destructible (line 335) | struct is_trivially_move_constructible_and_destructible {
      type all_true (line 340) | struct all_true : std::false_type {}
      type all_true<> (line 343) | struct all_true<> : std::true_type {}
      type is_tuple_effectively_trivially_move_constructible_and_destructible_helper (line 349) | struct is_tuple_effectively_trivially_move_constructible_and_destruc...
      class future_base (line 760) | class future_base
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      class promise_base (line 762) | class promise_base {
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      class promise_base_with_type (line 864) | class promise_base_with_type : protected internal::promise_base {
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class future_base (line 1074) | class future_base {
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      type future_result (line 1126) | struct future_result  {
      type future_result<Func, void> (line 1133) | struct future_result<Func, void> {
      function future_invoke (line 1143) | auto future_invoke(Func&& func, T&& v) {
      type result_of_apply (line 1152) | struct result_of_apply {
      type futurize_base (line 1825) | struct futurize_base {
        method type (line 1833) | static inline type convert(T&& value) { return make_ready_future<T...
        method type (line 1834) | static inline type convert(type&& value) { return std::move(value); }
      type futurize_base<void> (line 1842) | struct futurize_base<void> {
        method type (line 1847) | static inline type convert(type&& value) {
      type futurize_base<future<T>> (line 1855) | struct futurize_base<future<T>> : public futurize_base<T> {}
      type futurize_base<future<>> (line 1858) | struct futurize_base<future<>> : public futurize_base<void> {}
      function set_callback (line 2073) | inline
    type futurize (line 1862) | struct futurize : public internal::futurize_base<T> {
      method type (line 1884) | static inline type invoke(Func&& func, internal::monostate) noexcept {
      method type (line 1888) | static type current_exception_as_future() noexcept {
      method type (line 1893) | static type from_tuple(tuple_type&& value) {
      method type (line 1897) | static type from_tuple(const tuple_type& value) {
      method type (line 1902) | static type from_tuple(value_type&& value) {
      method type (line 1906) | static type from_tuple(const value_type& value) {
    function make_ready_future (line 1943) | inline
    function make_exception_future (line 1949) | inline
    function current_exception_as_future (line 1961) | future<T> current_exception_as_future() noexcept {
    function make_exception_future (line 1974) | inline
    function make_exception_future_with_backtrace (line 1981) | future<T> make_exception_future_with_backtrace(Exception&& ex) noexcept {
    function futurize_invoke (line 2059) | auto futurize_invoke(Func&& func, Args&&... args) noexcept {
    function futurize_apply (line 2065) | auto futurize_apply(Func&& func, std::tuple<Args...>&& args) noexcept {
    type internal (line 2070) | namespace internal {
      class promise_base_with_type (line 232) | class promise_base_with_type
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class promise_base (line 233) | class promise_base
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      type monostate (line 235) | struct monostate {}
      type future_stored_type (line 238) | struct future_stored_type
      type future_stored_type<> (line 241) | struct future_stored_type<> {
      type future_stored_type<T> (line 246) | struct future_stored_type<T> {
      type get0_return_type (line 259) | struct get0_return_type
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type get0_return_type<internal::monostate> (line 262) | struct get0_return_type<internal::monostate> {
        method type (line 264) | static type get0(internal::monostate) { }
      type get0_return_type (line 268) | struct get0_return_type {
        method T (line 270) | static T get0(T&& v) { return std::move(v); }
      type uninitialized_wrapper (line 282) | struct uninitialized_wrapper {
        method any (line 285) | any() noexcept {}
        method uninitialized_wrapper (line 292) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 295) | void
        method uninitialized_set (line 299) | void uninitialized_set(tuple_type&& v) {
        method uninitialized_set (line 302) | void uninitialized_set(const tuple_type& v) {
      type uninitialized_wrapper<internal::monostate> (line 314) | struct uninitialized_wrapper<internal::monostate> {
        method uninitialized_wrapper (line 317) | uninitialized_wrapper() noexcept = default;
        method uninitialized_set (line 318) | void uninitialized_set() {
        method uninitialized_set (line 320) | void uninitialized_set(internal::monostate) {
        method uninitialized_set (line 322) | void uninitialized_set(std::tuple<>&& v) {
        method uninitialized_set (line 324) | void uninitialized_set(const std::tuple<>& v) {
      type is_trivially_move_constructible_and_destructible (line 335) | struct is_trivially_move_constructible_and_destructible {
      type all_true (line 340) | struct all_true : std::false_type {}
      type all_true<> (line 343) | struct all_true<> : std::true_type {}
      type is_tuple_effectively_trivially_move_constructible_and_destructible_helper (line 349) | struct is_tuple_effectively_trivially_move_constructible_and_destruc...
      class future_base (line 760) | class future_base
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      class promise_base (line 762) | class promise_base {
        type urgent (line 764) | enum class urgent { no, yes }
        method set_task (line 776) | void set_task(task* task) noexcept {
        method set_task (line 782) | void set_task(task* task) noexcept {
        method assert_task_shard (line 785) | void assert_task_shard() const noexcept { }
        method promise_base (line 788) | promise_base(const promise_base&) = delete;
        method promise_base (line 789) | promise_base(future_state_base* state) noexcept : _state(state) {}
        method set_exception_impl (line 809) | void set_exception_impl(T&& val) noexcept {
        method set_exception (line 825) | void set_exception(future_state_base&& state) noexcept {
        method set_exception (line 829) | void set_exception(std::exception_ptr&& ex) noexcept {
        method set_exception (line 833) | void set_exception(const std::exception_ptr& ex) noexcept {
        method set_exception (line 839) | void set_exception(Exception&& e) noexcept {
        method task (line 854) | task* waiting_task() const noexcept { return _task; }
      class promise_base_with_type (line 864) | class promise_base_with_type : protected internal::promise_base {
        method future_state (line 867) | future_state* get_state() noexcept {
        method promise_base_with_type (line 872) | promise_base_with_type(future_state_base* state) noexcept : promis...
        method promise_base_with_type (line 873) | promise_base_with_type(future<T>* future) noexcept : promise_base(...
        method promise_base_with_type (line 874) | promise_base_with_type(promise_base_with_type&& x) noexcept = defa...
        method promise_base_with_type (line 875) | promise_base_with_type(const promise_base_with_type&) = delete;
        method promise_base_with_type (line 876) | promise_base_with_type& operator=(promise_base_with_type&& x) noex...
        method set_urgent_state (line 879) | void set_urgent_state(future_state&& state) noexcept {
        method set_value (line 891) | void set_value(A&&... a) noexcept {
        method set_to_current_exception (line 902) | void set_to_current_exception() noexcept {
      class future_base (line 1074) | class future_base {
        method future_base (line 1077) | future_base() noexcept : _promise(nullptr) {}
        method future_base (line 1078) | future_base(promise_base* promise, future_state_base* state) noexc...
        method move_it (line 1083) | void move_it(future_base&& x, future_state_base* state) noexcept {
        method future_base (line 1092) | future_base(future_base&& x, future_state_base* state) noexcept {
        method clear (line 1096) | void clear() noexcept {
        method promise_base (line 1106) | promise_base* detach_promise() noexcept {
        method schedule (line 1112) | void schedule(task* tws, future_state_base* state) noexcept {
      type future_result (line 1126) | struct future_result  {
      type future_result<Func, void> (line 1133) | struct future_result<Func, void> {
      function future_invoke (line 1143) | auto future_invoke(Func&& func, T&& v) {
      type result_of_apply (line 1152) | struct result_of_apply {
      type futurize_base (line 1825) | struct futurize_base {
        method type (line 1833) | static inline type convert(T&& value) { return make_ready_future<T...
        method type (line 1834) | static inline type convert(type&& value) { return std::move(value); }
      type futurize_base<void> (line 1842) | struct futurize_base<void> {
        method type (line 1847) | static inline type convert(type&& value) {
      type futurize_base<future<T>> (line 1855) | struct futurize_base<future<T>> : public futurize_base<T> {}
      type futurize_base<future<>> (line 1858) | struct futurize_base<future<>> : public futurize_base<void> {}
      function set_callback (line 2073) | inline
  type all_true<true, v...> (line 346) | struct all_true<true, v...> : public all_true<v...> {}
  type is_tuple_effectively_trivially_move_constructible_and_destructible_helper<std::tuple<T...>> (line 352) | struct is_tuple_effectively_trivially_move_constructible_and_destructibl...
  type continuation_base_from_future<future<T...>> (line 706) | struct continuation_base_from_future<future<T...>> {
  type is_future<future<T...>> (line 1030) | struct is_future<future<T...>> : std::true_type {}
  type result_of_apply<Func, std::tuple<T...>> (line 1157) | struct result_of_apply<Func, std::tuple<T...>> : std::invoke_result<Func...

FILE: include/seastar/core/gate.hh
  type seastar (line 38) | namespace seastar {
    class gate_closed_exception (line 45) | class gate_closed_exception : public std::exception {
    class named_gate_closed_exception (line 54) | class named_gate_closed_exception : public gate_closed_exception {
      method named_gate_closed_exception (line 58) | named_gate_closed_exception(const sstring& name) noexcept : gate_clo...
    class gate (line 77) | class gate {
      method assert_not_held_when_moved (line 85) | void assert_not_held_when_moved() const noexcept {}
      method assert_not_held_when_destroyed (line 86) | void assert_not_held_when_destroyed() const noexcept {}
      method gate (line 91) | gate() noexcept {}
      method gate (line 92) | gate(const gate&) = delete;
      method gate (line 93) | gate(gate&& x) noexcept
      method gate (line 97) | gate& operator=(gate&& x) noexcept {
      method try_enter (line 114) | bool try_enter() noexcept {
      method enter (line 125) | void enter() {
      method leave (line 134) | void leave() noexcept {
      method check (line 149) | void check() const {
      method close (line 159) | future<> close() noexcept {
      method get_count (line 169) | size_t get_count() const noexcept {
      method is_closed (line 174) | bool is_closed() const noexcept {
      class holder (line 187) | class holder {
        method debug_hold_gate (line 193) | void debug_hold_gate() noexcept {
        method debug_release_gate (line 199) | void debug_release_gate() noexcept {
        method debug_hold_gate (line 203) | void debug_hold_gate() noexcept {}
        method debug_release_gate (line 204) | void debug_release_gate() noexcept {}
        method gate (line 209) | gate* release_gate() noexcept {
        method holder (line 221) | holder() noexcept : _g(nullptr) { }
        method holder (line 225) | explicit holder(gate& g) : _g(&g) {
        method holder (line 235) | holder(const holder& x) noexcept : _g(x._g) {
        method holder (line 245) | holder(holder&& x) noexcept : _g(std::move(x).release_gate()) {
        method holder (line 260) | holder& operator=(const holder& x) noexcept {
        method holder (line 276) | holder& operator=(holder&& x) noexcept {
        method release (line 286) | void release() noexcept {
      method holder (line 295) | holder hold() {
        method debug_hold_gate (line 193) | void debug_hold_gate() noexcept {
        method debug_release_gate (line 199) | void debug_release_gate() noexcept {
        method debug_hold_gate (line 203) | void debug_hold_gate() noexcept {}
        method debug_release_gate (line 204) | void debug_release_gate() noexcept {}
        method gate (line 209) | gate* release_gate() noexcept {
        method holder (line 221) | holder() noexcept : _g(nullptr) { }
        method holder (line 225) | explicit holder(gate& g) : _g(&g) {
        method holder (line 235) | holder(const holder& x) noexcept : _g(x._g) {
        method holder (line 245) | holder(holder&& x) noexcept : _g(std::move(x).release_gate()) {
        method holder (line 260) | holder& operator=(const holder& x) noexcept {
        method holder (line 276) | holder& operator=(holder&& x) noexcept {
        method release (line 286) | void release() noexcept {
      method try_hold (line 302) | std::optional<holder> try_hold() noexcept {
      method make_closed_exception (line 307) | virtual std::exception_ptr make_closed_exception() const {
      method throw_closed_exception (line 322) | [[noreturn]] void throw_closed_exception() const {
    class named_gate (line 336) | class named_gate : public gate {
      method named_gate (line 340) | named_gate() = default;
      method named_gate (line 341) | explicit named_gate(sstring name) noexcept
      method named_gate (line 345) | named_gate(named_gate&&) = default;
      method named_gate (line 346) | named_gate& operator=(named_gate&&) = default;
      method make_closed_exception (line 349) | virtual std::exception_ptr make_closed_exception() const override {
    type internal (line 354) | namespace internal {
      function invoke_func_with_gate (line 357) | inline
    function with_gate (line 374) | inline
    function try_with_gate (line 392) | inline

FILE: include/seastar/core/idle_cpu_handler.hh
  type seastar (line 28) | namespace seastar {
    type idle_cpu_handler_result (line 33) | enum class idle_cpu_handler_result {

FILE: include/seastar/core/internal/api-level.hh
  type seastar (line 36) | namespace seastar {
    function SEASTAR_INCLUDE_API_V8 (line 37) | SEASTAR_INCLUDE_API_V8 namespace api_v8 {

FILE: include/seastar/core/internal/buffer_allocator.hh
  type seastar (line 24) | namespace seastar {
    class temporary_buffer (line 27) | class temporary_buffer
    type internal (line 29) | namespace internal {
      class buffer_allocator (line 34) | class buffer_allocator {

FILE: include/seastar/core/internal/current_task.hh
  type seastar::internal (line 24) | namespace seastar::internal {

FILE: include/seastar/core/internal/estimated_histogram.hh
  type seastar::metrics::internal (line 34) | namespace seastar::metrics::internal {
    class approximate_exponential_histogram (line 124) | class approximate_exponential_histogram {
      method approximate_exponential_histogram (line 133) | approximate_exponential_histogram() {
      method get_bucket_lower_limit (line 142) | uint64_t get_bucket_lower_limit(uint16_t bucket_id) const {
      method get_bucket_upper_limit (line

[
  {
    "path": ".clangd",
    "chars": 107,
    "preview": "Style:\n  AngledHeaders:\n    # public headers (under include/seastar) use angle brackets\n    - \"seastar/.*\"\n"
  },
  {
    "path": ".claude/CLAUDE.md",
    "chars": 3494,
    "preview": "# Seastar Project Instructions\n\n## Building\n\nThe project uses CMake with ninja as the build system. Build directories ar"
  },
  {
    "path": ".dockerignore",
    "chars": 11,
    "preview": ".git\nbuild\n"
  },
  {
    "path": ".gitattributes",
    "chars": 28,
    "preview": "*.cc diff=cpp\n*.hh diff=cpp\n"
  },
  {
    "path": ".github/workflows/alpinelinux.yaml",
    "chars": 1645,
    "preview": "name: Alpine Linux\n\non:\n  pull_request:\n  workflow_dispatch:  # Allows manual triggering\n\nconcurrency:\n  group: ${{ gith"
  },
  {
    "path": ".github/workflows/docker.yaml",
    "chars": 836,
    "preview": "name: Verify Dockerfile Build\n\non:\n  pull_request:\n    paths:\n      - 'docker/dev/Dockerfile'\n      - 'install-dependenc"
  },
  {
    "path": ".github/workflows/pre-commit.yaml",
    "chars": 459,
    "preview": "name: Pre-commit\n\non: [push, pull_request]\n\njobs:\n  pre-commit:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: acti"
  },
  {
    "path": ".github/workflows/python-lint.yaml",
    "chars": 420,
    "preview": "name: Python format\n\non: [push, pull_request]\n\njobs:\n  python-format:\n    name: Enforce python format\n    runs-on: ubunt"
  },
  {
    "path": ".github/workflows/test.yaml",
    "chars": 3596,
    "preview": "name: Test\n\npermissions:\n  contents: read\n\non:\n  workflow_call:\n    inputs:\n      compiler:\n        description: 'the C+"
  },
  {
    "path": ".github/workflows/tests.yaml",
    "chars": 1497,
    "preview": "name: Test\n\npermissions:\n  contents: read\n\non:\n  push:\n  pull_request:\n  workflow_dispatch:  # Allows manual triggering\n"
  },
  {
    "path": ".gitignore",
    "chars": 156,
    "preview": ".cooking_memory\n.cproject\n.project\n.settings\nbuild*\nbuild.ninja\ncscope.*\n__pycache__/\ncmake/Cooking.cmake\ntags\n.idea/\n.v"
  },
  {
    "path": ".gitmodules",
    "chars": 47,
    "preview": "[submodule \"dpdk\"]\n\tpath = dpdk\n\turl = ../dpdk\n"
  },
  {
    "path": ".gitorderfile",
    "chars": 22,
    "preview": "*.py\n*.hh\n*.rl\n*.cc\n*\n"
  },
  {
    "path": ".mailmap",
    "chars": 303,
    "preview": "Avi Kivity <avi@scylladb.com> Avi Kivity' via seastar-dev <seastar-dev@googlegroups.com>\nRaphael S. Carvalho <raphaelsc@"
  },
  {
    "path": ".pre-commit-config.yaml",
    "chars": 123,
    "preview": "repos:\n  - repo: https://github.com/pre-commit/pre-commit-hooks\n    rev: v5.0.0\n    hooks:\n      - id: trailing-whitespa"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 44423,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 727,
    "preview": "# Contributing Code to Seastar\n\nThere are two ways to contribute code to Seastar:\n* send your changes as [patches](https"
  },
  {
    "path": "HACKING.md",
    "chars": 4744,
    "preview": "# Developing and using Seastar\n\n## Configuring the project\n\nThere are multiple ways to configure Seastar and its depende"
  },
  {
    "path": "LICENSE",
    "chars": 10174,
    "preview": "\n                                 Apache License\n                           Version 2.0, January 2004\n                  "
  },
  {
    "path": "NOTICE",
    "chars": 460,
    "preview": "Seastar Framework\nCopyright 2015 Cloudius Systems\n\nThis works contains software from the OSv project (http://osv.io), li"
  },
  {
    "path": "README-DPDK.md",
    "chars": 1325,
    "preview": "Seastar and DPDK\n================\n\nSeastar uses the Data Plane Development Kit to drive NIC hardware directly.  This\npro"
  },
  {
    "path": "README.md",
    "chars": 8349,
    "preview": "Seastar\n=======\n\n[![Test](https://github.com/scylladb/seastar/actions/workflows/tests.yaml/badge.svg)](https://github.co"
  },
  {
    "path": "apps/CMakeLists.txt",
    "chars": 1531,
    "preview": "# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"License\""
  },
  {
    "path": "apps/httpd/CMakeLists.txt",
    "chars": 1134,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "apps/httpd/demo.json",
    "chars": 2445,
    "preview": "{\n    \"apiVersion\": \"0.0.1\",\n    \"swaggerVersion\": \"1.2\",\n    \"basePath\": \"{{Protocol}}://{{Host}}\",\n    \"resourcePath\":"
  },
  {
    "path": "apps/httpd/main.cc",
    "chars": 6734,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/io_tester/CMakeLists.txt",
    "chars": 989,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "apps/io_tester/conf.yaml",
    "chars": 559,
    "preview": "- name: big_writes\n  shards: all\n  type: overwrite\n  shard_info:\n    parallelism: 10\n    reqsize: 256kB\n    shares: 10\n "
  },
  {
    "path": "apps/io_tester/io_tester.cc",
    "chars": 52831,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/io_tester/ioinfo.cc",
    "chars": 5381,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/io_tester/sched.yaml",
    "chars": 176,
    "preview": "- name: statement\n  shares: 1000\n\n- name: maintenance\n  shares: 100\n\n- name: compaction\n  shares: 200\n  parent: maintena"
  },
  {
    "path": "apps/iotune/CMakeLists.txt",
    "chars": 873,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "apps/iotune/iotune.cc",
    "chars": 48769,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/lib/stop_signal.hh",
    "chars": 2221,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/memcached/CMakeLists.txt",
    "chars": 1387,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "apps/memcached/ascii.rl",
    "chars": 4840,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/memcached/memcache.cc",
    "chars": 57849,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/memcached/memcached.hh",
    "chars": 1773,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/memcached/tests/CMakeLists.txt",
    "chars": 2400,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "apps/memcached/tests/test.py",
    "chars": 1662,
    "preview": "#!/usr/bin/env python3\n#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, V"
  },
  {
    "path": "apps/memcached/tests/test_ascii_parser.cc",
    "chars": 13693,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/memcached/tests/test_memcached.py",
    "chars": 22599,
    "preview": "#!/usr/bin/env python3\n#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, V"
  },
  {
    "path": "apps/rpc_tester/CMakeLists.txt",
    "chars": 881,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "apps/rpc_tester/rpc_tester.cc",
    "chars": 34784,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "apps/rpc_tester/sample-conf.yaml",
    "chars": 1346,
    "preview": "client:\n  nodelay: # bool, whether or not to set tcp_nodelay option\nserver:\n  nodelay: # bool, whether or not to set tcp"
  },
  {
    "path": "apps/seawreck/CMakeLists.txt",
    "chars": 808,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "apps/seawreck/seawreck.cc",
    "chars": 9209,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "cmake/CheckGcc107852.cmake",
    "chars": 666,
    "preview": "include (CheckCXXSourceCompiles)\ninclude (CMakePushCheckState)\n\ncmake_push_check_state (RESET)\n\n# these options are incl"
  },
  {
    "path": "cmake/CheckHeaders.cmake",
    "chars": 4703,
    "preview": "# seastar_check_self_contained() checks if the headers listed as the source of\n# a target are self-contained.\n#\n# Header"
  },
  {
    "path": "cmake/CheckIncludeStyle.cmake",
    "chars": 749,
    "preview": "# seastar_check_include_style() enforces that all source and header files under\n# specified directories include the head"
  },
  {
    "path": "cmake/CheckLibc.cmake",
    "chars": 1293,
    "preview": "# check for the bits in different standard C library implementations we\n# care about\n\ninclude (CheckCXXSourceCompiles)\nf"
  },
  {
    "path": "cmake/CheckP2582R1.cmake",
    "chars": 562,
    "preview": "include (CheckCXXSourceCompiles)\ninclude (CMakePushCheckState)\n\ncmake_push_check_state (RESET)\n\nset (CMAKE_REQUIRED_FLAG"
  },
  {
    "path": "cmake/CxxModulesRules.cmake",
    "chars": 1031,
    "preview": "if (CMAKE_CXX_COMPILER_ID STREQUAL \"Clang\")\n  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16)\n    message (FATAL_ERROR \""
  },
  {
    "path": "cmake/FindGnuTLS.cmake",
    "chars": 1684,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/FindLibUring.cmake",
    "chars": 2027,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/FindLinuxMembarrier.cmake",
    "chars": 1430,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/FindPthreadSetName.cmake",
    "chars": 406,
    "preview": "include (CheckSymbolExists)\ninclude (CMakePushCheckState)\n\ncmake_push_check_state (RESET)\nset (CMAKE_REQUIRED_FLAGS \"-pt"
  },
  {
    "path": "cmake/FindSanitizers.cmake",
    "chars": 3372,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/FindStdAtomic.cmake",
    "chars": 1576,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/FindSystemTap-SDT.cmake",
    "chars": 1210,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/FindValgrind.cmake",
    "chars": 1483,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Findc-ares.cmake",
    "chars": 2143,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Finddpdk.cmake",
    "chars": 6516,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Findhwloc.cmake",
    "chars": 1712,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Findlksctp-tools.cmake",
    "chars": 1608,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Findlz4.cmake",
    "chars": 1643,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Findragel.cmake",
    "chars": 1440,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Findrt.cmake",
    "chars": 1581,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Finducontext.cmake",
    "chars": 1627,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/Findyaml-cpp.cmake",
    "chars": 2469,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/SeastarConfig.cmake.in",
    "chars": 2263,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/SeastarDependencies.cmake",
    "chars": 4510,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "cmake/TriStateOption.cmake",
    "chars": 1285,
    "preview": "# the \"option()\" defined by CMake represents a boolean. but somtimes, we want\n# to enable/disable it depending on the CM"
  },
  {
    "path": "cmake/check-seastar-include-style.py",
    "chars": 1659,
    "preview": "#!/usr/bin/env python3\n#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, V"
  },
  {
    "path": "cmake/code_tests/LinuxMembarrier_test.cc",
    "chars": 164,
    "preview": "extern \"C\" {\n#include <linux/membarrier.h>\n}\n\nint main() {\n    int x = MEMBARRIER_CMD_PRIVATE_EXPEDITED | MEMBARRIER_CMD"
  },
  {
    "path": "cmake/code_tests/Sanitizers_fiber_test.cc",
    "chars": 314,
    "preview": "#include <cstddef>\n\nextern \"C\" {\n    void __sanitizer_start_switch_fiber(void**, const void*, size_t);\n    void __saniti"
  },
  {
    "path": "cmake/code_tests/Source_location_default_argument.cc",
    "chars": 249,
    "preview": "#include<source_location>\n\nint test_source_location(int line,\n                         std::source_location loc = std::s"
  },
  {
    "path": "cmake/code_tests/Source_location_test.cc",
    "chars": 625,
    "preview": "#if __has_include(<source_location>)\n#include <source_location>\n#endif\n\n#ifdef __cpp_lib_source_location\nusing source_lo"
  },
  {
    "path": "cmake/code_tests/rt_test.cc",
    "chars": 156,
    "preview": "extern \"C\" {\n#include <signal.h>\n#include <time.h>\n}\n\nint main() {\n    timer_t td;\n    struct sigevent sev;\n    timer_cr"
  },
  {
    "path": "cmake/code_tests/stdout_test.cc",
    "chars": 82,
    "preview": "#include <cstdio>\n\nenum class logger_type {\n  stdout,\n  stderr,\n};\n\nint main() {}\n"
  },
  {
    "path": "coding-style.md",
    "chars": 5522,
    "preview": "# Seastar Coding Style\n\n## Files\n\nHeader files have the `.hh` extension, source files use the `.cc` extension. All files"
  },
  {
    "path": "configure.py",
    "chars": 15303,
    "preview": "#!/usr/bin/env python3\n#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, V"
  },
  {
    "path": "cooking.sh",
    "chars": 26472,
    "preview": "#!/bin/bash\n\n#\n# Copyright 2018 Jesse Haber-Kucharsky\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
  },
  {
    "path": "cooking_recipe.cmake",
    "chars": 10490,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "debug/task-latency.stap",
    "chars": 563,
    "preview": "#!/usr/bin/stap\n\n# usage: task_latency.stap process_name latency_threshold_ms\n\nglobal start_time\n\nprobe process(@1).mark"
  },
  {
    "path": "demos/CMakeLists.txt",
    "chars": 3200,
    "preview": "#\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the \"Licens"
  },
  {
    "path": "demos/block_discard_demo.cc",
    "chars": 2412,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/coroutines_demo.cc",
    "chars": 2435,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/echo_demo.cc",
    "chars": 3590,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/file_demo.cc",
    "chars": 10846,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/hello-cxx-module.cc",
    "chars": 1038,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/hello-world.cc",
    "chars": 1128,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/http_client_demo.cc",
    "chars": 4534,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/ip_demo.cc",
    "chars": 1425,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/l3_demo.cc",
    "chars": 1633,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/line_count_demo.cc",
    "chars": 2903,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/rpc_demo.cc",
    "chars": 14905,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/scheduling_group_demo.cc",
    "chars": 7321,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/sharded_parameter_demo.cc",
    "chars": 2800,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/tcp_demo.cc",
    "chars": 2453,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/tcp_sctp_client_demo.cc",
    "chars": 10695,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/tcp_sctp_server_demo.cc",
    "chars": 7992,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/tls_echo_server.hh",
    "chars": 4821,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/tls_echo_server_demo.cc",
    "chars": 2968,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/tls_simple_client_demo.cc",
    "chars": 5947,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/tutorial_examples.cc",
    "chars": 4353,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/udp_client_demo.cc",
    "chars": 2701,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/udp_server_demo.cc",
    "chars": 3264,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/udp_zero_copy_demo.cc",
    "chars": 4489,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/websocket_client_demo.cc",
    "chars": 4013,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "demos/websocket_server_demo.cc",
    "chars": 2985,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "doc/CMakeLists.txt",
    "chars": 1968,
    "preview": "find_program (Seastar_DOXYGEN_EXECUTABLE doxygen)\nif (NOT Seastar_DOXYGEN_EXECUTABLE)\n  message (FATAL_ERROR \"doxygen is"
  },
  {
    "path": "doc/Doxyfile.in",
    "chars": 103752,
    "preview": "# Doxyfile 1.8.9.1\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org"
  },
  {
    "path": "doc/DoxygenLayout.xml",
    "chars": 5898,
    "preview": "<doxygenlayout version=\"1.0\">\n  <!-- Generated by doxygen 1.8.13 -->\n  <!-- Navigation index tabs for HTML output -->\n  "
  },
  {
    "path": "doc/compatibility.md",
    "chars": 5775,
    "preview": "Compatibility\n=============\n\nAs a library, Seastar aims to maintain backwards compatibility\nin terms of the source (appl"
  },
  {
    "path": "doc/contributing.md",
    "chars": 1097,
    "preview": "Contributing to Seastar\n=======================\n\n# Sending Patches\nSeastar follows a patch submission similar to Linux. "
  },
  {
    "path": "doc/generator.md",
    "chars": 15080,
    "preview": "# Coroutine Generator\n\n## Overview\n\nThe generator implementation is based on C++23 proposal [P2502R2](https://wg21.link/"
  },
  {
    "path": "doc/htmlsplit.py",
    "chars": 5874,
    "preview": "#!/usr/bin/env python3\n\n# This script takes the single-page HTML output from pandoc - tutorial.html -\n# and splits it in"
  },
  {
    "path": "doc/io-properties-file.md",
    "chars": 2201,
    "preview": "# Specifying the I/O properties of a system\n\nThe I/O properties of a system can be specified as a YAML string, by\nusing "
  },
  {
    "path": "doc/io-scheduler.md",
    "chars": 5137,
    "preview": "IO scheduler uses rate-limiter to throttle the amount of data it dispatches into the disk.\n\n# Basic math\n\nThe scheduler'"
  },
  {
    "path": "doc/io-tester.md",
    "chars": 5221,
    "preview": "## I/O Tester utility\n\nThe I/O Tester utility, `io_tester` generates a user-defined I/O pattern\nspanning one of multiple"
  },
  {
    "path": "doc/lambda-coroutine-fiasco.md",
    "chars": 4188,
    "preview": "# The Lambda Coroutine Fiasco\n\nLambda coroutines and Seastar APIs that accept continuations interact badly. This\ndocumen"
  },
  {
    "path": "doc/md2html",
    "chars": 1104,
    "preview": "#!/bin/sh\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the"
  },
  {
    "path": "doc/md2pdf",
    "chars": 911,
    "preview": "#!/bin/sh\n# This file is open source software, licensed to you under the terms\n# of the Apache License, Version 2.0 (the"
  },
  {
    "path": "doc/mini-tutorial.md",
    "chars": 6089,
    "preview": "Futures and promises\n--------------------\n\nA *future* is a result of a computation that may not be available yet.\nExampl"
  },
  {
    "path": "doc/native-stack.md",
    "chars": 2368,
    "preview": "Seastar Native TCP/IP Stack\n---------------------------\n\nSeastar comes with a native, sharded TCP/IP stack.  Usually it "
  },
  {
    "path": "doc/network-configuration.md",
    "chars": 2698,
    "preview": "Network Configuration\n---------------------\n\nIn order to support multiple network devices in Seastar, new Network Config"
  },
  {
    "path": "doc/network-connection-load-balancing.md",
    "chars": 2172,
    "preview": "# Motivation\n\nIn sharded systems like seastar it is important for work to be\ndistributed equally between all shards to a"
  },
  {
    "path": "doc/prometheus.md",
    "chars": 5024,
    "preview": "# The Prometheus Protocol\n\nSeastar supports the Prometheus protocol for metrics reporting.\nSupported exposition formats "
  },
  {
    "path": "doc/rpc-compression.md",
    "chars": 2170,
    "preview": "# RPC provided compression infrastructure\n\n## Compression algorithm negotiation\n\nRPC protocol only defines `COMPRESS` fe"
  },
  {
    "path": "doc/rpc-streaming.md",
    "chars": 4915,
    "preview": "# RPC streaming\n\n## Streaming API\n\n### Sink and Source\n\nBasic element of streaming API is `rpc::sink` and `rpc::source`."
  },
  {
    "path": "doc/rpc.md",
    "chars": 7037,
    "preview": "# RPC protocol\n\n## Data encoding\n\nAll integral data is encoded in little endian format.\n\n## Protocol negotiation\n\nThe ne"
  },
  {
    "path": "doc/shared-token-bucket.md",
    "chars": 4272,
    "preview": "# Shared token bucket\n\n## Intro\n\nThe classical token bucket has two parameters -- rate and limit. The rate\nis the amount"
  },
  {
    "path": "doc/signal.md",
    "chars": 1788,
    "preview": "# Signals\n\nSeastar provides an interface to handle signals natively and safely as asynchronous tasks.\n\n## Default Signal"
  },
  {
    "path": "doc/template.css",
    "chars": 2730,
    "preview": "/* CSS style for Seastar's tutorial.\n * TODO: We also get some style for syntax highlighting inserted by our\n * use of \""
  },
  {
    "path": "doc/template.tex",
    "chars": 3184,
    "preview": "% The pandoc command line (see configure.py) can communicate variables to this\n% LaTeX skelaton, by using the \"-V varnam"
  },
  {
    "path": "doc/testing.md",
    "chars": 3993,
    "preview": "# Testing\n\nSeastar leverages Boost.Test and provides facilities for developers to implement tests in coroutines.\n\n## Tes"
  },
  {
    "path": "doc/tutorial.md",
    "chars": 170409,
    "preview": "% Asynchronous Programming with Seastar\n% Nadav Har'El - nyh@ScyllaDB.com\n  Avi Kivity - avi@ScyllaDB.com\n\n# Introductio"
  },
  {
    "path": "doc/websocket.md",
    "chars": 2164,
    "preview": "# WebSocket protocol implementation\n\nSeastar includes an experimental implementation of a WebSocket server.\nRefs:\nhttps:"
  },
  {
    "path": "docker/dev/Dockerfile",
    "chars": 1096,
    "preview": "# syntax=docker/dockerfile:1\n\nFROM ubuntu:plucky\n\nRUN --mount=type=bind,source=./install-dependencies.sh,target=/install"
  },
  {
    "path": "include/seastar/core/abort_on_ebadf.hh",
    "chars": 1281,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/abort_on_expiry.hh",
    "chars": 1807,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/abort_source.hh",
    "chars": 9046,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/abortable_fifo.hh",
    "chars": 8930,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/alien.hh",
    "chars": 6839,
    "preview": "// -*- mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-\n/*\n * This file is open source software, licens"
  },
  {
    "path": "include/seastar/core/align.hh",
    "chars": 1524,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/aligned_buffer.hh",
    "chars": 1369,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/app-template.hh",
    "chars": 7391,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/bitops.hh",
    "chars": 1786,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/bitset-iter.hh",
    "chars": 4926,
    "preview": "/*\n * Copyright (C) 2014 Cloudius Systems, Ltd.\n */\n\n/*\n * Imported from OSv:\n *\n * Copyright (C) 2014 Cloudius Systems,"
  },
  {
    "path": "include/seastar/core/byteorder.hh",
    "chars": 2502,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/cacheline.hh",
    "chars": 1249,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/checked_ptr.hh",
    "chars": 6305,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/chunked_fifo.hh",
    "chars": 22772,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/circular_buffer.hh",
    "chars": 15364,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/circular_buffer_fixed_capacity.hh",
    "chars": 11271,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/condition-variable.hh",
    "chars": 16902,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/coroutine.hh",
    "chars": 9403,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/deleter.hh",
    "chars": 8399,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/disk_params.hh",
    "chars": 3178,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/distributed.hh",
    "chars": 987,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/do_with.hh",
    "chars": 4953,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/dpdk_rte.hh",
    "chars": 1944,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/enum.hh",
    "chars": 1326,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/exception_hacks.hh",
    "chars": 834,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/execution_stage.hh",
    "chars": 21889,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/expiring_fifo.hh",
    "chars": 6979,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/fair_queue.hh",
    "chars": 12555,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/file-types.hh",
    "chars": 5050,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/file.hh",
    "chars": 29551,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/format.hh",
    "chars": 1408,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/fsnotify.hh",
    "chars": 7803,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/fsqual.hh",
    "chars": 923,
    "preview": "/*\n * Copyright 2017 ScyllaDB\n */\n/*\n * This file is open source software, licensed to you under the terms\n * of the Apa"
  },
  {
    "path": "include/seastar/core/fstream.hh",
    "chars": 5591,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/function_traits.hh",
    "chars": 2521,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/future-util.hh",
    "chars": 1099,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/future.hh",
    "chars": 79347,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/gate.hh",
    "chars": 13822,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/idle_cpu_handler.hh",
    "chars": 2469,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/api-level.hh",
    "chars": 1617,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/buffer_allocator.hh",
    "chars": 1244,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/current_task.hh",
    "chars": 1183,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/estimated_histogram.hh",
    "chars": 14950,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/io_desc.hh",
    "chars": 1129,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/io_intent.hh",
    "chars": 4046,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/io_request.hh",
    "chars": 11630,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/io_sink.hh",
    "chars": 2037,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/linux-aio.hh",
    "chars": 5989,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/poll.hh",
    "chars": 3034,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/pollable_fd.hh",
    "chars": 8420,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/run_in_background.hh",
    "chars": 1025,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/stall_detector.hh",
    "chars": 6397,
    "preview": "\n/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Li"
  },
  {
    "path": "include/seastar/core/internal/systemwide_memory_barrier.hh",
    "chars": 1078,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/internal/uname.hh",
    "chars": 1831,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/io_intent.hh",
    "chars": 3485,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/io_priority_class.hh",
    "chars": 958,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/io_queue.hh",
    "chars": 17978,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/iostream-impl.hh",
    "chars": 20800,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/iostream.hh",
    "chars": 22716,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "include/seastar/core/layered_file.hh",
    "chars": 2335,
    "preview": "/*\n * This file is open source software, licensed to you under the terms\n * of the Apache License, Version 2.0 (the \"Lic"
  }
]

// ... and 460 more files (download for full content)