ReturnVal.h

#pragma once
 
#include <sections/Misc.h>
 
#include <type_traits>
#include <concepts>
#include <utility>
 
namespace PashaBibko::Util
{
    #ifndef DOXYGEN_HIDE
 
    /* Wether functions should check to see if the call is safe or not */
    enum class Result
    {
        Check,
        Force
    };
 
    /*
     * Undocumented as it should be mentioned in all functions it is in
     * and does not need its own section as it is essentially a boolean.
     */
 
    #endif // DOXYGEN_HIDE
 
    struct DefaultError
    {
        DefaultError()
            : message("NO REASON PROVIDED") {}
 
        DefaultError(const char* _message)
            : message(_message) {}
 
        const char* message;
    };
 
    template<typename Err_Ty = DefaultError>
    struct FunctionFail final
    {
        explicit FunctionFail(Err_Ty _error)
            : error(_error)
        {}
 
        template<typename... Args>
            requires std::is_constructible_v<Err_Ty, Args...>
        explicit FunctionFail(Args&&... args)
            : error(std::forward<Args>(args)...)
        {}
 
        Err_Ty error;
    };
 
    template<typename Res_Ty, typename Err_Ty = DefaultError>
        requires (!std::same_as<Res_Ty, void>) && (!std::same_as<Err_Ty, void>)
    class ReturnVal final
    {
        public:
            explicit ReturnVal(Res_Ty _result)
                : m_Result(_result), m_FunctionFailed(false)
            {}
 
            ReturnVal(Res_Ty&& _result)
                : m_Result(std::move(_result)), m_FunctionFailed(false)
            {}
 
            ReturnVal(FunctionFail<Err_Ty>&& _error)
                : m_Error(std::move(_error.error)), m_FunctionFailed(true)
            {}
 
            /* Constructor is not manually called by someone using the library so it is excluded from docs */
            #ifndef DOXYGEN_HIDE
 
            ~ReturnVal()
            {
                /* Makes sure the types deconstructor is called to avoid memory leaks */
                if (m_FunctionFailed)
                    m_Error.~Err_Ty();
 
                else
                    m_Result.~Res_Ty();
            }
 
            #endif
 
            template<Result force = Result::Check>
            inline Err_Ty& Error()
            {
                /* Force bypasses checking if the function failed or not */
                if constexpr (force == Result::Check)
                {
                    /* Ends the process if the error was tried to access on a sucessful return */
                    if (!m_FunctionFailed)
                        EndProcess();
                }
 
                /* Returns a const reference to the error */
                return m_Error;
            }
 
            template<Result force = Result::Check>
            inline Res_Ty& Result()
            {
                /* Force bypasses checking if the function failed or not */
                if constexpr (force == Result::Check)
                {
                    /* Ends the process if the result was tried to access on a failed result */
                    if (m_FunctionFailed)
                        EndProcess();
                }
 
                /* Returns a const reference to the result */
                return m_Result;
            }
 
            inline bool Failed() const { return m_FunctionFailed; }
 
            inline bool Success() const { return !m_FunctionFailed; }
 
        private:
            #ifndef DOXYGEN_HIDE
 
            /* Union to hold either the result or the error */
            union
            {
                Res_Ty m_Result;
                Err_Ty m_Error;
            };
 
            /*
             * It appears in Doxygen even though it is within a private block
             * which is why it is located in a pre-processor block
             */
 
            #endif // DOXYGEN_HIDE
 
            /* Holds wether the function failed or not */
            const bool m_FunctionFailed;
    };
}