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();
    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 Check whether *this contains an expected value
    explicit operator bool() 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>
class [[nodiscard]] expected<void, E> {
public:
    constexpr expected() noexcept;
    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);
 
    bool has_value() const noexcept;
    explicit operator bool() const noexcept;
    void value() const;
 
    E& error();
    const E& error() const;
 
private:
    std::variant<std::monostate, 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()
    : 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>
expected<S, E>::operator bool() const noexcept {
    return has_value();
}
 
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();
}
 
template <class E>
constexpr expected<void, E>::expected() noexcept: data_(std::in_place_index<0>) {}
 
template <class E>
expected<void, E>::expected(const unexpected<E>& error)
    : data_(error.error())
{}
 
template <class E>
expected<void, E>::expected(unexpected<E>&& error)
    : data_(std::forward<unexpected<E>>(error.error()))
{}
 
template <class E>
template <class G, typename>
expected<void, E>::expected(const unexpected<G>& error)
    : data_(utils::unexpected<E>(std::forward<G>(error.error())))
{}
 
template <class E>
template <class G, typename>
expected<void, E>::expected(unexpected<G>&& error)
    : data_(utils::unexpected<E>(std::forward<G>(error.error())))
{}
 
template <class E>
bool expected<void, E>::has_value() const noexcept {
    return data_.index() == 0;
}
 
template <class E>
expected<void, E>::operator bool() const noexcept {
    return has_value();
}
 
template <class E>
void expected<void, E>::value() const {
    if (!has_value()) {
        throw bad_expected_access("Trying to get undefined value from utils::expected");
    }
}
 
template <class E>
E& expected<void, 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 E>
const E& expected<void, 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