unexpected.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
// SPDX-FileCopyrightText: Copyright (C) 2021 Tobias Hienzsch
 
#ifndef TETL_EXPECTED_UNEXPECTED_HPP
#define TETL_EXPECTED_UNEXPECTED_HPP
 
#include <etl/_type_traits/is_constructible.hpp>
#include <etl/_type_traits/is_nothrow_constructible.hpp>
#include <etl/_type_traits/is_nothrow_swappable.hpp>
#include <etl/_type_traits/is_same.hpp>
#include <etl/_type_traits/is_swappable.hpp>
#include <etl/_type_traits/remove_cvref.hpp>
#include <etl/_utility/forward.hpp>
#include <etl/_utility/in_place.hpp>
#include <etl/_utility/move.hpp>
#include <etl/_utility/swap.hpp>
 
namespace etl {
 
/// \ingroup expected
template <typename E>
struct unexpected {
    template <typename Err = E>
        requires(
            not etl::is_same_v<etl::remove_cvref_t<Err>, unexpected>          //
            and not etl::is_same_v<etl::remove_cvref_t<Err>, etl::in_place_t> //
            and etl::is_constructible_v<E, Err>
        )
    constexpr explicit unexpected(Err&& e) noexcept(etl::is_nothrow_constructible_v<E, Err>)
        : _unex(etl::forward<Err>(e))
    {
    }
 
    template <typename... Args>
        requires etl::is_constructible_v<E, Args...>
    constexpr explicit unexpected(etl::in_place_t /*tag*/, Args&&... args) noexcept(
        etl::is_nothrow_constructible_v<E, Args...>
    )
        : _unex(etl::forward<Args>(args)...)
    {
    }
 
    constexpr unexpected(unexpected const&) = default;
    constexpr unexpected(unexpected&&)      = default;
 
    constexpr auto operator=(unexpected const&) -> unexpected& = default;
    constexpr auto operator=(unexpected&&) -> unexpected&      = default;
 
    [[nodiscard]] constexpr auto error() const& noexcept -> E const&
    {
        return _unex;
    }
 
    [[nodiscard]] constexpr auto error() & noexcept -> E&
    {
        return _unex;
    }
 
    [[nodiscard]] constexpr auto error() const&& noexcept -> E const&&
    {
        return etl::move(_unex);
    }
 
    [[nodiscard]] constexpr auto error() && noexcept -> E&&
    {
        return etl::move(_unex);
    }
 
    constexpr auto swap(unexpected& other) noexcept(etl::is_nothrow_swappable_v<E>) -> void
        requires etl::is_swappable_v<E>
    {
        using etl::swap;
        swap(error(), other.error());
    }
 
    template <typename E2>
    friend constexpr auto operator==(unexpected const& lhs, unexpected<E2> const& rhs) -> bool
    {
        return lhs.error() == rhs.error();
    }
 
    friend constexpr auto swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y))) -> void
        requires etl::is_swappable_v<E>
    {
        x.swap(y);
    }
 
private:
    E _unex;
};
 
template <typename E>
unexpected(E) -> unexpected<E>;
 
} // namespace etl
#endif // TETL_EXPECTED_UNEXPECTED_HPP