Helpers.hpp

// SPDX-FileCopyrightText: 2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <cerrno>
#include <concepts>
#include <format>
#include <functional>
 
// Project includes
#include <dfx-plugins-interface/PluginInterface.h>
#include <dfx-utilities/Exception.hpp>
#include <dfx-utilities/Log.hpp>
 
struct VoidReturnTag { explicit VoidReturnTag() noexcept = default; };
inline constexpr VoidReturnTag DFX_VOID_ERROR {};
 
inline constexpr int DFX_NO_ERRNO = -1;
 
namespace dfx::Plugins::Helpers
{
template<int ErrnoValue, auto ErrorCode = DFX_ERROR, auto SuccessCode = DFX_OK, typename F, typename ... Args>
requires std::invocable<F, Args...>
auto safeInvokeFFI(std::shared_ptr<spdlog::logger> logger, F && f, Args && ... args) noexcept
{
    try
    {
        std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
        return SuccessCode;
    }
    catch (Utils::Exception const & e)
    {
        if (logger != nullptr)
            Utils::Exception::printToLogger(e, logger);
    }
    catch (std::exception const & e)
    {
        DFX_LLOG(logger, spdlog::level::err, "An error occurred: {}", e.what());
    }
    catch (...)
    {
        DFX_LLOG(logger, spdlog::level::err, "An unknown error occurred");
    }
 
    if constexpr (ErrnoValue != DFX_NO_ERRNO)
        errno = ErrnoValue;
    return ErrorCode;
}
 
template<int ErrnoValue, auto ErrorCode, typename F, typename ... Args>
requires std::invocable<F, Args...>
auto safeInvokeValueFFI(std::shared_ptr<spdlog::logger> logger, F && f, Args && ... args) noexcept
{
    using ResultType = std::invoke_result_t<F, Args...>;
    static_assert(!std::is_void_v<ResultType>,
                  "safeInvokeValueFFI cannot be used with void functions. Use safeInvokeFFI instead.");
 
    try
    {
        return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    }
    catch (Utils::Exception const & e)
    {
        if (logger != nullptr)
            Utils::Exception::printToLogger(e, logger);
    }
    catch (std::exception const & e)
    {
        DFX_LLOG(logger, spdlog::level::err, "An error occurred: {}", e.what());
    }
    catch (...)
    {
        DFX_LLOG(logger, spdlog::level::err, "An unknown error occurred");
    }
 
    if constexpr (ErrnoValue != DFX_NO_ERRNO)
        errno = ErrnoValue;
    return static_cast<ResultType>(ErrorCode);
}
 
template<int ErrnoValue, auto ErrorCode = DFX_ERROR>
auto setErrnoAndReturn() noexcept
{
    errno = ErrnoValue;
    if constexpr (!std::is_same_v<decltype(ErrorCode), VoidReturnTag>)
        return ErrorCode;
}
 
template<int ErrnoValue, auto ErrorCode = DFX_ERROR, typename ... Args>
auto setErrnoLogAndReturn(std::shared_ptr<spdlog::logger> logger, std::format_string<Args ...> message, Args && ... args) noexcept
{
    if (logger != nullptr)
        DFX_LLOG_ERROR(logger, message, std::forward<Args>(args)...);
 
    return setErrnoAndReturn<ErrnoValue, ErrorCode>();
}
} // !namespace dfx::Plugins::Helpers