Spawn.h

#ifndef XRPL_SERVER_SPAWN_H_INCLUDED
#define XRPL_SERVER_SPAWN_H_INCLUDED
 
#include <xrpl/basics/Log.h>
 
#include <boost/asio/spawn.hpp>
#include <boost/asio/strand.hpp>
 
#include <concepts>
#include <type_traits>
 
namespace ripple::util {
namespace impl {
 
template <typename T>
concept IsStrand = std::same_as<
    std::decay_t<T>,
    boost::asio::strand<typename std::decay_t<T>::inner_executor_type>>;
 
inline constexpr auto kPROPAGATE_EXCEPTIONS = [](std::exception_ptr ePtr) {
    if (ePtr)
    {
        try
        {
            std::rethrow_exception(ePtr);
        }
        catch (std::exception const& e)
        {
            JLOG(debugLog().warn()) << "Spawn exception: " << e.what();
            throw;
        }
        catch (...)
        {
            JLOG(debugLog().warn()) << "Spawn exception: Unknown";
            throw;
        }
    }
};
 
}  // namespace impl
 
template <typename Ctx, typename F>
    requires std::is_invocable_r_v<void, F, boost::asio::yield_context>
void
spawn(Ctx&& ctx, F&& func)
{
    if constexpr (impl::IsStrand<Ctx>)
    {
        boost::asio::spawn(
            std::forward<Ctx>(ctx),
            std::forward<F>(func),
            impl::kPROPAGATE_EXCEPTIONS);
    }
    else
    {
        boost::asio::spawn(
            boost::asio::make_strand(
                boost::asio::get_associated_executor(std::forward<Ctx>(ctx))),
            std::forward<F>(func),
            impl::kPROPAGATE_EXCEPTIONS);
    }
}
 
}  // namespace ripple::util
 
#endif