xref: /openbmc/sdbusplus/include/sdbusplus/async/stdexec/__detail/__p2300.hpp (revision 36137e09614746b13603b5fbae79e6f70819c46b)

/*
 * Copyright (c) 2022 NVIDIA Corporation
 *
 * Licensed under the Apache License Version 2.0 with LLVM Exceptions
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *   https://llvm.org/LICENSE.txt
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once

// Internal header, do not include directly

#ifdef STDEXEC_DISABLE_STD_DEPRECATIONS
#define STDEXEC_STD_DEPRECATED
#else
#define STDEXEC_STD_DEPRECATED                                                 \
    [[deprecated(                                                              \
        "Please access this entity in the ::stdexec:: namespace. Define "      \
        "STDEXEC_DISABLE_STD_DEPRECATIONS to silence this "                    \
        "warning.")]]
#endif

namespace std
{
//////////////////////////////////////////////////////////////////////////////
// <functional>
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::tag_invoke_t tag_invoke{};

template <class _Tag, class... _Ts>
using tag_invoke_result STDEXEC_STD_DEPRECATED =
    stdexec::tag_invoke_result<_Tag, _Ts...>;

template <class _Tag, class... _Ts>
using tag_invoke_result_t STDEXEC_STD_DEPRECATED =
    stdexec::tag_invoke_result_t<_Tag, _Ts...>;

template <class _Tag, class... _Ts>
concept tag_invocable /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::tag_invocable<_Tag, _Ts...>;

template <class _Tag, class... _Ts>
concept nothrow_tag_invocable /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::nothrow_tag_invocable<_Tag, _Ts...>;

template <auto& _Tag>
using tag_t STDEXEC_STD_DEPRECATED = stdexec::tag_t<_Tag>;

//////////////////////////////////////////////////////////////////////////////
// <stop_token>
template <class _Token>
concept stoppable_token /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::stoppable_token<_Token>;

template <class _Token, typename _Callback, typename _Initializer = _Callback>
concept stoppable_token_for /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::stoppable_token_for<_Token, _Callback, _Initializer>;

template <class _Token>
concept unstoppable_token /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::unstoppable_token<_Token>;

using never_stop_token STDEXEC_STD_DEPRECATED = stdexec::never_stop_token;
using in_place_stop_token STDEXEC_STD_DEPRECATED = stdexec::in_place_stop_token;
using in_place_stop_source STDEXEC_STD_DEPRECATED =
    stdexec::in_place_stop_source;

template <class _Callback>
using in_place_stop_callback STDEXEC_STD_DEPRECATED =
    stdexec::in_place_stop_callback<_Callback>;

//////////////////////////////////////////////////////////////////////////////
// <execution>
namespace execution
{
// [exec.queries], general queries
using get_scheduler_t STDEXEC_STD_DEPRECATED = stdexec::get_scheduler_t;
using get_delegatee_scheduler_t STDEXEC_STD_DEPRECATED =
    stdexec::get_delegatee_scheduler_t;
using get_allocator_t STDEXEC_STD_DEPRECATED = stdexec::get_allocator_t;
using get_stop_token_t STDEXEC_STD_DEPRECATED = stdexec::get_stop_token_t;
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::get_scheduler_t get_scheduler{};
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::get_delegatee_scheduler_t get_delegatee_scheduler{};
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::get_allocator_t get_allocator{};
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::get_stop_token_t get_stop_token{};

template <class _StopTokenProvider>
using stop_token_of_t STDEXEC_STD_DEPRECATED =
    stdexec::stop_token_of_t<_StopTokenProvider>;

// [exec.env], execution environments
struct __no_env
{};

using no_env STDEXEC_STD_DEPRECATED = __no_env;
using get_env_t STDEXEC_STD_DEPRECATED = stdexec::get_env_t;
// using forwarding_env_query_t STDEXEC_STD_DEPRECATED =
// stdexec::forwarding_env_query_t; // BUGBUG
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::get_env_t get_env{};
// inline constexpr stdexec::forwarding_env_query_t forwarding_env_query{}; //
// BUGBUG

template <class _EnvProvider>
using env_of_t STDEXEC_STD_DEPRECATED = stdexec::env_of_t<_EnvProvider>;

// [exec.sched], schedulers
template <class _Scheduler>
concept scheduler /*STDEXEC_STD_DEPRECATED*/ = stdexec::scheduler<_Scheduler>;

// [exec.sched_queries], scheduler queries
using forward_progress_guarantee STDEXEC_STD_DEPRECATED =
    stdexec::forward_progress_guarantee;
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::get_forward_progress_guarantee_t
    get_forward_progress_guarantee{};

// [exec.recv], receivers
template <class _Receiver>
concept receiver /*STDEXEC_STD_DEPRECATED*/ = stdexec::receiver<_Receiver>;

template <class _Receiver, class _Completions>
concept receiver_of /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::receiver_of<_Receiver, _Completions>;

using set_value_t STDEXEC_STD_DEPRECATED = stdexec::set_value_t;
using set_error_t STDEXEC_STD_DEPRECATED = stdexec::set_error_t;
using set_stopped_t STDEXEC_STD_DEPRECATED = stdexec::set_stopped_t;
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::set_value_t set_value{};
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::set_error_t set_error{};
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::set_stopped_t set_stopped{};

// [exec.recv_queries], receiver queries
// using stdexec::forwarding_receiver_query_t; // BUGBUG
// using stdexec::forwarding_receiver_query; // BUGBUG

// [exec.op_state], operation states
template <class _OpState>
concept operation_state /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::operation_state<_OpState>;

using start_t STDEXEC_STD_DEPRECATED = stdexec::start_t;
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::start_t start{};

// [exec.snd], senders
template <class _Sender, class _Env = __no_env>
concept sender /*STDEXEC_STD_DEPRECATED*/ = stdexec::sender_in<_Sender, _Env>;

template <class _Sender, class _Receiver>
concept sender_to /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::sender_to<_Sender, _Receiver>;

template <class _Sender, class _SetSig, class _Env = __no_env>
concept sender_of /*STDEXEC_STD_DEPRECATED*/ =
    stdexec::sender_of<_Sender, _SetSig, _Env>;

// [exec.sndtraits], completion signatures
using get_completion_signatures_t STDEXEC_STD_DEPRECATED =
    stdexec::get_completion_signatures_t;
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::get_completion_signatures_t
    get_completion_signatures{};

template <class _Sender, class _Env = __no_env>
using completion_signatures_of_t STDEXEC_STD_DEPRECATED =
    stdexec::completion_signatures_of_t<_Sender, _Env>;

template <class _Env>
struct __dependent_completion_signatures
{};

template <class _Env>
using dependent_completion_signatures STDEXEC_STD_DEPRECATED =
    __dependent_completion_signatures<_Env>;

template <                                                       //
    class _Sender,                                               //
    class _Env = __no_env,                                       //
    template <class...> class _Tuple = stdexec::__decayed_tuple, //
    template <class...> class _Variant = stdexec::__variant>
using value_types_of_t STDEXEC_STD_DEPRECATED =
    stdexec::value_types_of_t<_Sender, _Env, _Tuple, _Variant>;

template <                 //
    class _Sender,         //
    class _Env = __no_env, //
    template <class...> class _Variant = stdexec::__variant>
using error_types_of_t STDEXEC_STD_DEPRECATED =
    stdexec::error_types_of_t<_Sender, _Env, _Variant>;

template <class _Sender, class _Env = __no_env>
STDEXEC_STD_DEPRECATED inline constexpr bool sends_stopped =
    stdexec::sends_stopped<_Sender, _Env>;

// [exec.connect], the connect sender algorithm
using connect_t STDEXEC_STD_DEPRECATED = stdexec::connect_t;
STDEXEC_STD_DEPRECATED
inline constexpr stdexec::connect_t connect{};

template <class _Sender, class _Receiver>
using connect_result_t STDEXEC_STD_DEPRECATED =
    stdexec::connect_result_t<_Sender, _Receiver>;

template <class _Tag>
using get_completion_scheduler_t STDEXEC_STD_DEPRECATED =
    stdexec::get_completion_scheduler_t<_Tag>;

template <class _Tag>
STDEXEC_STD_DEPRECATED inline constexpr stdexec::get_completion_scheduler_t<
    _Tag>
    get_completion_scheduler{};

// [exec.factories], sender factories
using schedule_t STDEXEC_STD_DEPRECATED = stdexec::schedule_t;
using transfer_just_t STDEXEC_STD_DEPRECATED = stdexec::transfer_just_t;
STDEXEC_STD_DEPRECATED
inline constexpr auto just = stdexec::just;
STDEXEC_STD_DEPRECATED
inline constexpr auto just_error = stdexec::just_error;
STDEXEC_STD_DEPRECATED
inline constexpr auto just_stopped = stdexec::just_stopped;
STDEXEC_STD_DEPRECATED
inline constexpr auto schedule = stdexec::schedule;
STDEXEC_STD_DEPRECATED
inline constexpr auto transfer_just = stdexec::transfer_just;
STDEXEC_STD_DEPRECATED
inline constexpr auto read = stdexec::read;

template <class _Scheduler>
using schedule_result_t STDEXEC_STD_DEPRECATED =
    stdexec::schedule_result_t<_Scheduler>;

// [exec.adapt], sender adaptors
template <class _Closure>
using sender_adaptor_closure STDEXEC_STD_DEPRECATED =
    stdexec::sender_adaptor_closure<_Closure>;

using on_t STDEXEC_STD_DEPRECATED = stdexec::on_t;
using transfer_t STDEXEC_STD_DEPRECATED = stdexec::transfer_t;
using schedule_from_t STDEXEC_STD_DEPRECATED = stdexec::schedule_from_t;
using then_t STDEXEC_STD_DEPRECATED = stdexec::then_t;
using upon_error_t STDEXEC_STD_DEPRECATED = stdexec::upon_error_t;
using upon_stopped_t STDEXEC_STD_DEPRECATED = stdexec::upon_stopped_t;
using let_value_t STDEXEC_STD_DEPRECATED = stdexec::let_value_t;
using let_error_t STDEXEC_STD_DEPRECATED = stdexec::let_error_t;
using let_stopped_t STDEXEC_STD_DEPRECATED = stdexec::let_stopped_t;
using bulk_t STDEXEC_STD_DEPRECATED = stdexec::bulk_t;
using split_t STDEXEC_STD_DEPRECATED = stdexec::split_t;
using when_all_t STDEXEC_STD_DEPRECATED = stdexec::when_all_t;
using when_all_with_variant_t STDEXEC_STD_DEPRECATED =
    stdexec::when_all_with_variant_t;
using transfer_when_all_t STDEXEC_STD_DEPRECATED = stdexec::transfer_when_all_t;
using transfer_when_all_with_variant_t STDEXEC_STD_DEPRECATED =
    stdexec::transfer_when_all_with_variant_t;
using into_variant_t STDEXEC_STD_DEPRECATED = stdexec::into_variant_t;
using stopped_as_optional_t STDEXEC_STD_DEPRECATED =
    stdexec::stopped_as_optional_t;
using stopped_as_error_t STDEXEC_STD_DEPRECATED = stdexec::stopped_as_error_t;
using ensure_started_t STDEXEC_STD_DEPRECATED = stdexec::ensure_started_t;

STDEXEC_STD_DEPRECATED
inline constexpr auto on = stdexec::on;
STDEXEC_STD_DEPRECATED
inline constexpr auto transfer = stdexec::transfer;
STDEXEC_STD_DEPRECATED
inline constexpr auto schedule_from = stdexec::schedule_from;
STDEXEC_STD_DEPRECATED
inline constexpr auto then = stdexec::then;
STDEXEC_STD_DEPRECATED
inline constexpr auto upon_error = stdexec::upon_error;
STDEXEC_STD_DEPRECATED
inline constexpr auto upon_stopped = stdexec::upon_stopped;
STDEXEC_STD_DEPRECATED
inline constexpr auto let_value = stdexec::let_value;
STDEXEC_STD_DEPRECATED
inline constexpr auto let_error = stdexec::let_error;
STDEXEC_STD_DEPRECATED
inline constexpr auto let_stopped = stdexec::let_stopped;
STDEXEC_STD_DEPRECATED
inline constexpr auto bulk = stdexec::bulk;
STDEXEC_STD_DEPRECATED
inline constexpr auto split = stdexec::split;
STDEXEC_STD_DEPRECATED
inline constexpr auto when_all = stdexec::when_all;
STDEXEC_STD_DEPRECATED
inline constexpr auto when_all_with_variant = stdexec::when_all_with_variant;
STDEXEC_STD_DEPRECATED
inline constexpr auto transfer_when_all = stdexec::transfer_when_all;
STDEXEC_STD_DEPRECATED
inline constexpr auto transfer_when_all_with_variant =
    stdexec::transfer_when_all_with_variant;
STDEXEC_STD_DEPRECATED
inline constexpr auto into_variant = stdexec::into_variant;
STDEXEC_STD_DEPRECATED
inline constexpr auto stopped_as_optional = stdexec::stopped_as_optional;
STDEXEC_STD_DEPRECATED
inline constexpr auto stopped_as_error = stdexec::stopped_as_error;
STDEXEC_STD_DEPRECATED
inline constexpr auto ensure_started = stdexec::ensure_started;

// [exec.consumers], sender consumers
using start_detached_t STDEXEC_STD_DEPRECATED = stdexec::start_detached_t;
STDEXEC_STD_DEPRECATED
inline constexpr auto start_detached = stdexec::start_detached;

// [exec.utils], sender and receiver utilities
// [exec.utils.rcvr_adptr]
template <class _Derived, class _Base = stdexec::__adaptors::__not_a_receiver>
using receiver_adaptor STDEXEC_STD_DEPRECATED =
    stdexec::receiver_adaptor<_Derived, _Base>;

// [exec.utils.cmplsigs]
template <class... _Sigs>
using completion_signatures STDEXEC_STD_DEPRECATED =
    stdexec::completion_signatures<_Sigs...>;

// [exec.utils.mkcmplsigs]
template <                                          //
    class _Sender,                                  //
    class _Env = __no_env,
    class _Sigs = stdexec::completion_signatures<>, //
    template <class...> class _SetValue =
        stdexec::__compl_sigs::__default_set_value, //
    template <class> class _SetError =
        stdexec::__compl_sigs::__default_set_error, //
    class _SetStopped =
        stdexec::completion_signatures<stdexec::set_stopped_t()>>
using make_completion_signatures STDEXEC_STD_DEPRECATED =
    stdexec::make_completion_signatures<_Sender, _Env, _Sigs, _SetValue,
                                        _SetError, _SetStopped>;

// [exec.ctx], execution contexts
using run_loop STDEXEC_STD_DEPRECATED = stdexec::run_loop;

// [exec.execute], execute
using execute_t STDEXEC_STD_DEPRECATED = stdexec::execute_t;
STDEXEC_STD_DEPRECATED
inline constexpr auto execute = stdexec::execute;

#if !STDEXEC_STD_NO_COROUTINES_
// [exec.as_awaitable]
using as_awaitable_t STDEXEC_STD_DEPRECATED = stdexec::as_awaitable_t;
STDEXEC_STD_DEPRECATED
inline constexpr auto as_awaitable = stdexec::as_awaitable;

// [exec.with_awaitable_senders]
template <class _Promise>
using with_awaitable_senders STDEXEC_STD_DEPRECATED =
    stdexec::with_awaitable_senders<_Promise>;
#endif // !STDEXEC_STD_NO_COROUTINES_
} // namespace execution

namespace this_thread
{
using execute_may_block_caller_t STDEXEC_STD_DEPRECATED =
    stdexec::execute_may_block_caller_t;
using sync_wait_t STDEXEC_STD_DEPRECATED = stdexec::sync_wait_t;
using sync_wait_with_variant_t STDEXEC_STD_DEPRECATED =
    stdexec::sync_wait_with_variant_t;

STDEXEC_STD_DEPRECATED
inline constexpr auto execute_may_block_caller =
    stdexec::execute_may_block_caller;
STDEXEC_STD_DEPRECATED
inline constexpr auto sync_wait = stdexec::sync_wait;
STDEXEC_STD_DEPRECATED
inline constexpr auto sync_wait_with_variant = stdexec::sync_wait_with_variant;
} // namespace this_thread
} // namespace std