scopeguard.h

Go to the documentation of this file.

 
#ifndef A_UTIL_SCOPEGUARD_HEADER_INCLUDED
#define A_UTIL_SCOPEGUARD_HEADER_INCLUDED
 
#include <exception>
#include <type_traits>
#include <utility>
 
#if ((defined _MSC_VER) && (_MSVC_LANG >= 201703L)) ||                                             \
    ((!defined _MSC_VER) && (__cplusplus >= 201703L))
// C++17 is required for std::uncaught_exceptions. Code using it is enabled conditionally.
// MSVC does not correctly set the value of __cplusplus. Therefore there is an extra test for
// MSVC in the preprocessor directive.
// See https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
#define A_UTIL_HAVE_UNCAUGHT_EXCEPTIONS
#define A_UTIL_HAVE_GUARANTEED_COPY_ELISION
#endif
 
namespace a_util {
 
template <class F>
class ScopeGuard {
public:
    ScopeGuard() = delete;
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;
    ScopeGuard& operator=(ScopeGuard&& other) = delete;
 
#ifdef A_UTIL_HAVE_GUARANTEED_COPY_ELISION
    ScopeGuard(ScopeGuard&&) = delete;
#else
    ScopeGuard(ScopeGuard&& other) : _enabled(other._enabled), _f(other._f)
    {
        other.dismiss();
    }
#endif // A_UTIL_HAVE_GUARANTEED_COPY_ELISION
 
    explicit ScopeGuard(F&& f) : _f(std::forward<F>(f))
    {
    }
 
    ~ScopeGuard()
    {
        if (_enabled) {
            _f();
        }
    }
 
    void dismiss() noexcept
    {
        _enabled = false;
    }
 
    void rehire() noexcept
    {
        _enabled = true;
    }
 
private:
    bool _enabled = true;
    typename std::decay<F>::type _f;
};
 
template <class F>
inline auto scopeExit(F&& f)
{
    return ScopeGuard<F>(std::forward<F>(f));
}
 
#ifdef A_UTIL_HAVE_UNCAUGHT_EXCEPTIONS
 
namespace detail {
 
template <class F, bool ExecuteOnFailure>
class ScopeGuard final : public ::a_util::ScopeGuard<F> {
public:
    explicit ScopeGuard(F&& f) : ::a_util::ScopeGuard<F>(std::forward<F>(f))
    {
    }
 
    ~ScopeGuard()
    {
        const auto uncaught_exceptions_on_exit = std::uncaught_exceptions();
        const auto success = _uncaught_exceptions_on_entry == uncaught_exceptions_on_exit;
        if (ExecuteOnFailure == success) {
            this->dismiss();
        }
    }
 
private:
    const int _uncaught_exceptions_on_entry = std::uncaught_exceptions();
};
 
} // namespace detail
template <class F>
inline auto scopeSuccess(F&& f)
{
    return detail::ScopeGuard<F, /*ExecuteOnFailure=*/false>(std::forward<F>(f));
}
 
template <class F>
inline auto scopeFailure(F&& f)
{
    return detail::ScopeGuard<F, /*ExecuteOnFailure=*/true>(std::forward<F>(f));
}
 
#endif // A_UTIL_HAVE_UNCAUGHT_EXCEPTIONS
 
} // namespace a_util
 
#endif // A_UTIL_SCOPEGUARD_HEADER_INCLUDED