Re: Opinions on `defer`?

Am 09.01.2025 um 08:24 schrieb Bonita Montero:

Am 08.01.2025 um 23:39 schrieb Chris M. Thomasson:
 

Reminds me of ScopeGuard. ;^)

 But better than this. If you have multiple changes on a data structure
and the last fails the invoke_on_destruct-s are chained and revert the
changes incrementally.

I optimized the whole thing now a bit. Now I have two classed called
defer and xdefer. defer isn't chainable and xdefer is chainable.
#pragma once
#include <utility>
#include <concepts>
template<std::invocable Fn>
struct defer final
{
defer( Fn &&fn ) :
m_enabled( true ),
m_fn( std::forward<Fn>( fn ) )
{
}
defer( defer const & ) = delete;
~defer()
{
if( m_enabled ) [[likely]]
m_fn();
}
void operator ()()
{
if( !m_enabled ) [[unlikely]]
return;
m_fn();
m_enabled = false;
}
void disable()
{
m_enabled = false;
}
private:
bool m_enabled;
#if defined(_MSC_VER)
[[msvc::no_unique_address]]
#else
[[no_unique_address]]
#endif
Fn m_fn;
};
template<std::invocable Fn, std::invocable FnNext = Fn>
struct xdefer final
{
xdefer( Fn &&fn, xdefer<FnNext> *next = nullptr ) :
m_enabled( true ),
m_next( next ),
m_fn( std::forward<Fn>( fn ) )
{
}
xdefer( xdefer const & ) = delete;
~xdefer()
{
bool enabled = m_enabled;
if( m_next ) [[likely]]
m_next->m_enabled = enabled;
if( enabled ) [[likely]]
m_fn();
}
void operator ()()
{
if( !m_enabled ) [[unlikely]]
return;
m_fn();
m_enabled = false;
if( !m_next ) [[likely]]
return;
m_next->m_enabled = true;
(*m_next)();
}
void disable()
{
m_enabled = false;
}
private:
template<std::invocable Fn1, std::invocable Fn2>
friend struct xdefer;
bool m_enabled;
xdefer<FnNext> *m_next;
#if defined(_MSC_VER)
[[msvc::no_unique_address]]
#else
[[no_unique_address]]
#endif
Fn m_fn;
};