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 sources/threading_models.hpp 9 * \author Andrey Semashev 10 * \date 04.10.2008 11 * 12 * The header contains definition of threading models that can be used in loggers. 13 * The header also provides a number of tags that can be used to express lock requirements 14 * on a function callee. 15 */ 16 17 #ifndef BOOST_LOG_SOURCES_THREADING_MODELS_HPP_INCLUDED_ 18 #define BOOST_LOG_SOURCES_THREADING_MODELS_HPP_INCLUDED_ 19 20 #include <boost/type_traits/has_nothrow_constructor.hpp> 21 #include <boost/log/detail/config.hpp> 22 #include <boost/log/detail/locks.hpp> // is_mutex_type 23 #if !defined(BOOST_LOG_NO_THREADS) 24 #include <boost/mpl/bool.hpp> 25 #endif 26 #include <boost/log/detail/header.hpp> 27 28 #ifdef BOOST_HAS_PRAGMA_ONCE 29 #pragma once 30 #endif 31 32 namespace boost { 33 34 BOOST_LOG_OPEN_NAMESPACE 35 36 namespace sources { 37 38 //! Single thread locking model 39 struct single_thread_model 40 { 41 // We provide methods for the most advanced locking concept: UpgradeLockable lock_sharedboost::sources::single_thread_model42 void lock_shared() const BOOST_NOEXCEPT {} try_lock_sharedboost::sources::single_thread_model43 bool try_lock_shared() const BOOST_NOEXCEPT { return true; } 44 template< typename TimeT > timed_lock_sharedboost::sources::single_thread_model45 bool timed_lock_shared(TimeT const&) const BOOST_NOEXCEPT { return true; } unlock_sharedboost::sources::single_thread_model46 void unlock_shared() const BOOST_NOEXCEPT {} lockboost::sources::single_thread_model47 void lock() const BOOST_NOEXCEPT {} try_lockboost::sources::single_thread_model48 bool try_lock() const BOOST_NOEXCEPT { return true; } 49 template< typename TimeT > timed_lockboost::sources::single_thread_model50 bool timed_lock(TimeT const&) const BOOST_NOEXCEPT { return true; } unlockboost::sources::single_thread_model51 void unlock() const BOOST_NOEXCEPT {} lock_upgradeboost::sources::single_thread_model52 void lock_upgrade() const BOOST_NOEXCEPT {} try_lock_upgradeboost::sources::single_thread_model53 bool try_lock_upgrade() const BOOST_NOEXCEPT { return true; } 54 template< typename TimeT > timed_lock_upgradeboost::sources::single_thread_model55 bool timed_lock_upgrade(TimeT const&) const BOOST_NOEXCEPT { return true; } unlock_upgradeboost::sources::single_thread_model56 void unlock_upgrade() const BOOST_NOEXCEPT {} unlock_upgrade_and_lockboost::sources::single_thread_model57 void unlock_upgrade_and_lock() const BOOST_NOEXCEPT {} unlock_and_lock_upgradeboost::sources::single_thread_model58 void unlock_and_lock_upgrade() const BOOST_NOEXCEPT {} unlock_and_lock_sharedboost::sources::single_thread_model59 void unlock_and_lock_shared() const BOOST_NOEXCEPT {} unlock_upgrade_and_lock_sharedboost::sources::single_thread_model60 void unlock_upgrade_and_lock_shared() const BOOST_NOEXCEPT {} 61 swapboost::sources::single_thread_model62 void swap(single_thread_model&) BOOST_NOEXCEPT {} 63 }; 64 swap(single_thread_model &,single_thread_model &)65inline void swap(single_thread_model&, single_thread_model&) BOOST_NOEXCEPT 66 { 67 } 68 69 #if !defined(BOOST_LOG_NO_THREADS) 70 71 //! Multi-thread locking model with maximum locking capabilities 72 template< typename MutexT > 73 struct multi_thread_model 74 { BOOST_NOEXCEPT_IFboost::sources::multi_thread_model75 multi_thread_model() BOOST_NOEXCEPT_IF(boost::has_nothrow_constructor< MutexT >::value) {} BOOST_NOEXCEPT_IFboost::sources::multi_thread_model76 multi_thread_model(multi_thread_model const&) BOOST_NOEXCEPT_IF(boost::has_nothrow_constructor< MutexT >::value) {} operator =boost::sources::multi_thread_model77 multi_thread_model& operator= (multi_thread_model const&) BOOST_NOEXCEPT { return *this; } 78 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) BOOST_NOEXCEPT_IFboost::sources::multi_thread_model79 multi_thread_model(multi_thread_model&&) BOOST_NOEXCEPT_IF(boost::has_nothrow_constructor< MutexT >::value) {} operator =boost::sources::multi_thread_model80 multi_thread_model& operator= (multi_thread_model&&) BOOST_NOEXCEPT { return *this; } 81 #endif 82 lock_sharedboost::sources::multi_thread_model83 void lock_shared() const { m_Mutex.lock_shared(); } try_lock_sharedboost::sources::multi_thread_model84 bool try_lock_shared() const { return m_Mutex.try_lock_shared(); } 85 template< typename TimeT > timed_lock_sharedboost::sources::multi_thread_model86 bool timed_lock_shared(TimeT const& t) const { return m_Mutex.timed_lock_shared(t); } unlock_sharedboost::sources::multi_thread_model87 void unlock_shared() const BOOST_NOEXCEPT { m_Mutex.unlock_shared(); } lockboost::sources::multi_thread_model88 void lock() const { m_Mutex.lock(); } try_lockboost::sources::multi_thread_model89 bool try_lock() const { return m_Mutex.try_lock(); } 90 template< typename TimeT > timed_lockboost::sources::multi_thread_model91 bool timed_lock(TimeT const& t) const { return m_Mutex.timed_lock(t); } unlockboost::sources::multi_thread_model92 void unlock() const BOOST_NOEXCEPT { m_Mutex.unlock(); } lock_upgradeboost::sources::multi_thread_model93 void lock_upgrade() const { m_Mutex.lock_upgrade(); } try_lock_upgradeboost::sources::multi_thread_model94 bool try_lock_upgrade() const { return m_Mutex.try_lock_upgrade(); } 95 template< typename TimeT > timed_lock_upgradeboost::sources::multi_thread_model96 bool timed_lock_upgrade(TimeT const& t) const { return m_Mutex.timed_lock_upgrade(t); } unlock_upgradeboost::sources::multi_thread_model97 void unlock_upgrade() const BOOST_NOEXCEPT { m_Mutex.unlock_upgrade(); } unlock_upgrade_and_lockboost::sources::multi_thread_model98 void unlock_upgrade_and_lock() const { m_Mutex.unlock_upgrade_and_lock(); } unlock_and_lock_upgradeboost::sources::multi_thread_model99 void unlock_and_lock_upgrade() const { m_Mutex.unlock_and_lock_upgrade(); } unlock_and_lock_sharedboost::sources::multi_thread_model100 void unlock_and_lock_shared() const { m_Mutex.unlock_and_lock_shared(); } unlock_upgrade_and_lock_sharedboost::sources::multi_thread_model101 void unlock_upgrade_and_lock_shared() const { m_Mutex.unlock_upgrade_and_lock_shared(); } 102 swapboost::sources::multi_thread_model103 void swap(multi_thread_model&) BOOST_NOEXCEPT {} 104 105 private: 106 //! Synchronization primitive 107 mutable MutexT m_Mutex; 108 }; 109 110 template< typename MutexT > swap(multi_thread_model<MutexT> &,multi_thread_model<MutexT> &)111inline void swap(multi_thread_model< MutexT >&, multi_thread_model< MutexT >&) BOOST_NOEXCEPT 112 { 113 } 114 115 #endif // !defined(BOOST_LOG_NO_THREADS) 116 117 } // namespace sources 118 119 BOOST_LOG_CLOSE_NAMESPACE // namespace log 120 121 #if !defined(BOOST_LOG_NO_THREADS) && !defined(BOOST_LOG_DOXYGEN_PASS) 122 123 template< > 124 struct is_mutex_type< boost::log::sources::single_thread_model > : mpl::true_ 125 { 126 }; 127 128 template< typename T > 129 struct is_mutex_type< boost::log::sources::multi_thread_model< T > > : mpl::true_ 130 { 131 }; 132 133 #endif // !defined(BOOST_LOG_NO_THREADS) 134 135 } // namespace boost 136 137 #include <boost/log/detail/footer.hpp> 138 139 #endif // BOOST_LOG_SOURCES_THREADING_MODELS_HPP_INCLUDED_ 140