scope.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <exception>
#include <mutex>
#include <type_traits>
#include <utility>
 
namespace xrpl {
 
// RAII scope helpers.  As specified in Library Fundamental, Version 3
// Basic design of idea:  https://www.youtube.com/watch?v=WjTrfoiB0MQ
// Specification:
//   http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/n4873.html#scopeguard
 
// This implementation deviates from the spec slightly:
// The scope_exit and scope_fail constructors taking a functor are not
// permitted to throw an exception.  This was done because some compilers
// did not like the superfluous try/catch in the common instantiations
// where the construction was noexcept.  Instead a static_assert is used
// to enforce this restriction.
 
template <class EF>
class ScopeExit
{
    EF exitFunction_;
    bool executeOnDestruction_{true};
 
public:
    ~ScopeExit()
    {
        if (executeOnDestruction_)
            exitFunction_();
    }
 
    ScopeExit(ScopeExit&& rhs) noexcept(
        std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
        : exitFunction_{std::forward<EF>(rhs.exitFunction_)}
        , executeOnDestruction_{rhs.executeOnDestruction_}
    {
        rhs.release();
    }
 
    ScopeExit&
    operator=(ScopeExit&&) = delete;
 
    template <class EFP>
    explicit ScopeExit(EFP&& f) noexcept
        requires(
            !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> && std::is_constructible_v<EF, EFP>)
        : exitFunction_{std::forward<EFP>(f)}
    {
        static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
    }
 
    void
    release() noexcept
    {
        executeOnDestruction_ = false;
    }
};
 
template <class EF>
ScopeExit(EF) -> ScopeExit<EF>;
 
template <class EF>
class ScopeFail
{
    EF exitFunction_;
    bool executeOnDestruction_{true};
    int uncaughtOnCreation_{std::uncaught_exceptions()};
 
public:
    ~ScopeFail()
    {
        if (executeOnDestruction_ && std::uncaught_exceptions() > uncaughtOnCreation_)
            exitFunction_();
    }
 
    ScopeFail(ScopeFail&& rhs) noexcept(
        std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
        : exitFunction_{std::forward<EF>(rhs.exitFunction_)}
        , executeOnDestruction_{rhs.executeOnDestruction_}
        , uncaughtOnCreation_{rhs.uncaughtOnCreation_}
    {
        rhs.release();
    }
 
    ScopeFail&
    operator=(ScopeFail&&) = delete;
 
    template <class EFP>
    explicit ScopeFail(EFP&& f) noexcept
        requires(
            !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> && std::is_constructible_v<EF, EFP>)
        : exitFunction_{std::forward<EFP>(f)}
    {
        static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
    }
 
    void
    release() noexcept
    {
        executeOnDestruction_ = false;
    }
};
 
template <class EF>
ScopeFail(EF) -> ScopeFail<EF>;
 
template <class EF>
class ScopeSuccess
{
    EF exitFunction_;
    bool executeOnDestruction_{true};
    int uncaughtOnCreation_{std::uncaught_exceptions()};
 
public:
    ~ScopeSuccess() noexcept(noexcept(exitFunction_()))
    {
        if (executeOnDestruction_ && std::uncaught_exceptions() <= uncaughtOnCreation_)
            exitFunction_();
    }
 
    ScopeSuccess(ScopeSuccess&& rhs) noexcept(
        std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
        : exitFunction_{std::forward<EF>(rhs.exitFunction_)}
        , executeOnDestruction_{rhs.executeOnDestruction_}
        , uncaughtOnCreation_{rhs.uncaughtOnCreation_}
    {
        rhs.release();
    }
 
    ScopeSuccess&
    operator=(ScopeSuccess&&) = delete;
 
    template <class EFP>
    explicit ScopeSuccess(EFP&& f) noexcept(
        std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
        requires(
            !std::is_same_v<std::remove_cv_t<EFP>, ScopeSuccess> &&
            std::is_constructible_v<EF, EFP>)
        : exitFunction_{std::forward<EFP>(f)}
    {
    }
 
    void
    release() noexcept
    {
        executeOnDestruction_ = false;
    }
};
 
template <class EF>
ScopeSuccess(EF) -> ScopeSuccess<EF>;

 
template <class Mutex>
class ScopeUnlock
{
    std::unique_lock<Mutex>* plock_;
 
public:
    explicit ScopeUnlock(std::unique_lock<Mutex>& lock) noexcept(true) : plock_(&lock)
    {
        XRPL_ASSERT(plock_->owns_lock(), "xrpl::ScopeUnlock::ScopeUnlock : mutex must be locked");
        plock_->unlock();
    }
 
    // Immovable type
    ScopeUnlock(ScopeUnlock const&) = delete;
    ScopeUnlock&
    operator=(ScopeUnlock const&) = delete;
 
    ~ScopeUnlock() noexcept(true)
    {
        plock_->lock();
    }
};
 
template <class Mutex>
ScopeUnlock(std::unique_lock<Mutex>&) -> ScopeUnlock<Mutex>;
 
}  // namespace xrpl