1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// *****************************************************************************
// * This file is part of the FreeFileSync project. It is distributed under *
// * GNU General Public License: https://www.gnu.org/licenses/gpl-3.0 *
// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
// *****************************************************************************
#ifndef SCOPE_GUARD_H_8971632487321434
#define SCOPE_GUARD_H_8971632487321434
#include <cassert>
#include <exception>
#include "type_traits.h"
#include "legacy_compiler.h" //std::uncaught_exceptions
//best of Zen, Loki and C++17
namespace zen
{
/* Scope Guard
auto guardAio = zen::makeGuard<ScopeGuardRunMode::onExit>([&] { ::CloseHandle(hDir); });
...
guardAio.dismiss();
Scope Exit:
ZEN_ON_SCOPE_EXIT (CleanUp());
ZEN_ON_SCOPE_FAIL (UndoPreviousWork());
ZEN_ON_SCOPE_SUCCESS(NotifySuccess()); */
enum class ScopeGuardRunMode
{
onExit,
onSuccess,
onFail
};
//partially specialize scope guard destructor code and get rid of those pesky MSVC "4127 conditional expression is constant"
template <typename F> inline
void runScopeGuardDestructor(F& fun, bool failed, std::integral_constant<ScopeGuardRunMode, ScopeGuardRunMode::onExit>)
{
if (!failed)
fun(); //throw X
else
try { fun(); }
catch (...) { assert(false); }
}
template <typename F> inline
void runScopeGuardDestructor(F& fun, bool failed, std::integral_constant<ScopeGuardRunMode, ScopeGuardRunMode::onSuccess>)
{
if (!failed)
fun(); //throw X
}
template <typename F> inline
void runScopeGuardDestructor(F& fun, bool failed, std::integral_constant<ScopeGuardRunMode, ScopeGuardRunMode::onFail>) noexcept
{
if (failed)
try { fun(); }
catch (...) { assert(false); }
}
template <ScopeGuardRunMode runMode, typename F>
class ScopeGuard
{
public:
explicit ScopeGuard(const F& fun) : fun_(fun) {}
explicit ScopeGuard( F&& fun) : fun_(std::move(fun)) {}
ScopeGuard(ScopeGuard&& tmp) :
fun_(std::move(tmp.fun_)),
exeptionCount_(tmp.exeptionCount_),
dismissed_(tmp.dismissed_) { tmp.dismissed_ = true; }
~ScopeGuard() noexcept(runMode == ScopeGuardRunMode::onFail)
{
if (!dismissed_)
{
const bool failed = std::uncaught_exceptions() > exeptionCount_;
runScopeGuardDestructor(fun_, failed, std::integral_constant<ScopeGuardRunMode, runMode>());
}
}
void dismiss() { dismissed_ = true; }
private:
ScopeGuard (const ScopeGuard&) = delete;
ScopeGuard& operator=(const ScopeGuard&) = delete;
F fun_;
const int exeptionCount_ = std::uncaught_exceptions();
bool dismissed_ = false;
};
template <ScopeGuardRunMode runMode, class F> inline
auto makeGuard(F&& fun) { return ScopeGuard<runMode, std::decay_t<F>>(std::forward<F>(fun)); }
}
#define ZEN_CONCAT_SUB(X, Y) X ## Y
#define ZEN_CONCAT(X, Y) ZEN_CONCAT_SUB(X, Y)
#define ZEN_CHECK_CASE_FOR_CONSTANT(X) case X: return ZEN_CHECK_CASE_FOR_CONSTANT_IMPL(#X)
#define ZEN_CHECK_CASE_FOR_CONSTANT_IMPL(X) L ## X
#define ZEN_ON_SCOPE_EXIT(X) [[maybe_unused]] auto ZEN_CONCAT(scopeGuard, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::onExit >([&]{ X; });
#define ZEN_ON_SCOPE_FAIL(X) [[maybe_unused]] auto ZEN_CONCAT(scopeGuard, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::onFail >([&]{ X; });
#define ZEN_ON_SCOPE_SUCCESS(X) [[maybe_unused]] auto ZEN_CONCAT(scopeGuard, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::onSuccess>([&]{ X; });
#endif //SCOPE_GUARD_H_8971632487321434
|
