/*
 * Copyright (c) 2023 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

#include "__concepts.hpp"
#include "__config.hpp"
#include "__meta.hpp"
#include "__type_traits.hpp"

namespace stdexec
{
struct __none_such;

//////////////////////////////////////////////////////////////////////////////////////////////////
struct default_domain;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __receivers
{
struct set_value_t;
struct set_error_t;
struct set_stopped_t;
} // namespace __receivers

using __receivers::set_error_t;
using __receivers::set_stopped_t;
using __receivers::set_value_t;
extern const set_value_t set_value;
extern const set_error_t set_error;
extern const set_stopped_t set_stopped;

template <class _Tag>
concept __completion_tag =
    __one_of<_Tag, set_value_t, set_error_t, set_stopped_t>;

struct receiver_t;

template <class _Sender>
extern const bool enable_receiver;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __env
{
struct get_env_t;

struct empty_env
{
    using __t = empty_env;
    using __id = empty_env;
};
} // namespace __env

using __env::empty_env;
using __env::get_env_t;
extern const get_env_t get_env;

template <class _EnvProvider>
using env_of_t = __call_result_t<get_env_t, _EnvProvider>;

//////////////////////////////////////////////////////////////////////////////////////////////////
enum class forward_progress_guarantee
{
    concurrent,
    parallel,
    weakly_parallel
};

namespace __queries
{
struct forwarding_query_t;
struct execute_may_block_caller_t;
struct get_forward_progress_guarantee_t;
struct __has_algorithm_customizations_t;
struct get_scheduler_t;
struct get_delegatee_scheduler_t;
struct get_allocator_t;
struct get_stop_token_t;
template <__completion_tag _CPO>
struct get_completion_scheduler_t;
} // namespace __queries

using __queries::__has_algorithm_customizations_t;
using __queries::execute_may_block_caller_t;
using __queries::forwarding_query_t;
using __queries::get_allocator_t;
using __queries::get_completion_scheduler_t;
using __queries::get_delegatee_scheduler_t;
using __queries::get_forward_progress_guarantee_t;
using __queries::get_scheduler_t;
using __queries::get_stop_token_t;

extern const forwarding_query_t forwarding_query;
extern const execute_may_block_caller_t execute_may_block_caller;
extern const __has_algorithm_customizations_t __has_algorithm_customizations;
extern const get_forward_progress_guarantee_t get_forward_progress_guarantee;
extern const get_scheduler_t get_scheduler;
extern const get_delegatee_scheduler_t get_delegatee_scheduler;
extern const get_allocator_t get_allocator;
extern const get_stop_token_t get_stop_token;
template <__completion_tag _CPO>
extern const get_completion_scheduler_t<_CPO> get_completion_scheduler;

template <class _Tp>
using stop_token_of_t = __decay_t<__call_result_t<get_stop_token_t, _Tp>>;

template <class _Sender, class _CPO>
concept __has_completion_scheduler =
    __callable<get_completion_scheduler_t<_CPO>, env_of_t<const _Sender&>>;

template <class _Sender, class _CPO>
using __completion_scheduler_for =
    __call_result_t<get_completion_scheduler_t<_CPO>, env_of_t<const _Sender&>>;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __get_completion_signatures
{
struct get_completion_signatures_t;
}

using __get_completion_signatures::get_completion_signatures_t;
extern const get_completion_signatures_t get_completion_signatures;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __connect
{
struct connect_t;
}

using __connect::connect_t;
extern const connect_t connect;

template <class _Sender, class _Receiver>
using connect_result_t = __call_result_t<connect_t, _Sender, _Receiver>;

template <class _Sender, class _Receiver>
concept __nothrow_connectable =
    __nothrow_callable<connect_t, _Sender, _Receiver>;

struct sender_t;

template <class _Sender>
extern const bool enable_sender;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __start
{
struct start_t;
}

using __start::start_t;
extern const start_t start;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __schedule
{
struct schedule_t;
}

using __schedule::schedule_t;
extern const schedule_t schedule;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __as_awaitable
{
struct as_awaitable_t;
}

using __as_awaitable::as_awaitable_t;
extern const as_awaitable_t as_awaitable;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __transfer
{
struct transfer_t;
}

using __transfer::transfer_t;
extern const transfer_t transfer;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __transfer_just
{
struct transfer_just_t;
}

using __transfer_just::transfer_just_t;
extern const transfer_just_t transfer_just;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __bulk
{
struct bulk_t;
}

using __bulk::bulk_t;
extern const bulk_t bulk;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __split
{
struct split_t;
struct __split_t;
} // namespace __split

using __split::split_t;
extern const split_t split;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __ensure_started
{
struct ensure_started_t;
struct __ensure_started_t;
} // namespace __ensure_started

using __ensure_started::ensure_started_t;
extern const ensure_started_t ensure_started;

//////////////////////////////////////////////////////////////////////////////////////////////////
namespace __on_v2
{
struct on_t;
}

namespace v2
{
using __on_v2::on_t;
}

namespace __detail
{
struct __sexpr_apply_t;
}

using __detail::__sexpr_apply_t;
extern const __sexpr_apply_t __sexpr_apply;
} // namespace stdexec

template <class...>
[[deprecated]] void print()
{}

template <class>
struct undef;