async.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <functional>
#include <string>
#include <utility>
 
#include <userver/engine/async.hpp>
#include <userver/utils/fast_pimpl.hpp>
#include <userver/utils/lazy_prvalue.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
namespace impl {
 
// A wrapper that obtains a Span from args, attaches it to current coroutine,
// and applies a function to the rest of arguments.
struct SpanWrapCall {
  enum class InheritVariables { kYes, kNo };
 
  explicit SpanWrapCall(std::string&& name, InheritVariables inherit_variables);
 
  SpanWrapCall(const SpanWrapCall&) = delete;
  SpanWrapCall(SpanWrapCall&&) = delete;
  SpanWrapCall& operator=(const SpanWrapCall&) = delete;
  SpanWrapCall& operator=(SpanWrapCall&&) = delete;
  ~SpanWrapCall();
 
  template <typename Function, typename... Args>
  auto operator()(Function&& f, Args&&... args) {
    DoBeforeInvoke();
    return std::invoke(std::forward<Function>(f), std::forward<Args>(args)...);
  }
 
 private:
  void DoBeforeInvoke();
 
  struct Impl;
 
  static constexpr std::size_t kImplSize = 4240;
  static constexpr std::size_t kImplAlign = 8;
  utils::FastPimpl<Impl, kImplSize, kImplAlign> pimpl_;
};
 
// Note: 'name' must outlive the result of this function
inline auto SpanLazyPrvalue(std::string&& name) {
  return utils::LazyPrvalue([&name] {
    return SpanWrapCall(std::move(name), SpanWrapCall::InheritVariables::kYes);
  });
}
 
}  // namespace impl
 
template <typename Function, typename... Args>
[[nodiscard]] auto CriticalAsync(engine::TaskProcessor& task_processor,
                                 std::string name, Function&& f,
                                 Args&&... args) {
  return engine::CriticalAsyncNoSpan(
      task_processor, impl::SpanLazyPrvalue(std::move(name)),
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto SharedCriticalAsync(engine::TaskProcessor& task_processor,
                                       std::string name, Function&& f,
                                       Args&&... args) {
  return engine::SharedCriticalAsyncNoSpan(
      task_processor, impl::SpanLazyPrvalue(std::move(name)),
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto Async(engine::TaskProcessor& task_processor,
                         std::string name, Function&& f, Args&&... args) {
  return engine::AsyncNoSpan(
      task_processor, impl::SpanLazyPrvalue(std::move(name)),
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsync(engine::TaskProcessor& task_processor,
                               std::string name, Function&& f, Args&&... args) {
  return engine::SharedAsyncNoSpan(
      task_processor, impl::SpanLazyPrvalue(std::move(name)),
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto Async(engine::TaskProcessor& task_processor,
                         std::string name, engine::Deadline deadline,
                         Function&& f, Args&&... args) {
  return engine::AsyncNoSpan(
      task_processor, deadline, impl::SpanLazyPrvalue(std::move(name)),
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsync(engine::TaskProcessor& task_processor,
                               std::string name, engine::Deadline deadline,
                               Function&& f, Args&&... args) {
  return engine::SharedAsyncNoSpan(
      task_processor, deadline, impl::SpanLazyPrvalue(std::move(name)),
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto CriticalAsync(std::string name, Function&& f,
                                 Args&&... args) {
  return utils::CriticalAsync(engine::current_task::GetTaskProcessor(),
                              std::move(name), std::forward<Function>(f),
                              std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto SharedCriticalAsync(std::string name, Function&& f,
                                       Args&&... args) {
  return utils::SharedCriticalAsync(engine::current_task::GetTaskProcessor(),
                                    std::move(name), std::forward<Function>(f),
                                    std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto Async(std::string name, Function&& f, Args&&... args) {
  return utils::Async(engine::current_task::GetTaskProcessor(), std::move(name),
                      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsync(std::string name, Function&& f, Args&&... args) {
  return utils::SharedAsync(engine::current_task::GetTaskProcessor(),
                            std::move(name), std::forward<Function>(f),
                            std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto Async(std::string name, engine::Deadline deadline,
                         Function&& f, Args&&... args) {
  return utils::Async(engine::current_task::GetTaskProcessor(), std::move(name),
                      deadline, std::forward<Function>(f),
                      std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsync(std::string name, engine::Deadline deadline,
                               Function&& f, Args&&... args) {
  return utils::SharedAsync(
      engine::current_task::GetTaskProcessor(), std::move(name), deadline,
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
template <typename Function, typename... Args>
[[nodiscard]] auto AsyncBackground(std::string name,
                                   engine::TaskProcessor& task_processor,
                                   Function&& f, Args&&... args) {
  return engine::AsyncNoSpan(
      task_processor, utils::LazyPrvalue([&] {
        return impl::SpanWrapCall(std::move(name),
                                  impl::SpanWrapCall::InheritVariables::kNo);
      }),
      std::forward<Function>(f), std::forward<Args>(args)...);
}
 
}  // namespace utils
 
USERVER_NAMESPACE_END