expected.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/expected.hpp
/// @brief @copybrief utils::expected
 
#include <stdexcept>
#include <string>
#include <variant>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
// NOLINTBEGIN(readability-identifier-naming)
 
class bad_expected_access : public std::exception {
public:
    using std::exception::exception;
 
    explicit bad_expected_access(const std::string& message) : message_{message} {}
 
    const char* what() const noexcept override { return message_.c_str(); }
 
private:
    std::string message_;
};
 
template <class E>
class unexpected {
public:
    unexpected(const E& error);
    unexpected(E&& error);
 
    template <class... Args>
    unexpected(Args&&... args);
 
    template <class U, class... Args>
    unexpected(std::initializer_list<U> il, Args&&... args);
 
    E& error() noexcept;
    const E& error() const noexcept;
 
private:
    E value_;
};
 
template <class E>
unexpected(E) -> unexpected<E>;
 
/// @ingroup userver_universal userver_containers
///
/// @brief For holding a value or an error
template <class S, class E>
class [[nodiscard]] expected {
public:
    constexpr expected() noexcept(std::is_void_v<S>);
    expected(const S& success);
    expected(S&& success);
    expected(const unexpected<E>& error);
    expected(unexpected<E>&& error);
 
    template <class G, typename = std::enable_if_t<std::is_convertible_v<G, E>>>
    expected(const unexpected<G>& error);
 
    template <class G, typename = std::enable_if_t<std::is_convertible_v<G, E>>>
    expected(unexpected<G>&& error);
 
    /// @brief Check whether *this contains an expected value
    bool has_value() const noexcept;
 
    /// @brief Return reference to the value or throws bad_expected_access
    /// if it's not available
    /// @throws utils::bad_expected_access if *this contain an unexpected value
    S& value() &;
 
    /// @overload
    S&& value() &&;
 
    /// @overload
    const S& value() const&;
 
    /// @brief Return reference to the error value or throws bad_expected_access
    /// if it's not available
    /// @throws utils::bad_expected_access if success value is not available
    E& error();
 
    /// @overload
    const E& error() const;
 
private:
    std::variant<S, unexpected<E>> data_;
};
 
template <class E>
unexpected<E>::unexpected(const E& error) : value_{error} {}
 
template <class E>
unexpected<E>::unexpected(E&& error) : value_{std::forward<E>(error)} {}
 
template <class E>
template <class... Args>
unexpected<E>::unexpected(Args&&... args) : value_(std::forward<Args>(args)...) {}
 
template <class E>
template <class U, class... Args>
unexpected<E>::unexpected(std::initializer_list<U> il, Args&&... args) : value_(il, std::forward<Args>(args)...) {}
 
template <class E>
E& unexpected<E>::error() noexcept {
    return value_;
}
 
template <class E>
const E& unexpected<E>::error() const noexcept {
    return value_;
}
 
template <class S, class E>
constexpr expected<S, E>::expected() noexcept(std::is_void_v<S>) : data_(std::in_place_index<0>) {}
 
template <class S, class E>
expected<S, E>::expected(const S& success) : data_(success) {}
 
template <class S, class E>
expected<S, E>::expected(S&& success) : data_(std::forward<S>(success)) {}
 
template <class S, class E>
expected<S, E>::expected(const unexpected<E>& error) : data_(error.error()) {}
 
template <class S, class E>
expected<S, E>::expected(unexpected<E>&& error) : data_(std::forward<unexpected<E>>(error.error())) {}
 
template <class S, class E>
template <class G, typename>
expected<S, E>::expected(const unexpected<G>& error) : data_(utils::unexpected<E>(std::forward<G>(error.error()))) {}
 
template <class S, class E>
template <class G, typename>
expected<S, E>::expected(unexpected<G>&& error) : data_(utils::unexpected<E>(std::forward<G>(error.error()))) {}
 
template <class S, class E>
bool expected<S, E>::has_value() const noexcept {
    return std::holds_alternative<S>(data_);
}
 
template <class S, class E>
S& expected<S, E>::value() & {
    S* result = std::get_if<S>(&data_);
    if (result == nullptr) {
        throw bad_expected_access("Trying to get undefined value from utils::expected");
    }
    return *result;
}
 
template <class S, class E>
S&& expected<S, E>::value() && {
    return std::move(value());
}
 
template <class S, class E>
const S& expected<S, E>::value() const& {
    const S* result = std::get_if<S>(&data_);
    if (result == nullptr) {
        throw bad_expected_access("Trying to get undefined value from utils::expected");
    }
    return *result;
}
 
template <class S, class E>
E& expected<S, E>::error() {
    auto* result = std::get_if<unexpected<E>>(&data_);
    if (result == nullptr) {
        throw bad_expected_access("Trying to get undefined error value from utils::expected");
    }
    return result->error();
}
 
template <class S, class E>
const E& expected<S, E>::error() const {
    const auto* result = std::get_if<unexpected<E>>(&data_);
    if (result == nullptr) {
        throw bad_expected_access("Trying to get undefined error value from utils::expected");
    }
    return result->error();
}
 
// NOLINTEND(readability-identifier-naming)
 
}  // namespace utils
 
USERVER_NAMESPACE_END