result_helpers.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "result.h"
#include <utility>
#include <type_traits>
 
namespace kcenon::common {
namespace helpers {
 
template<typename T>
[[nodiscard]] auto return_if_error(const Result<T>& result)
    -> std::optional<error_info>
{
    if (result.is_err()) {
        return result.error();
    }
    return std::nullopt;
}
 
// TRY_UNWRAP macro removed: it used GCC statement expressions ({ }) which
// are not supported on MSVC. Use the type-safe alternatives instead:
//   - return_if_error() above for early-return on error
//   - try_extract() below for extracting values
//   - safe_execute() below for exception-to-Result conversion
 
template<typename T>
[[nodiscard]] auto try_extract(Result<T>&& result)
    -> std::conditional_t<std::is_void_v<T>, Result<std::monostate>, Result<T>>
{
    return std::forward<Result<T>>(result);
}
 
[[nodiscard]] inline auto error_if(bool condition, const error_info& error)
    -> std::optional<error_info>
{
    if (condition) {
        return error;
    }
    return std::nullopt;
}
 
[[nodiscard]] inline auto make_error(int code,
                                     const std::string& message,
                                     const std::string& module = "") noexcept
    -> error_info
{
    return error_info{code, message, module};
}
 
[[nodiscard]] inline auto make_error_with_details(
    int code,
    const std::string& message,
    const std::string& module,
    const std::string& details) noexcept
    -> error_info
{
    return error_info{code, message, module, details};
}
 
template<typename... Funcs>
[[nodiscard]] auto chain(Funcs&&... funcs) {
    using FirstResult = std::invoke_result_t<std::tuple_element_t<0, std::tuple<Funcs...>>>;
 
    FirstResult result = std::get<0>(std::forward_as_tuple(funcs...))();
 
    if constexpr (sizeof...(funcs) > 1) {
        ([&]<typename Func>(Func&& func) {
            if (result.is_ok()) {
                result = func(result.value());
            }
        }(std::forward<Funcs>(funcs)), ...);
    }
 
    return result;
}
 
template<typename Func>
[[nodiscard]] auto safe_execute(Func&& func, const std::string& module = "")
    -> Result<std::invoke_result_t<Func>>
{
    using ReturnType = std::invoke_result_t<Func>;
 
    try {
        if constexpr (std::is_void_v<ReturnType>) {
            func();
            return Result<std::monostate>(std::monostate{});
        } else {
            return Result<ReturnType>(func());
        }
    } catch (const std::exception& e) {
        return Result<ReturnType>(error_info{-99, e.what(), module});
    } catch (...) {
        return Result<ReturnType>(error_info{-99, "Unknown error", module});
    }
}
 
template<typename T, typename ErrorHandler>
[[nodiscard]] auto unwrap_or_handle(Result<T>&& result, ErrorHandler&& error_handler) -> T
{
    if (result.is_err()) {
        error_handler(result.error());
        return T{};
    }
    return std::move(result).value();
}
 
template<typename... Results>
[[nodiscard]] auto combine_results(Results&&... results)
    -> Result<std::tuple<typename std::decay_t<Results>::value_type...>>
{
    // Check if any result is error
    bool has_error = (... || results.is_err());
    if (has_error) {
        // Return first error found
        error_info first_error;
        ((results.is_err() && (first_error = results.error(), true)) || ...);
        return Result<std::tuple<typename std::decay_t<Results>::value_type...>>(first_error);
    }
 
    // All ok, combine values
    return Result<std::tuple<typename std::decay_t<Results>::value_type...>>(
        std::make_tuple(std::forward<Results>(results).value()...)
    );
}
 
} // namespace helpers
} // namespace kcenon::common