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 locking_ptr.hpp
9 * \author Andrey Semashev
10 * \date 15.07.2009
11 *
12 * This header is the Boost.Log library implementation, see the library documentation
13 * at http://www.boost.org/doc/libs/release/libs/log/doc/html/index.html.
14 */
15
16#ifndef BOOST_LOG_DETAIL_LOCKING_PTR_HPP_INCLUDED_
17#define BOOST_LOG_DETAIL_LOCKING_PTR_HPP_INCLUDED_
18
19#include <cstddef>
20#include <boost/move/core.hpp>
21#include <boost/smart_ptr/shared_ptr.hpp>
22#include <boost/thread/lock_options.hpp>
23#include <boost/core/explicit_operator_bool.hpp>
24#include <boost/log/detail/config.hpp>
25#include <boost/log/detail/header.hpp>
26
27#ifdef BOOST_HAS_PRAGMA_ONCE
28#pragma once
29#endif
30
31namespace boost {
32
33BOOST_LOG_OPEN_NAMESPACE
34
35namespace aux {
36
37//! A pointer type that locks the backend until it's destroyed
38template< typename T, typename LockableT >
39class locking_ptr
40{
41 typedef locking_ptr this_type;
42 BOOST_COPYABLE_AND_MOVABLE_ALT(this_type)
43
44public:
45 //! Pointed type
46 typedef T element_type;
47
48private:
49 //! Lockable type
50 typedef LockableT lockable_type;
51
52private:
53 //! The pointer to the backend
54 shared_ptr< element_type > m_pElement;
55 //! Reference to the shared lock control object
56 lockable_type* m_pLock;
57
58public:
59 //! Default constructor
60 locking_ptr() BOOST_NOEXCEPT : m_pLock(NULL)
61 {
62 }
63 //! Constructor
64 locking_ptr(shared_ptr< element_type > const& p, lockable_type& l) : m_pElement(p), m_pLock(&l)
65 {
66 m_pLock->lock();
67 }
68 //! Constructor
69 locking_ptr(shared_ptr< element_type > const& p, lockable_type& l, try_to_lock_t const&) : m_pElement(p), m_pLock(&l)
70 {
71 if (!m_pLock->try_lock())
72 {
73 m_pElement.reset();
74 m_pLock = NULL;
75 }
76 }
77 //! Copy constructor
78 locking_ptr(locking_ptr const& that) : m_pElement(that.m_pElement), m_pLock(that.m_pLock)
79 {
80 if (m_pLock)
81 m_pLock->lock();
82 }
83 //! Move constructor
84 locking_ptr(BOOST_RV_REF(this_type) that) BOOST_NOEXCEPT : m_pLock(that.m_pLock)
85 {
86 m_pElement.swap(that.m_pElement);
87 that.m_pLock = NULL;
88 }
89
90 //! Destructor
91 ~locking_ptr()
92 {
93 if (m_pLock)
94 m_pLock->unlock();
95 }
96
97 //! Assignment
98 locking_ptr& operator= (locking_ptr that) BOOST_NOEXCEPT
99 {
100 this->swap(that);
101 return *this;
102 }
103
104 //! Indirection
105 element_type* operator-> () const BOOST_NOEXCEPT { return m_pElement.get(); }
106 //! Dereferencing
107 element_type& operator* () const BOOST_NOEXCEPT { return *m_pElement; }
108
109 //! Accessor to the raw pointer
110 element_type* get() const BOOST_NOEXCEPT { return m_pElement.get(); }
111
112 //! Checks for null pointer
113 BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
114 //! Checks for null pointer
115 bool operator! () const BOOST_NOEXCEPT { return !m_pElement; }
116
117 //! Swaps two pointers
118 void swap(locking_ptr& that) BOOST_NOEXCEPT
119 {
120 m_pElement.swap(that.m_pElement);
121 lockable_type* p = m_pLock;
122 m_pLock = that.m_pLock;
123 that.m_pLock = p;
124 }
125};
126
127//! Free raw pointer getter to assist generic programming
128template< typename T, typename LockableT >
129inline T* get_pointer(locking_ptr< T, LockableT > const& p) BOOST_NOEXCEPT
130{
131 return p.get();
132}
133//! Free swap operation
134template< typename T, typename LockableT >
135inline void swap(locking_ptr< T, LockableT >& left, locking_ptr< T, LockableT >& right) BOOST_NOEXCEPT
136{
137 left.swap(right);
138}
139
140} // namespace aux
141
142BOOST_LOG_CLOSE_NAMESPACE // namespace log
143
144} // namespace boost
145
146#include <boost/log/detail/footer.hpp>
147
148#endif // BOOST_LOG_DETAIL_LOCKING_PTR_HPP_INCLUDED_
149

source code of boost/libs/log/include/boost/log/detail/locking_ptr.hpp