ceph/src/boost/libs/log/include/boost/log/utility/once_block.hpp

   1 /*
   2  *          Copyright Andrey Semashev 2007 - 2015.
   3  * Distributed under the Boost Software License, Version 1.0.
   4  *    (See accompanying file LICENSE_1_0.txt or copy at
   5  *          http://www.boost.org/LICENSE_1_0.txt)
   6  */
   7 /*!
   8  * \file   once_block.hpp
   9  * \author Andrey Semashev
  10  * \date   23.06.2010
  11  *
  12  * \brief  The header defines classes and macros for once-blocks.
  13  */
  14
  15 #ifndef BOOST_LOG_UTILITY_ONCE_BLOCK_HPP_INCLUDED_
  16 #define BOOST_LOG_UTILITY_ONCE_BLOCK_HPP_INCLUDED_
  17
  18 #include <boost/log/detail/config.hpp>
  19 #include <boost/log/utility/unique_identifier_name.hpp>
  20 #include <boost/log/detail/header.hpp>
  21
  22 #ifdef BOOST_HAS_PRAGMA_ONCE
  23 #pragma once
  24 #endif
  25
  26 #ifndef BOOST_LOG_NO_THREADS
  27
  28 namespace boost {
  29
  30 BOOST_LOG_OPEN_NAMESPACE
  31
  32 /*!
  33  * \brief A flag to detect if a code block has already been executed.
  34  *
  35  * This structure should be used in conjunction with the \c BOOST_LOG_ONCE_BLOCK_FLAG
  36  * macro. Usage example:
  37  *
  38  * <code>
  39  * once_block_flag flag = BOOST_LOG_ONCE_BLOCK_INIT;
  40  *
  41  * void foo()
  42  * {
  43  *     BOOST_LOG_ONCE_BLOCK_FLAG(flag)
  44  *     {
  45  *         puts("Hello, world once!");
  46  *     }
  47  * }
  48  * </code>
  49  */
  50 struct once_block_flag
  51 {
  52 #ifndef BOOST_LOG_DOXYGEN_PASS
  53     // Do not use, implementation detail
  54     enum
  55     {
  56         uninitialized = 0, // this must be zero, so that zero-initialized once_block_flag is equivalent to the one initialized with uninitialized
  57         being_initialized,
  58         initialized
  59     };
  60     unsigned char status;
  61 #endif // BOOST_LOG_DOXYGEN_PASS
  62 };
  63
  64 /*!
  65  * \def BOOST_LOG_ONCE_BLOCK_INIT
  66  *
  67  * The static initializer for \c once_block_flag.
  68  */
  69 #define BOOST_LOG_ONCE_BLOCK_INIT { boost::log::once_block_flag::uninitialized }
  70
  71 namespace aux {
  72
  73 class once_block_sentry
  74 {
  75 private:
  76     once_block_flag& m_flag;
  77
  78 public:
  79     explicit once_block_sentry(once_block_flag& f) BOOST_NOEXCEPT : m_flag(f)
  80     {
  81     }
  82
  83     ~once_block_sentry() BOOST_NOEXCEPT
  84     {
  85         if (BOOST_UNLIKELY(m_flag.status != once_block_flag::initialized))
  86             rollback();
  87     }
  88
  89     bool executed() const BOOST_NOEXCEPT
  90     {
  91         return (m_flag.status == once_block_flag::initialized || enter_once_block());
  92     }
  93
  94     BOOST_LOG_API void commit() BOOST_NOEXCEPT;
  95
  96 private:
  97     BOOST_LOG_API bool enter_once_block() const BOOST_NOEXCEPT;
  98     BOOST_LOG_API void rollback() BOOST_NOEXCEPT;
  99
 100     //  Non-copyable, non-assignable
 101     BOOST_DELETED_FUNCTION(once_block_sentry(once_block_sentry const&))
 102     BOOST_DELETED_FUNCTION(once_block_sentry& operator= (once_block_sentry const&))
 103 };
 104
 105 } // namespace aux
 106
 107 BOOST_LOG_CLOSE_NAMESPACE // namespace log
 108
 109 } // namespace boost
 110
 111 #else // BOOST_LOG_NO_THREADS
 112
 113 namespace boost {
 114
 115 BOOST_LOG_OPEN_NAMESPACE
 116
 117 struct once_block_flag
 118 {
 119     bool status;
 120 };
 121
 122 #define BOOST_LOG_ONCE_BLOCK_INIT { false }
 123
 124 namespace aux {
 125
 126 class once_block_sentry
 127 {
 128 private:
 129     once_block_flag& m_flag;
 130
 131 public:
 132     explicit once_block_sentry(once_block_flag& f) BOOST_NOEXCEPT : m_flag(f)
 133     {
 134     }
 135
 136     bool executed() const BOOST_NOEXCEPT
 137     {
 138         return m_flag.status;
 139     }
 140
 141     void commit() BOOST_NOEXCEPT
 142     {
 143         m_flag.status = true;
 144     }
 145
 146     //  Non-copyable, non-assignable
 147     BOOST_DELETED_FUNCTION(once_block_sentry(once_block_sentry const&))
 148     BOOST_DELETED_FUNCTION(once_block_sentry& operator= (once_block_sentry const&))
 149 };
 150
 151 } // namespace aux
 152
 153 BOOST_LOG_CLOSE_NAMESPACE // namespace log
 154
 155 } // namespace boost
 156
 157 #endif // BOOST_LOG_NO_THREADS
 158
 159 #ifndef BOOST_LOG_DOXYGEN_PASS
 160
 161 #define BOOST_LOG_ONCE_BLOCK_FLAG_INTERNAL(flag_var, sentry_var)\
 162     for (boost::log::aux::once_block_sentry sentry_var((flag_var));\
 163         BOOST_UNLIKELY(!sentry_var.executed()); sentry_var.commit())
 164
 165 // NOTE: flag_var deliberately doesn't have an initializer so that it is zero-initialized at the static initialization stage
 166 #define BOOST_LOG_ONCE_BLOCK_INTERNAL(flag_var, sentry_var)\
 167     static boost::log::once_block_flag flag_var;\
 168     BOOST_LOG_ONCE_BLOCK_FLAG_INTERNAL(flag_var, sentry_var)
 169
 170 #endif // BOOST_LOG_DOXYGEN_PASS
 171
 172 /*!
 173  * \def BOOST_LOG_ONCE_BLOCK_FLAG(flag_var)
 174  *
 175  * Begins a code block to be executed only once, with protection against thread concurrency.
 176  * User has to provide the flag variable that controls whether the block has already
 177  * been executed.
 178  */
 179 #define BOOST_LOG_ONCE_BLOCK_FLAG(flag_var)\
 180     BOOST_LOG_ONCE_BLOCK_FLAG_INTERNAL(\
 181         flag_var,\
 182         BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_once_block_sentry_))
 183
 184 /*!
 185  * \def BOOST_LOG_ONCE_BLOCK()
 186  *
 187  * Begins a code block to be executed only once, with protection against thread concurrency.
 188  */
 189 #define BOOST_LOG_ONCE_BLOCK()\
 190     BOOST_LOG_ONCE_BLOCK_INTERNAL(\
 191         BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_once_block_flag_),\
 192         BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_once_block_sentry_))
 193
 194 #include <boost/log/detail/footer.hpp>
 195
 196 #endif // BOOST_LOG_UTILITY_ONCE_BLOCK_HPP_INCLUDED_