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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// **************************************************************************
// * This file is part of the FreeFileSync project. It is distributed under *
// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 *
// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved *
// **************************************************************************
#ifndef SCOPE_GUARD_H_8971632487321434
#define SCOPE_GUARD_H_8971632487321434
#include <cassert>
#include <exception>
#include <type_traits> //std::decay
//best of Zen, Loki and C++17
#ifdef ZEN_WIN
inline int getUncaughtExceptionCount() { return std::uncaught_exceptions(); }
#elif defined ZEN_LINUX || defined ZEN_MAC
//std::uncaught_exceptions() currently unsupported on GCC and Clang => clean up ASAP
#ifdef ZEN_LINUX
static_assert(__GNUC__ < 5 || (__GNUC__ == 5 && (__GNUC_MINOR__ < 3 || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ <= 1))), "check std::uncaught_exceptions support");
#else
static_assert(__clang_major__ < 7 || (__clang_major__ == 7 && __clang_minor__ <= 3), "check std::uncaught_exceptions support");
#endif
namespace __cxxabiv1
{
struct __cxa_eh_globals;
extern "C" __cxa_eh_globals* __cxa_get_globals() noexcept;
}
inline int getUncaughtExceptionCount()
{
return *(reinterpret_cast<unsigned int*>(static_cast<char*>(static_cast<void*>(__cxxabiv1::__cxa_get_globals())) + sizeof(void*)));
}
#endif
namespace zen
{
//Scope Guard
/*
auto guardAio = zen::makeGuard<ScopeGuardRunMode::ON_EXIT>([&] { ::CloseHandle(hDir); });
...
guardAio.dismiss();
Scope Exit:
ZEN_ON_SCOPE_EXIT(::CloseHandle(hDir));
ZEN_ON_SCOPE_FAIL(UndoPreviousWork());
ZEN_ON_SCOPE_SUCCESS(NotifySuccess());
*/
enum class ScopeGuardRunMode
{
ON_EXIT,
ON_SUCCESS,
ON_FAIL
};
template <ScopeGuardRunMode runMode, typename F>
struct ScopeGuardDestructor;
//specialize scope guard destructor code and get rid of those pesky MSVC "4127 conditional expression is constant"
template <typename F>
struct ScopeGuardDestructor<ScopeGuardRunMode::ON_EXIT, F>
{
static void run(F& fun, int exeptionCountOld)
{
(void)exeptionCountOld; //silence unused parameter warning
try { fun(); }
catch (...) { assert(false); } //consistency: don't expect exceptions for ON_EXIT even if "!failed"!
}
};
template <typename F>
struct ScopeGuardDestructor<ScopeGuardRunMode::ON_SUCCESS, F>
{
static void run(F& fun, int exeptionCountOld)
{
const bool failed = getUncaughtExceptionCount() > exeptionCountOld;
if (!failed)
fun(); //throw X
}
};
template <typename F>
struct ScopeGuardDestructor<ScopeGuardRunMode::ON_FAIL, F>
{
static void run(F& fun, int exeptionCountOld)
{
const bool failed = getUncaughtExceptionCount() > exeptionCountOld;
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&& other) : fun_(std::move(other.fun_)),
exeptionCount(other.exeptionCount),
dismissed(other.dismissed) { other.dismissed = true; }
~ScopeGuard() noexcept(runMode != ScopeGuardRunMode::ON_SUCCESS)
{
if (!dismissed)
ScopeGuardDestructor<runMode, F>::run(fun_, exeptionCount);
}
void dismiss() { dismissed = true; }
private:
ScopeGuard (const ScopeGuard&) = delete;
ScopeGuard& operator=(const ScopeGuard&) = delete;
F fun_;
const int exeptionCount = getUncaughtExceptionCount();
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_ON_SCOPE_EXIT(X) auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_EXIT >([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
#define ZEN_ON_SCOPE_FAIL(X) auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_FAIL >([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
#define ZEN_ON_SCOPE_SUCCESS(X) auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_SUCCESS>([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
#endif //SCOPE_GUARD_H_8971632487321434
|
