Throw.inl

/*
 * Copyright(c) Sophist Solutions, Inc. 1990-2026.  All rights reserved
 */
#include <typeinfo> // needed for use of typeid()
 
namespace Stroika::Foundation::Execution {
 
    /*
     *  Forward declared, not included: Exceptions.h includes THIS file, and reaching the activity API from here
     *  would close the loop (Activity.h -> Characters/String.h -> String.inl -> Throw.h). Both helpers take only
     *  an ExceptionStringHelper&, so a forward declaration is enough; they are defined in Exceptions.cpp.
     */
    class ExceptionStringHelper;
    namespace Private_ {
        bool ShouldImbueActivities_ (const ExceptionStringHelper& e) noexcept;
        void ImbueCurrentActivities_ (ExceptionStringHelper* e);
    }
 
    namespace Private_ {
// avoid header dependencies on Debug/BackTrace and no Characters/String
#if qStroika_Foundation_Execution_Throw_TraceThrowpointBacktrace
        string  GetBT_s ();
        wstring GetBT_ws ();
#endif
        string ToString_ (const type_info&);
        template <typename T>
        inline string ToString_ (const T& t)
        {
            if constexpr (is_convertible_v<T, const exception&>) {
                return t.what ();
            }
            else {
                return ToString_ (typeid (T)); // exact match preferred over template
            }
        }
 
#if qStroika_Foundation_Debug_DefaultTracingOn
        void JustDbgTrace_ (const string& msg);
        void JustDbgTrace_ (const wstring& msg);
        void ThrowingExceptionDbgTrace_ (const string& msg);
        void ThrowingExceptionDbgTrace_ (const wstring& msg);
        void ReThrowingExceptionDbgTrace_ (const string& msg);
        void ReThrowingExceptionDbgTrace_ (const wstring& msg = {});
#endif
 
    }
 
    /*
     ********************************************************************************
     ***************************** Execution::Throw *********************************
     ********************************************************************************
     */
    template <typename T>
    [[noreturn]] inline void Throw (T&& e2Throw)
    {
        static_assert (is_convertible_v<remove_cvref_t<T>*, exception*>);
        if constexpr (derived_from<remove_cvref_t<T>, ExceptionStringHelper>) {
            // Use the current Activity stack if not already specified in the e2Throw
            if (Private_::ShouldImbueActivities_ (e2Throw)) [[unlikely]] {
                remove_cvref_t<T> tmp = e2Throw;
                Private_::ImbueCurrentActivities_ (&tmp);
#if qStroika_Foundation_Debug_DefaultTracingOn
                Private_::ThrowingExceptionDbgTrace_ (Private_::ToString_ (tmp));
#endif
                throw tmp;
            }
        }
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::ThrowingExceptionDbgTrace_ (Private_::ToString_ (forward<T> (e2Throw)));
#endif
        throw e2Throw;
    }
    template <typename T>
    [[noreturn]] inline void Throw (T&& e2Throw, [[maybe_unused]] const char* traceMsg)
    {
        static_assert (is_convertible_v<remove_cvref_t<T>*, exception*>);
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::JustDbgTrace_ (traceMsg);
#endif
        // deliberately via the 1-arg overload: that is what emits the "Throwing exception" trace (and backtrace);
        // throwing directly here would lose it. NB: this used to be about a per-type Throw<> specialization
        // which translated exception types (Platform::Windows::Exception ERROR_OUTOFMEMORY -> bad_alloc, etc);
        // no such specialization has existed for some time - @see Execution::ThrowError for where translation
        // actually happens now.
        Throw (forward<T> (e2Throw));
    }
    template <typename T>
    [[noreturn]] inline void Throw (T&& e2Throw, [[maybe_unused]] const wchar_t* traceMsg)
    {
        static_assert (is_convertible_v<remove_cvref_t<T>*, exception*>);
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::JustDbgTrace_ (traceMsg);
#endif
        // deliberately via the 1-arg overload: that is what emits the "Throwing exception" trace (and backtrace);
        // throwing directly here would lose it. NB: this used to be about a per-type Throw<> specialization
        // which translated exception types (Platform::Windows::Exception ERROR_OUTOFMEMORY -> bad_alloc, etc);
        // no such specialization has existed for some time - @see Execution::ThrowError for where translation
        // actually happens now.
        Throw (forward<T> (e2Throw));
    }
 
    /*
     ********************************************************************************
     ***************************** Execution::ReThrow *******************************
     ********************************************************************************
     */
    [[noreturn]] inline void ReThrow ()
    {
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::ReThrowingExceptionDbgTrace_ ();
#endif
        throw;
    }
    [[noreturn]] inline void ReThrow (const exception_ptr& e)
    {
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::ReThrowingExceptionDbgTrace_ ();
#endif
        rethrow_exception (e);
    }
    [[noreturn]] inline void ReThrow ([[maybe_unused]] const char* traceMsg)
    {
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::ReThrowingExceptionDbgTrace_ (traceMsg);
#endif
        throw;
    }
    [[noreturn]] inline void ReThrow (const exception_ptr& e, [[maybe_unused]] const char* traceMsg)
    {
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::ReThrowingExceptionDbgTrace_ (traceMsg);
#endif
        rethrow_exception (e);
    }
    [[noreturn]] inline void ReThrow ([[maybe_unused]] const wchar_t* traceMsg)
    {
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::ReThrowingExceptionDbgTrace_ (traceMsg);
#endif
        throw;
    }
    [[noreturn]] inline void ReThrow (const exception_ptr& e, [[maybe_unused]] const wchar_t* traceMsg)
    {
#if qStroika_Foundation_Debug_DefaultTracingOn
        Private_::ReThrowingExceptionDbgTrace_ (traceMsg);
#endif
        rethrow_exception (e);
    }
 
    /*
     ********************************************************************************
     *************************** Execution::ThrowIfNull *****************************
     ********************************************************************************
     */
    template <equality_comparable_with<nullptr_t> T, typename E>
    inline void ThrowIfNull (const T& p, const E& e)
    {
        if (p == nullptr) [[unlikely]] {
            Throw (e, "ThrowIfNull (nullptr) - throwing bad_alloc"); // todo fix trace message to depend on 'E'
        }
    }
    template <equality_comparable_with<nullptr_t> T>
    inline void ThrowIfNull (const T& p)
    {
        static const bad_alloc kException_;
        ThrowIfNull (p, kException_);
    }
    template <Common::Weak_Equality_Comparable_With<nullopt_t> T, typename E>
    inline void ThrowIfNull (const T& p, const E& e)
        requires (not equality_comparable_with<nullptr_t, T>)
    {
        if (p == nullopt) [[unlikely]] {
            Throw (e, "ThrowIfNull (nullopt) - throwing bad_optional_access"); // todo fix trace message to depend on 'E'
        }
    }
    template <Common::Weak_Equality_Comparable_With<nullopt_t> T>
    inline void ThrowIfNull (const T& p)
        requires (not equality_comparable_with<nullptr_t, T>)
    {
        static const bad_optional_access kException_;
        ThrowIfNull (p, kException_);
    }
 
    /*
     ********************************************************************************
     *************************** Execution::ThrowIfFailed ***************************
     ********************************************************************************
     */
    template <typename EXPECTED>
    inline auto ThrowIfFailed (const EXPECTED& e) -> typename EXPECTED::value_type
    {
        if (e) {
            return e.value ();
        }
        else {
            Throw (e.error ());
        }
    }
 
}