result_store.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/result_store.hpp
/// @brief @copybrief utils::ResultStore
 
#include <exception>
#include <optional>
#include <stdexcept>
#include <utility>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
/// @ingroup userver_universal userver_containers
///
/// Simple value/exception store
template <typename T>
class ResultStore final {
public:
    /// @brief Retrieves the stored value or rethrows the stored exception
    /// @throws std::logic_error if no value/exception stored
    /// @note Can be called at most once.
    T Retrieve();
 
    /// @brief Returns the stored value or rethrows the stored exception
    /// @throws std::logic_error if no value/exception stored
    const T& Get() const&;
 
    /// Stores a value
    void SetValue(const T&);
 
    /// Stores a value
    void SetValue(T&&);
 
    /// Stores an exception
    void SetException(std::exception_ptr&&) noexcept;
 
private:
    // variant here would require a specialization for exception_ptr
    std::optional<T> value_;
    std::exception_ptr exception_;
};
 
/// @ingroup userver_universal userver_containers
///
/// Simple void value/exception store
template <>
class ResultStore<void> final {
public:
    /// @brief Checks value availability or rethrows the stored exception
    /// @throws std::logic_error if no value/exception stored
    void Retrieve();
 
    void Get() const&;
 
    /// Marks the value as available
    void SetValue() noexcept;
 
    /// Stores an exception
    void SetException(std::exception_ptr&&) noexcept;
 
private:
    bool has_value_{false};
    std::exception_ptr exception_;
};
class ResultStore<void> final {…};
 
template <typename T>
T ResultStore<T>::Retrieve() {
    if (value_) return std::move(*value_);
    if (exception_) std::rethrow_exception(exception_);
    throw std::logic_error("result store is not ready");
}
T ResultStore<T>::Retrieve() {…}
 
template <typename T>
const T& ResultStore<T>::Get() const& {
    if (value_) return *value_;
    if (exception_) std::rethrow_exception(exception_);
    throw std::logic_error("result store is not ready");
}
const T& ResultStore<T>::Get() const& {…}
 
template <typename T>
void ResultStore<T>::SetValue(const T& value) {
    value_ = value;
}
void ResultStore<T>::SetValue(const T& value) {…}
 
template <typename T>
void ResultStore<T>::SetValue(T&& value) {
    value_.emplace(std::move(value));
}
void ResultStore<T>::SetValue(T&& value) {…}
 
template <typename T>
void ResultStore<T>::SetException(std::exception_ptr&& exception) noexcept {
    exception_ = std::move(exception);
}
void ResultStore<T>::SetException(std::exception_ptr&& exception) noexcept {…}
    void SetException(std::exception_ptr&&) noexcept; {…}
 
// NOLINTNEXTLINE(readability-make-member-function-const)
inline void ResultStore<void>::Retrieve() { Get(); }
 
inline void ResultStore<void>::Get() const& {
    if (has_value_) return;
    if (exception_) std::rethrow_exception(exception_);
    throw std::logic_error("result store is not ready");
}
 
inline void ResultStore<void>::SetValue() noexcept { has_value_ = true; }
 
inline void ResultStore<void>::SetException(std::exception_ptr&& exception) noexcept {
    exception_ = std::move(exception);
}
inline void ResultStore<void>::SetException(std::exception_ptr&& exception) noexcept {…}
 
}  // namespace utils
 
USERVER_NAMESPACE_END
    void SetValue(T&&); {…}
    void SetValue(const T&); {…}
    const T& Get() const&; {…}
    T Retrieve(); {…}
class ResultStore final {…};