/**
|
* Copyright 2016 Facebook
|
* @author Tudor Bosman (tudorb@fb.com)
|
*/
|
|
#pragma once
|
|
#include <cstddef>
|
#include <functional>
|
#include <new>
|
#include <type_traits>
|
#include <utility>
|
|
namespace caffe2 {
|
|
// Copied from folly/ScopeGuard.h
|
|
namespace detail {
|
|
class ScopeGuardImplBase {
|
public:
|
void dismiss() noexcept {
|
dismissed_ = true;
|
}
|
|
protected:
|
ScopeGuardImplBase() noexcept : dismissed_(false) {}
|
|
static ScopeGuardImplBase makeEmptyScopeGuard() noexcept {
|
return ScopeGuardImplBase{};
|
}
|
|
template <typename T>
|
static const T& asConst(const T& t) noexcept {
|
return t;
|
}
|
|
bool dismissed_;
|
};
|
|
template <typename FunctionType>
|
class ScopeGuardImpl : public ScopeGuardImplBase {
|
public:
|
explicit ScopeGuardImpl(FunctionType& fn) noexcept(
|
std::is_nothrow_copy_constructible<FunctionType>::value)
|
: ScopeGuardImpl(
|
asConst(fn),
|
makeFailsafe(std::is_nothrow_copy_constructible<FunctionType>{},
|
&fn)) {}
|
|
explicit ScopeGuardImpl(const FunctionType& fn) noexcept(
|
std::is_nothrow_copy_constructible<FunctionType>::value)
|
: ScopeGuardImpl(
|
fn,
|
makeFailsafe(std::is_nothrow_copy_constructible<FunctionType>{},
|
&fn)) {}
|
|
explicit ScopeGuardImpl(FunctionType&& fn) noexcept(
|
std::is_nothrow_move_constructible<FunctionType>::value)
|
: ScopeGuardImpl(
|
std::move_if_noexcept(fn),
|
makeFailsafe(std::is_nothrow_move_constructible<FunctionType>{},
|
&fn)) {}
|
|
ScopeGuardImpl(ScopeGuardImpl&& other) noexcept(
|
std::is_nothrow_move_constructible<FunctionType>::value)
|
: function_(std::move_if_noexcept(other.function_)) {
|
// If the above line attempts a copy and the copy throws, other is
|
// left owning the cleanup action and will execute it (or not) depending
|
// on the value of other.dismissed_. The following lines only execute
|
// if the move/copy succeeded, in which case *this assumes ownership of
|
// the cleanup action and dismisses other.
|
dismissed_ = other.dismissed_;
|
other.dismissed_ = true;
|
}
|
|
~ScopeGuardImpl() noexcept {
|
if (!dismissed_) {
|
execute();
|
}
|
}
|
|
private:
|
static ScopeGuardImplBase makeFailsafe(std::true_type, const void*) noexcept {
|
return makeEmptyScopeGuard();
|
}
|
|
template <typename Fn>
|
static auto makeFailsafe(std::false_type, Fn* fn) noexcept
|
-> ScopeGuardImpl<decltype(std::ref(*fn))> {
|
return ScopeGuardImpl<decltype(std::ref(*fn))>{std::ref(*fn)};
|
}
|
|
template <typename Fn>
|
explicit ScopeGuardImpl(Fn&& fn, ScopeGuardImplBase&& failsafe)
|
: ScopeGuardImplBase{}, function_(std::forward<Fn>(fn)) {
|
failsafe.dismiss();
|
}
|
|
void* operator new(std::size_t) = delete;
|
|
void execute() noexcept { function_(); }
|
|
FunctionType function_;
|
};
|
|
template <typename F>
|
using ScopeGuardImplDecay = ScopeGuardImpl<typename std::decay<F>::type>;
|
|
} // namespace detail
|
|
/**
|
* ScopeGuard is a general implementation of the "Initialization is
|
* Resource Acquisition" idiom. Basically, it guarantees that a function
|
* is executed upon leaving the currrent scope unless otherwise told.
|
*
|
* The MakeGuard() function is used to create a new ScopeGuard object.
|
* It can be instantiated with a lambda function, a std::function<void()>,
|
* a functor, or a void(*)() function pointer.
|
*
|
*
|
* Usage example: Add a friend to memory iff it is also added to the db.
|
*
|
* void User::addFriend(User& newFriend) {
|
* // add the friend to memory
|
* friends_.push_back(&newFriend);
|
*
|
* // If the db insertion that follows fails, we should
|
* // remove it from memory.
|
* auto guard = MakeGuard([&] { friends_.pop_back(); });
|
*
|
* // this will throw an exception upon error, which
|
* // makes the ScopeGuard execute UserCont::pop_back()
|
* // once the Guard's destructor is called.
|
* db_->addFriend(GetName(), newFriend.GetName());
|
*
|
* // an exception was not thrown, so don't execute
|
* // the Guard.
|
* guard.dismiss();
|
* }
|
*
|
* Examine ScopeGuardTest.cpp for some more sample usage.
|
*
|
* Stolen from:
|
* Andrei's and Petru Marginean's CUJ article:
|
* http://drdobbs.com/184403758
|
* and the loki library:
|
* http://loki-lib.sourceforge.net/index.php?n=Idioms.ScopeGuardPointer
|
* and triendl.kj article:
|
* http://www.codeproject.com/KB/cpp/scope_guard.aspx
|
*/
|
template <typename F>
|
detail::ScopeGuardImplDecay<F> MakeGuard(F&& f) noexcept(
|
noexcept(detail::ScopeGuardImplDecay<F>(static_cast<F&&>(f)))) {
|
return detail::ScopeGuardImplDecay<F>(static_cast<F&&>(f));
|
}
|
|
} // namespaces
|
