|
void | set_abort_on_ebadf (bool do_abort) |
|
bool | is_abort_on_ebadf_enabled () |
|
template<typename T > |
constexpr T | align_up (T v, T align) |
|
template<typename T > |
constexpr T * | align_up (T *v, size_t align) |
|
template<typename T > |
constexpr T | align_down (T v, T align) |
|
template<typename T > |
constexpr T * | align_down (T *v, size_t align) |
|
template<typename CharType > |
std::unique_ptr< CharType[], free_deleter > | allocate_aligned_buffer (size_t size, size_t align) |
|
constexpr unsigned | count_leading_zeros (unsigned x) |
|
constexpr unsigned | count_leading_zeros (unsigned long x) |
|
constexpr unsigned | count_leading_zeros (unsigned long long x) |
|
constexpr unsigned | count_trailing_zeros (unsigned x) |
|
constexpr unsigned | count_trailing_zeros (unsigned long x) |
|
constexpr unsigned | count_trailing_zeros (unsigned long long x) |
|
template<std::integral T> |
constexpr unsigned | log2ceil (T n) |
|
template<std::integral T> |
constexpr unsigned | log2floor (T n) |
|
template<typename T > |
T | cpu_to_le (T x) noexcept |
|
template<typename T > |
T | le_to_cpu (T x) noexcept |
|
template<typename T > |
T | cpu_to_be (T x) noexcept |
|
template<typename T > |
T | be_to_cpu (T x) noexcept |
|
template<typename T > |
T | cpu_to_le (const unaligned< T > &v) noexcept |
|
template<typename T > |
T | le_to_cpu (const unaligned< T > &v) noexcept |
|
template<typename T > |
T | read_le (const char *p) noexcept |
|
template<typename T > |
void | write_le (char *p, T datum) noexcept |
|
template<typename T > |
T | read_be (const char *p) noexcept |
|
template<typename T > |
void | write_be (char *p, T datum) noexcept |
|
template<typename T > |
T | consume_be (const char *&p) noexcept |
|
template<typename T > |
void | produce_be (char *&p, T datum) noexcept |
|
template<typename T > |
auto | operator co_await (future< T > f) noexcept |
|
template<typename T > |
auto | operator co_await (coroutine::without_preemption_check< T > f) noexcept |
|
template<typename T1 , typename T2 , typename... More> |
auto | do_with (T1 &&rv1, T2 &&rv2, More &&... more) noexcept |
|
template<typename Lock , typename Func > |
auto | with_lock (Lock &lock, Func &&func) |
|
void | init_phdr_cache () |
|
template<typename Function > |
auto | make_execution_stage (const sstring &name, scheduling_group sg, Function &&fn) |
|
template<typename Function > |
auto | make_execution_stage (const sstring &name, Function &&fn) |
|
template<typename Ret , typename Object , typename... Args> |
concrete_execution_stage< Ret, Object *, Args... > | make_execution_stage (const sstring &name, scheduling_group sg, Ret(Object::*fn)(Args...)) |
|
template<typename Ret , typename Object , typename... Args> |
concrete_execution_stage< Ret, const Object *, Args... > | make_execution_stage (const sstring &name, scheduling_group sg, Ret(Object::*fn)(Args...) const) |
|
template<typename Ret , typename Object , typename... Args> |
concrete_execution_stage< Ret, Object *, Args... > | make_execution_stage (const sstring &name, Ret(Object::*fn)(Args...)) |
|
template<typename Ret , typename Object , typename... Args> |
concrete_execution_stage< Ret, const Object *, Args... > | make_execution_stage (const sstring &name, Ret(Object::*fn)(Args...) const) |
|
open_flags | operator| (open_flags a, open_flags b) |
|
void | operator|= (open_flags &a, open_flags b) |
|
open_flags | operator& (open_flags a, open_flags b) |
|
void | operator&= (open_flags &a, open_flags b) |
|
access_flags | operator| (access_flags a, access_flags b) |
|
access_flags | operator& (access_flags a, access_flags b) |
|
constexpr file_permissions | operator| (file_permissions a, file_permissions b) |
|
constexpr file_permissions | operator& (file_permissions a, file_permissions b) |
|
future< shared_ptr< file_impl > > | make_file_impl (int fd, file_open_options options, int oflags, struct stat st) noexcept |
|
template<std::invocable< file & > Func>
requires std::is_nothrow_move_constructible_v<Func> |
auto | with_file (future< file > file_fut, Func func) noexcept |
| Helper for ensuring a file is closed after func is called. More...
|
|
template<std::invocable< file & > Func>
requires std::is_nothrow_move_constructible_v<Func> |
auto | with_file_close_on_failure (future< file > file_fut, Func func) noexcept |
| Helper for ensuring a file is closed if func fails. More...
|
|
template<typename... A> |
sstring | format (fmt::format_string< A... > fmt, A &&... a) |
|
bool | filesystem_has_good_aio_support (sstring directory, bool verbose=false) |
|
input_stream< char > | make_file_input_stream (file file, uint64_t offset, uint64_t len, file_input_stream_options options={}) |
| Creates an input_stream to read a portion of a file. More...
|
|
input_stream< char > | make_file_input_stream (file file, uint64_t offset, file_input_stream_options={}) |
| Create an input_stream for a given file, reading starting at a given position of the given file, with the specified options. More...
|
|
input_stream< char > | make_file_input_stream (file file, file_input_stream_options={}) |
|
future< output_stream< char > > | make_file_output_stream (file file, uint64_t buffer_size=8192) noexcept |
|
future< output_stream< char > > | make_file_output_stream (file file, file_output_stream_options options) noexcept |
|
future< data_sink > | make_file_data_sink (file, file_output_stream_options) noexcept |
|
template<typename T = void, typename... A> |
future< T > | make_ready_future (A &&... value) noexcept |
| Creates a future in an available, value state. More...
|
|
template<typename T > |
future< std::remove_cv_t< std::remove_reference_t< T > > > | as_ready_future (T &&v) noexcept |
| Returns a ready future that is already resolved.
|
|
template<typename T = void> |
future< T > | make_exception_future (std::exception_ptr &&value) noexcept |
| Creates a future in an available, failed state. More...
|
|
template<typename T = void, typename Exception > |
future< T > | make_exception_future (Exception &&ex) noexcept |
| Creates a future in an available, failed state. More...
|
|
template<typename T = void> |
future< T > | make_exception_future (const std::exception_ptr &ex) noexcept |
|
template<typename T = void> |
future< T > | make_exception_future (std::exception_ptr &ex) noexcept |
|
template<typename T = void> |
future< T > | make_exception_future (const std::exception_ptr &&ex) noexcept |
|
template<typename T = void> |
future< T > | current_exception_as_future () noexcept |
| Returns std::current_exception() wrapped in a future. More...
|
|
template future< void > | current_exception_as_future () noexcept |
|
void | report_failed_future (future_state_base::any &&state) noexcept |
|
template<typename Func , typename... Args> |
auto | futurize_invoke (Func &&func, Args &&... args) noexcept |
|
template<typename Func , typename... Args> |
auto | futurize_apply (Func &&func, std::tuple< Args... > &&args) noexcept |
|
void | log_exception_trace () noexcept |
|
template<typename T , typename Exception > |
future< T > | make_exception_future_with_backtrace (Exception &&ex) noexcept |
|
void | set_idle_cpu_handler (idle_cpu_handler &&handler) |
|
template<typename CharType > |
future | copy (input_stream< CharType > &, output_stream< CharType > &) |
| copy all the content from the input stream to the output stream
|
|
template future | copy< char > (input_stream< char > &, output_stream< char > &) |
|
template<typename AsyncAction > |
future | repeat (const AsyncAction &action) noexcept=delete |
|
template<typename AsyncAction > |
future | repeat (AsyncAction &action) noexcept=delete |
|
template<typename AsyncAction >
requires std::is_invocable_r_v<stop_iteration, AsyncAction> || std::is_invocable_r_v<future<stop_iteration>, AsyncAction> |
future | repeat (AsyncAction &&action) noexcept |
|
template<typename AsyncAction >
requires requires (AsyncAction aa) { bool(futurize_invoke(aa).get()); futurize_invoke(aa).get().value(); } |
repeat_until_value_return_type< AsyncAction > | repeat_until_value (AsyncAction action) noexcept |
|
template<typename AsyncAction , typename StopCondition >
requires std::is_invocable_r_v<bool, StopCondition> && std::is_invocable_r_v<future<>, AsyncAction> |
future | do_until (StopCondition stop_cond, AsyncAction action) noexcept |
|
template<typename AsyncAction >
requires std::is_invocable_r_v<future<>, AsyncAction> |
future | keep_doing (AsyncAction action) noexcept |
|
template<typename Iterator , typename Sentinel , typename AsyncAction >
requires ( requires (Iterator i, AsyncAction aa) { { futurize_invoke(aa, *i) } -> std::same_as<future<>>; } && (std::same_as<Sentinel, Iterator> || std::sentinel_for<Sentinel, Iterator>) ) |
future | do_for_each (Iterator begin, Sentinel end, AsyncAction action) noexcept |
| Call a function for each item in a range, sequentially (iterator version). More...
|
|
template<typename Range , typename AsyncAction >
requires requires (Range c, AsyncAction aa) { { futurize_invoke(aa, *std::begin(c)) } -> std::same_as<future<>>; std::end(c); } |
future | do_for_each (Range &c, AsyncAction action) noexcept |
| Call a function for each item in a range, sequentially (range version). More...
|
|
template<typename Iterator , typename Sentinel , typename Func >
requires (requires (Func f, Iterator i) { { f(*i) } -> std::same_as<future<>>; { i++ }; } && (std::same_as<Sentinel, Iterator> || std::sentinel_for<Sentinel, Iterator>)) |
future | parallel_for_each (Iterator begin, Sentinel end, Func &&func) noexcept |
| Run tasks in parallel (iterator version). More...
|
|
template<typename Range , typename Func >
requires requires (Func f, Range r) { { f(*std::begin(r)) } -> std::same_as<future<>>; std::end(r); } |
future | parallel_for_each (Range &&range, Func &&func) noexcept |
|
template<typename Iterator , typename Sentinel , typename Func >
requires (requires (Func f, Iterator i) { { f(*i) } -> std::same_as<future<>>; { ++i }; } && (std::same_as<Sentinel, Iterator> || std::sentinel_for<Sentinel, Iterator>) ) |
future | max_concurrent_for_each (Iterator begin, Sentinel end, size_t max_concurrent, Func &&func) noexcept |
|
template<typename Range , typename Func >
requires requires (Func f, Range r) { { f(*std::begin(r)) } -> std::same_as<future<>>; std::end(r); } |
future | max_concurrent_for_each (Range &&range, size_t max_concurrent, Func &&func) noexcept |
|
template<typename Func > |
lambda_task< Func > * | make_task (Func &&func) noexcept |
|
template<typename Func > |
lambda_task< Func > * | make_task (scheduling_group sg, Func &&func) noexcept |
|
template<typename Iterator , typename Mapper , typename Reducer >
requires requires (Iterator i, Mapper mapper, Reducer reduce) { *i++; { i != i } -> std::convertible_to<bool>; mapper(*i); reduce(futurize_invoke(mapper, *i).get()); } |
auto | map_reduce (Iterator begin, Iterator end, Mapper &&mapper, Reducer &&r) -> typename reducer_traits< Reducer >::future_type |
|
template<typename Iterator , typename Mapper , typename Initial , typename Reduce >
requires requires (Iterator i, Mapper mapper, Initial initial, Reduce reduce) { *i++; { i != i} -> std::convertible_to<bool>; mapper(*i); requires is_future<decltype(mapper(*i))>::value; { reduce(std::move(initial), mapper(*i).get()) } -> std::convertible_to<Initial>; } |
future< Initial > | map_reduce (Iterator begin, Iterator end, Mapper &&mapper, Initial initial, Reduce reduce) |
|
template<typename Range , typename Mapper , typename Initial , typename Reduce >
requires requires (Range range, Mapper mapper, Initial initial, Reduce reduce) { std::begin(range); std::end(range); mapper(*std::begin(range)); requires is_future<std::remove_reference_t<decltype(mapper(*std::begin(range)))>>::value; { reduce(std::move(initial), mapper(*std::begin(range)).get()) } -> std::convertible_to<Initial>; } |
future< Initial > | map_reduce (Range &&range, Mapper &&mapper, Initial initial, Reduce reduce) |
|
bool | set_abort_on_internal_error (bool do_abort) noexcept |
|
void | on_internal_error (logger &logger, std::string_view reason) |
|
void | on_internal_error (logger &logger, std::exception_ptr ex) |
|
void | on_internal_error_noexcept (logger &logger, std::string_view reason) noexcept |
|
void | on_fatal_internal_error (logger &logger, std::string_view reason) noexcept |
|
template<typename CharType > |
temporary_buffer< CharType > | make_temporary_buffer (std::pmr::polymorphic_allocator< CharType > *allocator, std::size_t size) |
|
void | throw_system_error_on (bool condition, const char *what_arg="") |
|
template<typename T > |
void | throw_kernel_error (T r) |
|
template<typename T > |
void | throw_pthread_error (T r) |
|
mmap_area | mmap_anonymous (void *addr, size_t length, int prot, int flags) |
|
sigset_t | make_sigset_mask (int signo) |
|
sigset_t | make_full_sigset_mask () |
|
sigset_t | make_empty_sigset_mask () |
|
void | pin_this_thread (unsigned cpu_id) |
|
std::set< unsigned > | get_current_cpuset () |
|
bool | need_preempt () noexcept |
|
template<typename T , int LOC = 3> |
void | prefetch (T *ptr) |
|
template<typename Iterator , int LOC = 3> |
void | prefetch (Iterator begin, Iterator end) |
|
template<size_t C, typename T , int LOC = 3> |
void | prefetch_n (T **pptr) |
|
template<size_t L, int LOC = 3> |
void | prefetch (void *ptr) |
|
template<size_t L, typename Iterator , int LOC = 3> |
void | prefetch_n (Iterator begin, Iterator end) |
|
template<size_t L, size_t C, typename T , int LOC = 3> |
void | prefetch_n (T **pptr) |
|
template<typename T , int LOC = 3> |
void | prefetchw (T *ptr) |
|
template<typename Iterator , int LOC = 3> |
void | prefetchw_n (Iterator begin, Iterator end) |
|
template<size_t C, typename T , int LOC = 3> |
void | prefetchw_n (T **pptr) |
|
template<size_t L, int LOC = 3> |
void | prefetchw (void *ptr) |
|
template<size_t L, typename Iterator , int LOC = 3> |
void | prefetchw_n (Iterator begin, Iterator end) |
|
template<size_t L, size_t C, typename T , int LOC = 3> |
void | prefetchw_n (T **pptr) |
|
template<typename... A> |
std::ostream & | fprint (std::ostream &os, const char *fmt, A &&... a) |
|
template<typename... A> |
void | print (const char *fmt, A &&... a) |
|
template<typename... A> |
std::string | sprint (const char *fmt, A &&... a) |
|
template<typename... A> |
std::string | sprint (const sstring &fmt, A &&... a) |
|
template<typename Iterator > |
std::string | format_separated (Iterator b, Iterator e, const char *sep=", ") |
|
template<typename TimePoint > |
usecfmt_wrapper< TimePoint > | usecfmt (TimePoint tp) |
|
template<typename Clock , typename Rep , typename Period > |
std::ostream & | operator<< (std::ostream &os, usecfmt_wrapper< std::chrono::time_point< Clock, std::chrono::duration< Rep, Period > > > tp) |
|
template<typename... A> |
void | log (A &&... a) |
|
template<typename... A> |
std::ostream & | fmt_print (std::ostream &os, const char *format, A &&... a) |
|
void | trim_trailing_spaces_and_tabs (sstring &str) |
|
reactor & | engine () |
|
bool | engine_is_ready () |
|
int | hrtimer_signal () |
|
void | report_exception (std::string_view message, std::exception_ptr) noexcept |
|
cpu_set_t | cpuid_to_cpuset (unsigned cpuid) |
|
constexpr unsigned | max_scheduling_groups () |
|
future< scheduling_group > | create_scheduling_group (sstring name, float shares) noexcept |
|
future< scheduling_group > | create_scheduling_group (sstring name, sstring shortname, float shares) noexcept |
|
future | destroy_scheduling_group (scheduling_group sg) noexcept |
|
future | rename_scheduling_group (scheduling_group sg, sstring new_name) noexcept |
|
future | rename_scheduling_group (scheduling_group sg, sstring new_name, sstring new_shortname) noexcept |
|
template<typename T , typename... ConstructorArgs> |
scheduling_group_key_config | make_scheduling_group_key_config (ConstructorArgs... args) |
|
future< scheduling_group_key > | scheduling_group_key_create (scheduling_group_key_config cfg) noexcept |
|
template<typename T > |
T & | scheduling_group_get_specific (scheduling_group sg, scheduling_group_key key) |
|
scheduling_group | current_scheduling_group () noexcept |
| Returns the current scheduling group.
|
|
scheduling_group | default_scheduling_group () noexcept |
|
template<typename T > |
T & | scheduling_group_get_specific (scheduling_group_key key) noexcept |
|
template<typename SpecificValType , typename Mapper , typename Reducer , typename Initial >
requires requires(SpecificValType specific_val, Mapper mapper, Reducer reducer, Initial initial) { {reducer(initial, mapper(specific_val))} -> std::convertible_to<Initial>; } |
future< typename function_traits< Reducer >::return_type > | map_reduce_scheduling_group_specific (Mapper mapper, Reducer reducer, Initial initial_val, scheduling_group_key key) |
|
template<typename SpecificValType , typename Reducer , typename Initial >
requires requires(SpecificValType specific_val, Reducer reducer, Initial initial) { {reducer(initial, specific_val)} -> std::convertible_to<Initial>; } |
future< typename function_traits< Reducer >::return_type > | reduce_scheduling_group_specific (Reducer reducer, Initial initial_val, scheduling_group_key key) |
|
server_socket | listen (socket_address sa) |
|
server_socket | listen (socket_address sa, listen_options opts) |
|
future< connected_socket > | connect (socket_address sa) |
|
future< connected_socket > | connect (socket_address sa, socket_address local, transport proto) |
|
socket | make_socket () |
|
net::udp_channel | make_udp_channel () |
|
net::udp_channel | make_udp_channel (const socket_address &local) |
|
net::datagram_channel | make_unbound_datagram_channel (sa_family_t family) |
|
net::datagram_channel | make_bound_datagram_channel (const socket_address &local) |
|
future | check_direct_io_support (std::string_view path) noexcept |
|
future | make_directory (std::string_view name, file_permissions permissions=file_permissions::default_dir_permissions) noexcept |
|
future | touch_directory (std::string_view name, file_permissions permissions=file_permissions::default_dir_permissions) noexcept |
|
future | recursive_touch_directory (std::string_view name, file_permissions permissions=file_permissions::default_dir_permissions) noexcept |
|
future | sync_directory (std::string_view name) noexcept |
|
future | remove_file (std::string_view name) noexcept |
|
future | rename_file (std::string_view old_name, std::string_view new_name) noexcept |
|
future< stat_data > | file_stat (std::string_view name, follow_symlink fs=follow_symlink::yes) noexcept |
|
future< std::optional< struct group_details > > | getgrnam (std::string_view name) |
|
future | chown (std::string_view filepath, uid_t owner, gid_t group) |
|
future< uint64_t > | file_size (std::string_view name) noexcept |
|
future< bool > | file_accessible (std::string_view name, access_flags flags) noexcept |
|
future< bool > | file_exists (std::string_view name) noexcept |
|
future< std::optional< directory_entry_type > > | file_type (std::string_view name, follow_symlink follow=follow_symlink::yes) noexcept |
|
future | link_file (std::string_view oldpath, std::string_view newpath) noexcept |
|
future | chmod (std::string_view name, file_permissions permissions) noexcept |
|
future< fs_type > | file_system_at (std::string_view name) noexcept |
|
future< uint64_t > | fs_avail (std::string_view name) noexcept |
|
future< uint64_t > | fs_free (std::string_view name) noexcept |
|
template<typename ExceptionFactory , typename Clock = typename timer<>::clock> |
semaphore_units< ExceptionFactory, Clock > | consume_units (basic_semaphore< ExceptionFactory, Clock > &sem, size_t units) noexcept |
| Consume units from semaphore temporarily. More...
|
|
shard_id | this_shard_id () noexcept |
| Returns shard_id of the of the current shard.
|
|
template<std::invocable Func>
requires (!std::is_nothrow_move_constructible_v<Func>) |
futurize_t< std::invoke_result_t< Func > > | with_shared (shared_mutex &sm, Func &&func) noexcept |
|
template<std::invocable Func>
requires (!std::is_nothrow_move_constructible_v<Func>) |
futurize_t< std::invoke_result_t< Func > > | with_lock (shared_mutex &sm, Func &&func) noexcept |
|
template<internal::FutureBasicSharedLockable T> |
future< std::shared_lock< T > > | get_shared_lock (T &t) |
| Construct a RAII-based shared lock corresponding to a given object. More...
|
|
template<internal::FutureBasicLockable T> |
future< std::unique_lock< T > > | get_unique_lock (T &t) |
| Construct a RAII-based unique lock corresponding to a given object. More...
|
|
template<typename T , typename... A> |
lw_shared_ptr< T > | make_lw_shared (A &&... a) |
|
template<typename T > |
lw_shared_ptr< T > | make_lw_shared (T &&a) |
|
template<typename T > |
lw_shared_ptr< T > | make_lw_shared (T &a) |
|
template<typename T , typename... A> |
shared_ptr< T > | make_shared (A &&... a) |
|
template<typename T > |
shared_ptr< T > | make_shared (T &&a) |
|
template<typename T , typename U > |
shared_ptr< T > | static_pointer_cast (const shared_ptr< U > &p) |
|
template<typename T , typename U > |
shared_ptr< T > | dynamic_pointer_cast (const shared_ptr< U > &p) |
|
template<typename T , typename U > |
shared_ptr< T > | const_pointer_cast (const shared_ptr< U > &p) |
|
template<typename T > |
std::ostream & | operator<< (std::ostream &out, const lw_shared_ptr< T > &p) |
|
template<typename T , typename U > |
bool | operator== (const shared_ptr< T > &x, const shared_ptr< U > &y) |
|
template<typename T > |
bool | operator== (const shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator== (std::nullptr_t, const shared_ptr< T > &y) |
|
template<typename T > |
bool | operator== (const lw_shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator== (std::nullptr_t, const lw_shared_ptr< T > &y) |
|
template<typename T , typename U > |
bool | operator!= (const shared_ptr< T > &x, const shared_ptr< U > &y) |
|
template<typename T > |
bool | operator!= (const shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator!= (std::nullptr_t, const shared_ptr< T > &y) |
|
template<typename T > |
bool | operator!= (const lw_shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator!= (std::nullptr_t, const lw_shared_ptr< T > &y) |
|
template<typename T , typename U > |
bool | operator< (const shared_ptr< T > &x, const shared_ptr< U > &y) |
|
template<typename T > |
bool | operator< (const shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator< (std::nullptr_t, const shared_ptr< T > &y) |
|
template<typename T , typename U > |
bool | operator<= (const shared_ptr< T > &x, const shared_ptr< U > &y) |
|
template<typename T > |
bool | operator<= (const shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator<= (std::nullptr_t, const shared_ptr< T > &y) |
|
template<typename T , typename U > |
bool | operator> (const shared_ptr< T > &x, const shared_ptr< U > &y) |
|
template<typename T > |
bool | operator> (const shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator> (std::nullptr_t, const shared_ptr< T > &y) |
|
template<typename T , typename U > |
bool | operator>= (const shared_ptr< T > &x, const shared_ptr< U > &y) |
|
template<typename T > |
bool | operator>= (const shared_ptr< T > &x, std::nullptr_t) |
|
template<typename T > |
bool | operator>= (std::nullptr_t, const shared_ptr< T > &y) |
|
template<typename T > |
std::ostream & | operator<< (std::ostream &out, const shared_ptr< T > &p) |
|
void | handle_signal (int signo, noncopyable_function< void()> &&handler, bool once=false) |
| Sets a signal handler for the specified signal. More...
|
|
template<typename Stream , typename StreamVisitor , typename = std::enable_if_t<Stream::has_with_stream::value>> |
decltype(auto) | with_serialized_stream (Stream &stream, StreamVisitor &&visitor) |
|
template<typename Stream , typename StreamVisitor , typename = std::enable_if_t<!Stream::has_with_stream::value>, typename = void> |
decltype(auto) | with_serialized_stream (Stream &stream, StreamVisitor &&visitor) |
|
template<typename Clock = steady_clock_type, typename Rep , typename Period > |
future | sleep (std::chrono::duration< Rep, Period > dur) |
|
template<typename Clock = steady_clock_type> |
future | sleep_abortable (typename Clock::duration dur) |
|
template future | sleep_abortable< steady_clock_type > (typename steady_clock_type::duration) |
|
template future | sleep_abortable< lowres_clock > (typename lowres_clock::duration) |
|
template<typename Clock = steady_clock_type> |
future | sleep_abortable (typename Clock::duration dur, abort_source &as) |
|
template future | sleep_abortable< steady_clock_type > (typename steady_clock_type::duration, abort_source &) |
|
template future | sleep_abortable< lowres_clock > (typename lowres_clock::duration, abort_source &) |
|
template future | sleep_abortable< manual_clock > (typename manual_clock::duration, abort_source &) |
|
smp_service_group | default_smp_service_group () noexcept |
|
future< smp_service_group > | create_smp_service_group (smp_service_group_config ssgc) noexcept |
|
future | destroy_smp_service_group (smp_service_group ssg) noexcept |
|
void | init_default_smp_service_group (shard_id cpu) |
|
smp_service_group_semaphore & | get_smp_service_groups_semaphore (unsigned ssg_id, shard_id t) noexcept |
|
template<typename string_type = sstring> |
string_type | uninitialized_string (size_t size) |
|
template<typename char_type , typename size_type , size_type Max, size_type N, bool NulTerminate> |
basic_sstring< char_type, size_type, Max, NulTerminate > | operator+ (const char(&s)[N], const basic_sstring< char_type, size_type, Max, NulTerminate > &t) |
|
template<typename T > |
static size_t constexpr | str_len (const T &s) |
|
template<typename char_type , typename size_type , size_type max_size> |
void | swap (basic_sstring< char_type, size_type, max_size > &x, basic_sstring< char_type, size_type, max_size > &y) noexcept |
|
template<typename char_type , typename size_type , size_type max_size, bool NulTerminate, typename char_traits > |
std::basic_ostream< char_type, char_traits > & | operator<< (std::basic_ostream< char_type, char_traits > &os, const basic_sstring< char_type, size_type, max_size, NulTerminate > &s) |
|
template<typename char_type , typename size_type , size_type max_size, bool NulTerminate, typename char_traits > |
std::basic_istream< char_type, char_traits > & | operator>> (std::basic_istream< char_type, char_traits > &is, basic_sstring< char_type, size_type, max_size, NulTerminate > &s) |
|
template<typename T > |
static void | copy_str_to (char *&dst, const T &s) |
|
template<typename String = sstring, typename... Args> |
static String | make_sstring (Args &&... args) |
|
template<typename string_type = sstring, typename T > |
string_type | to_sstring (T value) |
|
void | schedule (task *t) noexcept |
|
void | schedule_checked (task *t) noexcept |
|
void | schedule_urgent (task *t) noexcept |
|
template<typename Func , typename... Args> |
futurize_t< std::invoke_result_t< Func, Args... > > | async (thread_attributes attr, Func &&func, Args &&... args) noexcept |
|
template<typename Func , typename... Args> |
futurize_t< std::invoke_result_t< Func, Args... > > | async (Func &&func, Args &&... args) noexcept |
|
template<typename T , typename Alloc > |
void | transfer_pass1 (Alloc &a, T *from, T *to, std::enable_if_t< std::is_nothrow_move_constructible_v< T > > *=nullptr) |
|
template<typename T , typename Alloc > |
void | transfer_pass2 (Alloc &, T *, T *, std::enable_if_t< std::is_nothrow_move_constructible_v< T > > *=nullptr) |
|
template<typename T , typename Alloc > |
void | transfer_pass1 (Alloc &a, T *from, T *to, std::enable_if_t<!std::is_nothrow_move_constructible_v< T > > *=nullptr) |
|
template<typename T , typename Alloc > |
void | transfer_pass2 (Alloc &a, T *from, T *, std::enable_if_t<!std::is_nothrow_move_constructible_v< T > > *=nullptr) |
|
template<typename T > |
struct seastar::unaligned | __attribute__ ((packed)) |
|
template<typename T , typename F > |
auto | unaligned_cast (F *p) noexcept |
|
template<typename T , typename F > |
auto | unaligned_cast (const F *p) noexcept |
|
constexpr size_t | operator""_KiB (unsigned long long n) |
|
constexpr size_t | operator""_MiB (unsigned long long n) |
|
constexpr size_t | operator""_GiB (unsigned long long n) |
|
constexpr size_t | operator""_TiB (unsigned long long n) |
|
template<typename... FutOrFuncs> |
auto | when_all (FutOrFuncs &&... fut_or_funcs) noexcept |
|
template<typename FutureIterator >
requires requires (FutureIterator i) { { *i++ }; requires is_future<std::remove_reference_t<decltype(*i)>>::value; } |
future< std::vector< typename std::iterator_traits< FutureIterator >::value_type > > | when_all (FutureIterator begin, FutureIterator end) noexcept |
|
template<typename... FutOrFuncs> |
auto | when_all_succeed (FutOrFuncs &&... fut_or_funcs) noexcept |
|
template<typename FutureIterator , typename = typename std::iterator_traits<FutureIterator>::value_type>
requires requires (FutureIterator i) { *i++; { i != i } -> std::convertible_to<bool>; requires is_future<std::remove_reference_t<decltype(*i)>>::value; } |
auto | when_all_succeed (FutureIterator begin, FutureIterator end) noexcept |
|
template<typename T > |
auto | when_all_succeed (std::vector< future< T > > &&futures) noexcept |
|
template<class FutureIterator >
requires requires (FutureIterator i) { { *i++ }; requires is_future<std::remove_reference_t<decltype(*i)>>::value; } |
auto | when_any (FutureIterator begin, FutureIterator end) noexcept -> future< when_any_result< std::vector< std::decay_t< typename std::iterator_traits< FutureIterator >::value_type > > > > |
|
template<class... FutOrFuncs> |
auto | when_any (FutOrFuncs &&... fut_or_funcs) noexcept |
|
template<typename Func , typename... Args>
requires std::is_nothrow_move_constructible_v<Func> |
auto | with_scheduling_group (scheduling_group sg, Func func, Args &&... args) noexcept |
| run a callable (with some arbitrary arguments) in a scheduling group More...
|
|
template<typename ExceptionFactory = default_timeout_exception_factory, typename Clock , typename Duration , typename... T> |
future< T... > | with_timeout (std::chrono::time_point< Clock, Duration > timeout, future< T... > f) |
| Wait for either a future, or a timeout, whichever comes first. More...
|
|
auto | operator co_await (coroutine::exception ex) noexcept |
|
bool | is_ip_unspecified (const ipv4_addr &addr) noexcept |
|
bool | is_port_unspecified (const ipv4_addr &addr) noexcept |
|
socket_address | make_ipv4_address (const ipv4_addr &addr) noexcept |
|
socket_address | make_ipv4_address (uint32_t ip, uint16_t port) noexcept |
|
uint64_t | ntohq (uint64_t v) |
|
uint64_t | htonq (uint64_t v) |
|
std::ostream & | operator<< (std::ostream &, const socket_address &) |
|
std::ostream & | operator<< (std::ostream &, const ipv4_addr &) |
|
std::ostream & | operator<< (std::ostream &, const ipv6_addr &) |
|
bool | operator== (const ipv4_addr &lhs, const ipv4_addr &rhs) noexcept |
|
template<typename T > |
uint32_t | toeplitz_hash (rss_key_type key, const T &data) |
|
std::ostream & | operator<< (std::ostream &, const unix_domain_addr &) |
|
bool | operator== (const frame &a, const frame &b) noexcept |
|
frame | decorate (uintptr_t addr) noexcept |
|
template<typename Func > |
void | backtrace (Func &&func) noexcept(noexcept(func(frame()))) |
|
saved_backtrace | current_backtrace () noexcept |
|
tasktrace | current_tasktrace () noexcept |
|
simple_backtrace | current_backtrace_tasklocal () noexcept |
|
std::ostream & | operator<< (std::ostream &out, const tasktrace &b) |
|
template<class Exc , typename... Args> |
std::exception_ptr | make_backtraced_exception_ptr (Args &&... args) |
|
template<class Exc , typename... Args> |
void | throw_with_backtrace (Args &&... args) |
|
template<closeable Closeable, std::invocable< Closeable & > Func>
requires std::is_nothrow_move_constructible_v<Closeable> && std::is_nothrow_move_constructible_v<Func> |
futurize_t< std::invoke_result_t< Func, Closeable & > > | with_closeable (Closeable &&obj, Func func) noexcept |
|
template<stoppable Stoppable, std::invocable< Stoppable & > Func>
requires std::is_nothrow_move_constructible_v<Stoppable> && std::is_nothrow_move_constructible_v<Func> |
futurize_t< std::invoke_result_t< Func, Stoppable & > > | with_stoppable (Stoppable &&obj, Func func) noexcept |
|
size_t | parse_memory_size (std::string_view s) |
|
static std::vector< char > | string2vector (std::string_view str) |
|
template<typename Func >
requires deferrable_action<Func> |
deferred_action< Func > | defer (Func &&func) |
|
std::filesystem::filesystem_error | make_filesystem_error (const std::string &what, std::filesystem::path path, int error) |
| make a filesystem_error for system calls with a single file operand. More...
|
|
std::filesystem::filesystem_error | make_filesystem_error (const std::string &what, std::filesystem::path path1, std::filesystem::path path2, int error) |
| make a filesystem_error for system calls with two file operands. More...
|
|
future | recursive_remove_directory (std::filesystem::path path) noexcept |
|
template<typename Function , typename State > |
function_input_iterator< Function, State > | make_function_input_iterator (Function func, State state) |
|
template<typename Function , typename State > |
function_input_iterator< Function, State > | make_function_input_iterator (Function &&func) |
|
future | now () |
| Returns a ready future.
|
|
future | yield () noexcept |
| Returns a future which is not ready but is scheduled to resolve soon. More...
|
|
future | maybe_yield () noexcept |
|
future | check_for_io_immediately () noexcept |
|
future | later () noexcept |
| Returns a future which is not ready but is scheduled to resolve soon. More...
|
|
template<typename Func > |
lazy_eval< Func > | value_of (Func &&func) |
|
template<typename T > |
lazy_deref_wrapper< T > | lazy_deref (const T &p) |
|
std::ostream & | operator<< (std::ostream &out, log_level level) |
|
std::istream & | operator>> (std::istream &in, log_level &level) |
|
void | print_safe (const char *str, size_t len) noexcept |
|
void | print_safe (const char *str) noexcept |
|
template<typename Integral , char Padding = ' '>
requires std::integral<Integral> |
char * | convert_hex_safe (char *buf, size_t bufsz, Integral n) noexcept |
|
template<typename Integral >
requires std::integral<Integral> |
void | convert_zero_padded_hex_safe (char *buf, size_t bufsz, Integral n) noexcept |
|
template<typename Integral >
requires std::unsigned_integral<Integral> |
void | print_zero_padded_hex_safe (Integral n) noexcept |
|
template<typename Integral >
requires std::unsigned_integral<Integral> |
size_t | convert_decimal_safe (char *buf, size_t bufsz, Integral n) noexcept |
|
template<typename Integral > |
void | print_decimal_safe (Integral n) noexcept |
|
sstring | read_first_line (std::filesystem::path sys_file) |
|
template<typename Type > |
Type | read_first_line_as (std::filesystem::path sys_file) |
|
template<typename T > |
reference_wrapper< T > | ref (T &object) noexcept |
| Wraps reference in a reference_wrapper.
|
|
template<typename T > |
reference_wrapper< const T > | cref (const T &object) noexcept |
| Wraps constant reference in a reference_wrapper.
|
|
const std::filesystem::path & | default_tmpdir () |
|
void | set_default_tmpdir (std::filesystem::path) |
|
future< tmp_file > | make_tmp_file (std::filesystem::path path_template=default_tmpdir(), open_flags oflags=open_flags::rw, file_open_options options={}) noexcept |
|
future< tmp_dir > | make_tmp_dir (std::filesystem::path path_template=default_tmpdir(), file_permissions create_permissions=file_permissions::default_dir_permissions) noexcept |
|
template<typename Iterator , typename Func > |
transform_iterator< Iterator, Func > | make_transform_iterator (Iterator i, Func f) |
|
template<template< typename > class FilterClass, typename... Elements> |
auto | tuple_filter_by_type (const std::tuple< Elements... > &t) |
|
template<template< typename > class FilterClass, typename... Elements> |
auto | tuple_filter_by_type (std::tuple< Elements... > &&t) |
|
template<typename Function , typename... Elements> |
auto | tuple_map (const std::tuple< Elements... > &t, Function &&f) |
|
template<typename Function , typename... Elements> |
auto | tuple_map (std::tuple< Elements... > &&t, Function &&f) |
|
template<typename Function , typename... Elements> |
void | tuple_for_each (const std::tuple< Elements... > &t, Function &&f) |
|
template<typename Function , typename... Elements> |
void | tuple_for_each (std::tuple< Elements... > &t, Function &&f) |
|
template<typename Function , typename... Elements> |
void | tuple_for_each (std::tuple< Elements... > &&t, Function &&f) |
|
template<typename... Args> |
auto | make_visitor (Args &&... args) |
|
template<typename Variant , typename... Args> |
auto | visit (Variant &&variant, Args &&... args) |
|
template<typename... Args> |
internal::castable_variant< Args... > | variant_cast (std::variant< Args... > &&var) |
|
template<typename... Args> |
internal::castable_variant< Args... > | variant_cast (const std::variant< Args... > &var) |
|