result.hpp

// Copyright (C) 2022 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/exception.hpp"
 
#include <variant>
 
namespace arg_router::utility
{
template <typename ResultType, typename ExceptionType>
class result
{
    static_assert(!std::is_same_v<ResultType, ExceptionType>,
                  "Result and exception argument cannot be same type");
 
public:
    using result_type = std::decay_t<ResultType>;
    using exception_type = ExceptionType;
 
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    constexpr result(result_type value) noexcept : data_{std::move(value)} {}
 
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    constexpr result(ExceptionType ex) noexcept : data_{std::move(ex)} {}
 
    [[nodiscard]] constexpr bool has_result() const noexcept { return data_.index() == 0; }
 
    [[nodiscard]] constexpr bool has_error() const noexcept { return !has_result(); }
 
    [[nodiscard]] explicit constexpr operator bool() const noexcept { return has_result(); }
 
    [[nodiscard]] constexpr bool operator!() const noexcept { return has_error(); }
 
    [[nodiscard]] constexpr bool operator==(const result& other) const noexcept
    {
        if (has_error() || other.has_error()) {
            return false;
        }
        return std::get<0>(data_) == std::get<0>(other.data_);
    }
 
    [[nodiscard]] constexpr bool operator!=(const result& other) const noexcept
    {
        return !(*this == other);
    }
 
    [[nodiscard]] friend constexpr bool operator==(const result& lhs,
                                                   const result_type& rhs) noexcept
    {
        if (lhs.has_error()) {
            return false;
        }
        return std::get<0>(lhs.data_) == rhs;
    }
 
    [[nodiscard]] friend constexpr bool operator!=(const result& lhs,
                                                   const result_type& rhs) noexcept
    {
        return !(lhs == rhs);
    }
 
    [[nodiscard]] friend constexpr bool operator==(const result_type& lhs,
                                                   const result& rhs) noexcept
    {
        return rhs == lhs;
    }
 
    [[nodiscard]] friend constexpr bool operator!=(const result_type& lhs,
                                                   const result& rhs) noexcept
    {
        return !(lhs == rhs);
    }
 
    [[nodiscard]] result_type* get_if() noexcept
    {
        return has_result() ? &std::get<0>(data_) : nullptr;
    }
 
    [[nodiscard]] const result_type* get_if() const noexcept
    {
        return has_result() ? &std::get<0>(data_) : nullptr;
    }
 
    result_type extract()
    {
        if (has_result()) {
            return std::move(std::get<0>(data_));
        }
        throw std::move(std::get<1>(data_));
    }
 
    [[nodiscard]] auto get() const
        -> std::conditional_t<(sizeof(std::size_t) >= sizeof(result_type)) &&
                                  std::is_copy_constructible_v<result_type>,
                              result_type,
                              const result_type&>
    {
        if (has_result()) {
            return std::get<0>(data_);
        }
        throw exception_type{std::get<1>(data_)};
    }
 
    void throw_exception() const
    {
        if (has_error()) {
            throw exception_type{std::get<1>(data_)};
        }
    }
 
private:
    std::variant<result_type, exception_type> data_;
};
}  // namespace arg_router::utility