• For what is this class good for ?

    From Bonita Montero@3:633/10 to All on Wed Oct 8 18:48:34 2025
    template<typename First, typename ... Further>
    struct exc_xguard_unpack_last
    {
    using further = std::tuple<Further *...>;
    using type = typename exc_xguard_unpack_last<Further ...>::type;
    };

    template<typename Last>
    struct exc_xguard_unpack_last<Last>
    {
    using type = Last;
    };

    template<typename ... PassThrough>
    struct exc_xguard
    {
    template<typename Func, typename Nested>
    FORCEINLINE auto operator ()( Func func, Nested nested ) const
    {
    static_assert( sizeof ...(PassThrough) >= 1 );
    try
    {
    using return_type = std::invoke_result_t<Func>;
    return [&]<typename ... Pass>( this auto const &self, std::tuple<Pass
    *...> ) L_FORCEINLINE -> return_type
    {
    try
    {
    if constexpr( sizeof ...(Pass) == 1 )
    return func();
    else
    return self( typename exc_xguard_unpack_last<Pass ...>::further() );
    }
    catch( typename exc_xguard_unpack_last<Pass ...>::type & )
    {
    throw;
    }
    }( std::tuple<PassThrough *...>() );
    }
    catch( ... )
    {
    throw nested();
    }
    }
    };



    --- PyGate Linux v1.0
    * Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)
  • From Bonita Montero@3:633/10 to All on Wed Oct 8 19:07:09 2025
    Am 08.10.2025 um 18:48 schrieb Bonita Montero:

    ...
    template<typename ... PassThrough>
    struct exc_xguard
    {
    ˙˙˙˙template<typename Func, typename Nested>
    ˙˙˙˙FORCEINLINE auto operator ()( Func func, Nested nested ) const
    ˙˙˙˙{
    ˙˙˙˙˙˙˙ static_assert( sizeof ...(PassThrough) >= 1 );
    ˙˙˙˙˙˙˙ try
    ˙˙˙˙˙˙˙ {
    ˙˙˙˙˙˙˙˙˙˙˙ using return_type = std::invoke_result_t<Func>;
    ˙˙˙˙˙˙˙˙˙˙˙ return [&]<typename ... Pass>( this auto const &self, std::tuple<Pass *...> ) L_FORCEINLINE -> return_type
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ {
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ try
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ {
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ if constexpr( sizeof ...(Pass) == 1 )
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ return func();
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ else
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ return self( typename exc_xguard_unpack_last<Pass ...>::further() );
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ }
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ catch( typename
    exc_xguard_unpack_last<Pass ...>::type & )
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ {
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ throw;
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ }
    ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ }( std::tuple<PassThrough *...>() );
    ˙˙˙˙˙˙˙ }
    ˙˙˙˙˙˙˙ catch( ... )
    ˙˙˙˙˙˙˙ {
    ˙˙˙˙˙˙˙˙˙˙˙ throw nested();
    ˙˙˙˙˙˙˙ }
    ˙˙˙˙}
    };



    I forget a throw_with_nested:

    template<typename ... PassThrough>
    struct exc_xguard
    {
    template<typename Func, typename Nested>
    FORCEINLINE auto operator ()( Func func, Nested nested ) const
    {
    static_assert( sizeof ...(PassThrough) >= 1 );
    try
    {
    using return_type = std::invoke_result_t<Func>;
    return [&]<typename ... Pass>( this auto const &self, std::tuple<Pass
    *...> ) L_FORCEINLINE -> return_type
    {
    try
    {
    if constexpr( sizeof ...(Pass) == 1 )
    return func();
    else
    return self( typename exc_xguard_unpack_last<Pass ...>::further() );
    }
    catch( typename exc_xguard_unpack_last<Pass ...>::type & )
    {
    throw;
    }
    }( std::tuple<PassThrough *...>() );
    }
    catch( ... )
    {
    std::throw_with_nested( nested() );
    }
    }
    };

    --- PyGate Linux v1.0
    * Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)
  • From wij@3:633/10 to All on Thu Oct 9 01:45:22 2025
    On Wed, 2025-10-08 at 18:48 +0200, Bonita Montero wrote:
    template<typename First, typename ... Further>
    struct exc_xguard_unpack_last
    {
    using further = std::tuple<Further *...>;
    using type = typename exc_xguard_unpack_last<Further ...>::type;
    };

    template<typename Last>
    struct exc_xguard_unpack_last<Last>
    {
    using type = Last;
    };

    template<typename ... PassThrough>
    struct exc_xguard
    {
    template<typename Func, typename Nested>
    FORCEINLINE auto operator ()( Func func, Nested nested ) const
    {
    static_assert( sizeof ...(PassThrough) >= 1 );
    try
    {
    using return_type = std::invoke_result_t<Func>;
    return [&]<typename ... Pass>( this auto const &self, std::tuple<Pass

    *...> ) L_FORCEINLINE -> return_type
    {
    try
    {
    if constexpr( sizeof ...(Pass) == 1 )
    return func();
    else
    return self( typename exc_xguard_unpack_last<Pass ...>::further() );
    }
    catch( typename exc_xguard_unpack_last<Pass ...>::type & )
    {
    throw;
    }
    }( std::tuple<PassThrough *...>() );
    }
    catch( ... )
    {
    throw nested();
    }
    }
    };

    As usual, the code itself is meaningless (likely so?).
    What is the purpose of the codes, and useful in what environment/condition?

    C++ is expressive. But more importantly, expressive for what? If the author
    is
    not clear of the logic of his idea/concept, what would the 'expressive' mea
    n?
    That is the general C++ problem: It greatly helps writing obscure codes.


    --- PyGate Linux v1.0
    * Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)
  • From Bonita Montero@3:633/10 to All on Thu Oct 9 05:47:11 2025
    Am 08.10.2025 um 19:45 schrieb wij:

    As usual, the code itself is meaningless (likely so?).
    What is the purpose of the codes, and useful in what environment/condition?

    C++ is expressive. But more importantly, expressive for what? If the author is
    not clear of the logic of his idea/concept, what would the 'expressive' mean? That is the general C++ problem: It greatly helps writing obscure codes.

    For skilled C++-developers the purpose is easy to guess from the source.


    --- PyGate Linux v1.0
    * Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)