defer.h

#ifndef __DEFER_H
#define __DEFER_H
/* As posted by Oded Lazar, modified from StackOverflow user R. Martinho Fernandes, */
/*  and originally published by Andrei Alexandrescu and Petru Marginean in Dr. Dobbs
 *  December 2000 */
/* https://oded.blog/2017/10/05/go-defer-in-cpp/ */
/* https://stackoverflow.com/questions/10270328/the-simplest-and-neatest-c11-scopeguard/ */
/* http://www.drdobbs.com/cpp/generic-change-the-way-you-write-excepti/184403758 */
/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#include <functional>
#include <utility>
 
#define DEFER_CONCAT_(a, b) a##b
#define DEFER_CONCAT(a, b) DEFER_CONCAT_(a, b)
 
#define DEFER_CALL(fn) _ScopeGuard DEFER_CONCAT(__defer__, __LINE__) = [&]() { fn; };
 
class _ScopeGuard
{
   public:
    template<class Callable>
    _ScopeGuard(Callable &&fn) : fn_(std::forward<Callable>(fn))
    {
    }
 
    _ScopeGuard(_ScopeGuard &&other) : fn_(std::move(other.fn_)) { other.fn_ = nullptr; }
 
    ~_ScopeGuard()
    {
        // must not throw
        if (fn_) fn_();
    }
 
    _ScopeGuard(const _ScopeGuard &) = delete;
    void operator=(const _ScopeGuard &) = delete;
 
   private:
    std::function<void()> fn_;
};
 
#define IF_REENTERED(fn)                                            \
    static int DEFER_CONCAT(__reenter_guard_depth__, __LINE__) = 0; \
    _ReentrancyGuard DEFER_CONCAT(__reenter_guard__, __LINE__)(DEFER_CONCAT(__reenter_guard_depth__, __LINE__), [&]() { fn; });
 
class _ReentrancyGuard
{
   public:
    template<class Callable>
    _ReentrancyGuard(int &entered, Callable &&fn) : depth(entered)
    {
        if (depth) { fn(); }
        depth++;
    }
 
    _ReentrancyGuard(_ReentrancyGuard &&other) : depth(other.depth) {}
 
    ~_ReentrancyGuard() { depth--; }
 
    _ReentrancyGuard(const _ReentrancyGuard &) = delete;
    void operator=(const _ReentrancyGuard &) = delete;
 
   private:
    int &depth;
};
 
#endif /* ----- #ifndef __DEFER_H  ----- */