diagnostics.hpp

Go to the documentation of this file.

#ifndef KOKKOS_EXECUTION_IMPL_DIAGNOSTICS_HPP
#define KOKKOS_EXECUTION_IMPL_DIAGNOSTICS_HPP

 
#include "kokkos-execution/stdexec.hpp"
 
namespace Kokkos::Execution::Impl {

template <typename T>
struct WITH_OPSTATE;

template <typename... T>
struct WITH_CHILDREN_ERRORS;

template <typename T>
struct WITH_EXECUTION_SPACE;

template <template <typename...> class To, template <typename...> class From, typename... As>
auto rebind(From<As...>*) -> To<As...>;
 
template <template <typename...> class To, typename From>
using rebind_t = decltype(rebind<To>(static_cast<From*>(nullptr)));

template <typename T>
struct TryDiagnose {
    using type = stdexec::__msuccess;
};
 
template <typename T>
requires std::invocable<decltype(T::diagnose)>
struct TryDiagnose<T> {
    using type = decltype(T::diagnose());
};
 
template <typename T>
using try_diagnose_t = typename TryDiagnose<T>::type;

template <typename...>
struct Diagnose;
 
template <typename T>
struct Diagnose<T> : TryDiagnose<T> { };
 
template <typename... Ts>
struct Diagnose {
    using type = stdexec::__mlist<try_diagnose_t<Ts>...>;
};
 
template <typename... Ts>
requires(sizeof...(Ts) > 0)
using diagnose_t = typename Diagnose<Ts...>::type;

template <typename...>
struct FirstErrorOf;
 
template <typename T>
struct FirstErrorOf<T> {
    using type = std::conditional_t<stdexec::__merror<T>, T, stdexec::__msuccess>;
};
 
template <typename T, typename... Ts>
struct FirstErrorOf<T, Ts...>
    : std::conditional_t<stdexec::__merror<T>, std::type_identity<T>, FirstErrorOf<Ts...>> { };
 
template <typename T>
struct FirstError : FirstErrorOf<T> { };
 
template <typename... Ts>
struct FirstError<stdexec::__mlist<Ts...>> : FirstErrorOf<Ts...> { };
 
template <typename T>
using first_error_t = typename FirstError<T>::type;

template <typename T>
struct Collapse : std::type_identity<T> { };
 
template <typename T>
struct Collapse<stdexec::__mlist<T>> {
    using type = T;
};
 
template <typename T>
using collapse_t = typename Collapse<T>::type;

template <typename T>
using keep_if_error_t = std::conditional_t<stdexec::__merror<T>, stdexec::__mlist<T>, stdexec::__mlist<>>;
 
template <typename T>
struct KeepErrors {
    using type = std::conditional_t<stdexec::__merror<T>, T, stdexec::__msuccess>;
};
 
template <typename... Ts>
struct KeepErrors<stdexec::__mlist<Ts...>> {
    using type = stdexec::__mconcat_result_t<stdexec::__mlist<>, keep_if_error_t<Ts>...>;
};
 
template <typename List>
using keep_errors_t = typename KeepErrors<List>::type;

template <typename T>
constexpr bool mandate_or_explain() noexcept {
    if constexpr (!T::value) {
        static_assert(std::is_same_v<diagnose_t<T>, stdexec::__msuccess>, "Check for the error in the compiler log.");
    }
    return T::value;
}
 
} // namespace Kokkos::Execution::Impl
 
#endif // KOKKOS_EXECUTION_IMPL_DIAGNOSTICS_HPP