I'm sometimes doing multiple changes with more than a single data
structure which have to be reverted if the latest change throws an
exception. Until today I used my home-brew experimental::scope_guard
like class multiple times and I disabled each individual scope-object
when all changes have finished.
So I got the idea to concatenate multiple scope-guards and If i disable
the a child scope-guard in the chain all depending scope-guards also
will be disabled; re-enabling the latest scope-guard also propagates
through the chain. Disabling parent scope-guards won't have an effect,
i.e only the last enable-state in the chain counts. Enabling and dis-
abling is propagated to the immediate parent on destruction.

#pragma once#pragma once
#include <utility>

template<typename Fn>
struct invoke_on_destruct;

struct iod_base
{ private:
template<typename Fn>
friend struct invoke_on_destruct;
bool m_enabled;
iod_base *m_next;
iod_base( iod_base *next ) :
m_enabled( true ),
m_next( next )
{
}
};

template<typename Fn>
struct invoke_on_destruct final : public iod_base
{ private:
Fn m_fn;
public:
invoke_on_destruct( Fn &&fn, iod_base *next = nullptr )
requires requires( Fn fn ) { { fn() }; } :
iod_base( next ),
m_fn( std::forward<Fn>( fn ) )
{
}
~invoke_on_destruct()
{
// enable or disable parent node according to our state;
// use a conditional move for efficiency
bool enabled = (m_next ? m_next : this)->m_enabled = m_enabled;
// are we enabled ?
if( enabled ) [[unlikely]]
// yes: invoke
m_fn();
}
void disable()
{
m_enabled = false;
}
invoke_on_destruct &enable()
{
m_enabled = true;
}
};