lazy_value.hpp

#pragma once
 
/// @file userver/utils/lazy_value.hpp
/// @brief @copybrief utils::LazyValue
 
#include <atomic>
#include <exception>
#include <utility>
 
#include <userver/engine/condition_variable.hpp>
#include <userver/engine/exception.hpp>
#include <userver/engine/task/cancel.hpp>
#include <userver/utils/assert.hpp>
#include <userver/utils/result_store.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace concurrent {
 
/// @brief lazy value computation with multiple users
template <typename T>
class LazyValue final {
public:
    explicit LazyValue(std::function<T()> f) : f_(std::move(f)) { UASSERT(f_); }
 
    /// @brief Get an already calculated result or calculate it.
    ///        It is guaranteed that `f` is called exactly once.
    ///        Can be called concurrently from multiple coroutines.
    /// @throws anything `f` throws.
    const T& operator()();
 
private:
    std::function<T()> f_;
    std::atomic<bool> started_{false};
    utils::ResultStore<T> result_;
 
    engine::ConditionVariable cv_finished_;
    engine::Mutex m_finished_;
    std::atomic<bool> finished_{false};
};
 
template <typename T>
const T& LazyValue<T>::operator()() {
    if (finished_) return result_.Get();
 
    auto old = started_.exchange(true);
    if (!old) {
        try {
            result_.SetValue(f_());
 
            std::lock_guard lock(m_finished_);
            finished_ = true;
            cv_finished_.NotifyAll();
        } catch (...) {
            result_.SetException(std::current_exception());
 
            std::lock_guard lock(m_finished_);
            finished_ = true;
            cv_finished_.NotifyAll();
            throw;
        }
    } else {
        std::unique_lock lock(m_finished_);
        auto rc = cv_finished_.Wait(lock, [this]() { return finished_.load(); });
        if (!rc) throw engine::WaitInterruptedException(engine::current_task::CancellationReason());
    }
 
    return result_.Get();
}
 
}  // namespace concurrent
 
USERVER_NAMESPACE_END