local_variable.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/engine/task/local_variable.hpp
/// @brief @copybrief engine::TaskLocalVariable
 
#include <type_traits>
 
#include <userver/engine/impl/task_local_storage.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace engine {
 
/// @ingroup userver_concurrency
///
/// @brief TaskLocalVariable is a per-coroutine variable of arbitrary type.
///
/// It is an alternative to `thread_local`, but per-task instead of per-thread.
///
/// The order of destruction of task-local variables is inverse to the order of
/// initialization.
template <typename T>
class TaskLocalVariable final {
    static_assert(!std::is_reference_v<T>);
    static_assert(!std::is_const_v<T>);
 
public:
    /// @brief Get the instance of the variable for the current coroutine.
    /// Initializes (default constructs) the variable if it was not previously
    /// initialized.
    /// @note Must be called from a coroutine, otherwise it is UB.
    T& operator*();
 
    /// @overload
    T* operator->();
 
    /// @brief Get the variable instance for the current task.
    /// @returns the variable or `nullptr` if variable was not initialized.
    T* GetOptional() noexcept {
        return impl::task_local::GetCurrentStorage().GetOptional<T, kVariableKind>(impl_.GetKey());
    }
    T* GetOptional() noexcept {…}
 
private:
    static constexpr auto kVariableKind = impl::task_local::VariableKind::kNormal;
 
    impl::task_local::Variable impl_;
};
class TaskLocalVariable final {…};
 
template <typename T>
T& TaskLocalVariable<T>::operator*() {
    return impl::task_local::GetCurrentStorage().GetOrEmplace<T, kVariableKind>(impl_.GetKey());
}
T& TaskLocalVariable<T>::operator*() {…}
 
template <typename T>
T* TaskLocalVariable<T>::operator->() {
    return &(**this);
}
T* TaskLocalVariable<T>::operator->() {…}
 
}  // namespace engine
 
USERVER_NAMESPACE_END