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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/*
* Copyright Andrey Semashev 2007 - 2015.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*/
/*!
* \file once_block.hpp
* \author Andrey Semashev
* \date 23.06.2010
*
* \brief The header defines classes and macros for once-blocks.
*/
#ifndef BOOST_LOG_UTILITY_ONCE_BLOCK_HPP_INCLUDED_
#define BOOST_LOG_UTILITY_ONCE_BLOCK_HPP_INCLUDED_
#include <boost/log/detail/config.hpp>
#include <boost/log/utility/unique_identifier_name.hpp>
#include <boost/log/detail/header.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#ifndef BOOST_LOG_NO_THREADS
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
/*!
* \brief A flag to detect if a code block has already been executed.
*
* This structure should be used in conjunction with the \c BOOST_LOG_ONCE_BLOCK_FLAG
* macro. Usage example:
*
* <code>
* once_block_flag flag = BOOST_LOG_ONCE_BLOCK_INIT;
*
* void foo()
* {
* BOOST_LOG_ONCE_BLOCK_FLAG(flag)
* {
* puts("Hello, world once!");
* }
* }
* </code>
*/
struct once_block_flag
{
#ifndef BOOST_LOG_DOXYGEN_PASS
// Do not use, implementation detail
enum
{
uninitialized = 0, // this must be zero, so that zero-initialized once_block_flag is equivalent to the one initialized with uninitialized
being_initialized,
initialized
};
unsigned char status;
#endif // BOOST_LOG_DOXYGEN_PASS
};
/*!
* \def BOOST_LOG_ONCE_BLOCK_INIT
*
* The static initializer for \c once_block_flag.
*/
#define BOOST_LOG_ONCE_BLOCK_INIT { boost::log::once_block_flag::uninitialized }
namespace aux {
class once_block_sentry
{
private:
once_block_flag& m_flag;
public:
explicit once_block_sentry(once_block_flag& f) BOOST_NOEXCEPT : m_flag(f)
{
}
~once_block_sentry() BOOST_NOEXCEPT
{
if (BOOST_UNLIKELY(m_flag.status != once_block_flag::initialized))
rollback();
}
bool executed() const BOOST_NOEXCEPT
{
return (m_flag.status == once_block_flag::initialized || enter_once_block());
}
BOOST_LOG_API void commit() BOOST_NOEXCEPT;
private:
BOOST_LOG_API bool enter_once_block() const BOOST_NOEXCEPT;
BOOST_LOG_API void rollback() BOOST_NOEXCEPT;
// Non-copyable, non-assignable
BOOST_DELETED_FUNCTION(once_block_sentry(once_block_sentry const&))
BOOST_DELETED_FUNCTION(once_block_sentry& operator= (once_block_sentry const&))
};
} // namespace aux
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#else // BOOST_LOG_NO_THREADS
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
struct once_block_flag
{
bool status;
};
#define BOOST_LOG_ONCE_BLOCK_INIT { false }
namespace aux {
class once_block_sentry
{
private:
once_block_flag& m_flag;
public:
explicit once_block_sentry(once_block_flag& f) BOOST_NOEXCEPT : m_flag(f)
{
}
bool executed() const BOOST_NOEXCEPT
{
return m_flag.status;
}
void commit() BOOST_NOEXCEPT
{
m_flag.status = true;
}
// Non-copyable, non-assignable
BOOST_DELETED_FUNCTION(once_block_sentry(once_block_sentry const&))
BOOST_DELETED_FUNCTION(once_block_sentry& operator= (once_block_sentry const&))
};
} // namespace aux
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#endif // BOOST_LOG_NO_THREADS
#ifndef BOOST_LOG_DOXYGEN_PASS
#define BOOST_LOG_ONCE_BLOCK_FLAG_INTERNAL(flag_var, sentry_var)\
for (boost::log::aux::once_block_sentry sentry_var((flag_var));\
BOOST_UNLIKELY(!sentry_var.executed()); sentry_var.commit())
// NOTE: flag_var deliberately doesn't have an initializer so that it is zero-initialized at the static initialization stage
#define BOOST_LOG_ONCE_BLOCK_INTERNAL(flag_var, sentry_var)\
static boost::log::once_block_flag flag_var;\
BOOST_LOG_ONCE_BLOCK_FLAG_INTERNAL(flag_var, sentry_var)
#endif // BOOST_LOG_DOXYGEN_PASS
/*!
* \def BOOST_LOG_ONCE_BLOCK_FLAG(flag_var)
*
* Begins a code block to be executed only once, with protection against thread concurrency.
* User has to provide the flag variable that controls whether the block has already
* been executed.
*/
#define BOOST_LOG_ONCE_BLOCK_FLAG(flag_var)\
BOOST_LOG_ONCE_BLOCK_FLAG_INTERNAL(\
flag_var,\
BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_once_block_sentry_))
/*!
* \def BOOST_LOG_ONCE_BLOCK()
*
* Begins a code block to be executed only once, with protection against thread concurrency.
*/
#define BOOST_LOG_ONCE_BLOCK()\
BOOST_LOG_ONCE_BLOCK_INTERNAL(\
BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_once_block_flag_),\
BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_once_block_sentry_))
#include <boost/log/detail/footer.hpp>
#endif // BOOST_LOG_UTILITY_ONCE_BLOCK_HPP_INCLUDED_
|
