ceph/src/boost/boost/smart_ptr/intrusive_ref_counter.hpp

   1 /*
   2  *          Copyright Andrey Semashev 2007 - 2013.
   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   intrusive_ref_counter.hpp
   9  * \author Andrey Semashev
  10  * \date   12.03.2009
  11  *
  12  * This header contains a reference counter class for \c intrusive_ptr.
  13  */
  14
  15 #ifndef BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_
  16 #define BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_
  17
  18 #include <boost/config.hpp>
  19 #include <boost/smart_ptr/detail/atomic_count.hpp>
  20 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
  21
  22 #ifdef BOOST_HAS_PRAGMA_ONCE
  23 #pragma once
  24 #endif
  25
  26 #if defined(_MSC_VER)
  27 #pragma warning(push)
  28 // This is a bogus MSVC warning, which is flagged by friend declarations of intrusive_ptr_add_ref and intrusive_ptr_release in intrusive_ref_counter:
  29 // 'name' : the inline specifier cannot be used when a friend declaration refers to a specialization of a function template
  30 // Note that there is no inline specifier in the declarations.
  31 #pragma warning(disable: 4396)
  32 #endif
  33
  34 namespace boost {
  35
  36 namespace sp_adl_block {
  37
  38 /*!
  39  * \brief Thread unsafe reference counter policy for \c intrusive_ref_counter
  40  *
  41  * The policy instructs the \c intrusive_ref_counter base class to implement
  42  * a reference counter suitable for single threaded use only. Pointers to the same
  43  * object with this kind of reference counter must not be used by different threads.
  44  */
  45 struct thread_unsafe_counter
  46 {
  47     typedef unsigned int type;
  48
  49     static unsigned int load(unsigned int const& counter) BOOST_SP_NOEXCEPT
  50     {
  51         return counter;
  52     }
  53
  54     static void increment(unsigned int& counter) BOOST_SP_NOEXCEPT
  55     {
  56         ++counter;
  57     }
  58
  59     static unsigned int decrement(unsigned int& counter) BOOST_SP_NOEXCEPT
  60     {
  61         return --counter;
  62     }
  63 };
  64
  65 /*!
  66  * \brief Thread safe reference counter policy for \c intrusive_ref_counter
  67  *
  68  * The policy instructs the \c intrusive_ref_counter base class to implement
  69  * a thread-safe reference counter, if the target platform supports multithreading.
  70  */
  71 struct thread_safe_counter
  72 {
  73     typedef boost::detail::atomic_count type;
  74
  75     static unsigned int load(boost::detail::atomic_count const& counter) BOOST_SP_NOEXCEPT
  76     {
  77         return static_cast< unsigned int >(static_cast< long >(counter));
  78     }
  79
  80     static void increment(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
  81     {
  82         ++counter;
  83     }
  84
  85     static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
  86     {
  87         return static_cast< unsigned int >(--counter);
  88     }
  89 };
  90
  91 template< typename DerivedT, typename CounterPolicyT = thread_safe_counter >
  92 class intrusive_ref_counter;
  93
  94 template< typename DerivedT, typename CounterPolicyT >
  95 void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
  96 template< typename DerivedT, typename CounterPolicyT >
  97 void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
  98
  99 /*!
 100  * \brief A reference counter base class
 101  *
 102  * This base class can be used with user-defined classes to add support
 103  * for \c intrusive_ptr. The class contains a reference counter defined by the \c CounterPolicyT.
 104  * Upon releasing the last \c intrusive_ptr referencing the object
 105  * derived from the \c intrusive_ref_counter class, operator \c delete
 106  * is automatically called on the pointer to the object.
 107  *
 108  * The other template parameter, \c DerivedT, is the user's class that derives from \c intrusive_ref_counter.
 109  */
 110 template< typename DerivedT, typename CounterPolicyT >
 111 class intrusive_ref_counter
 112 {
 113 private:
 114     //! Reference counter type
 115     typedef typename CounterPolicyT::type counter_type;
 116     //! Reference counter
 117     mutable counter_type m_ref_counter;
 118
 119 public:
 120     /*!
 121      * Default constructor
 122      *
 123      * \post <tt>use_count() == 0</tt>
 124      */
 125     intrusive_ref_counter() BOOST_SP_NOEXCEPT : m_ref_counter(0)
 126     {
 127     }
 128
 129     /*!
 130      * Copy constructor
 131      *
 132      * \post <tt>use_count() == 0</tt>
 133      */
 134     intrusive_ref_counter(intrusive_ref_counter const&) BOOST_SP_NOEXCEPT : m_ref_counter(0)
 135     {
 136     }
 137
 138     /*!
 139      * Assignment
 140      *
 141      * \post The reference counter is not modified after assignment
 142      */
 143     intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_SP_NOEXCEPT { return *this; }
 144
 145     /*!
 146      * \return The reference counter
 147      */
 148     unsigned int use_count() const BOOST_SP_NOEXCEPT
 149     {
 150         return CounterPolicyT::load(m_ref_counter);
 151     }
 152
 153 protected:
 154     /*!
 155      * Destructor
 156      */
 157     BOOST_DEFAULTED_FUNCTION(~intrusive_ref_counter(), {})
 158
 159     friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 160     friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 161 };
 162
 163 template< typename DerivedT, typename CounterPolicyT >
 164 inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT
 165 {
 166     CounterPolicyT::increment(p->m_ref_counter);
 167 }
 168
 169 template< typename DerivedT, typename CounterPolicyT >
 170 inline void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT
 171 {
 172     if (CounterPolicyT::decrement(p->m_ref_counter) == 0)
 173         delete static_cast< const DerivedT* >(p);
 174 }
 175
 176 } // namespace sp_adl_block
 177
 178 using sp_adl_block::intrusive_ref_counter;
 179 using sp_adl_block::thread_unsafe_counter;
 180 using sp_adl_block::thread_safe_counter;
 181
 182 } // namespace boost
 183
 184 #if defined(_MSC_VER)
 185 #pragma warning(pop)
 186 #endif
 187
 188 #endif // BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_