ceph/src/boost/libs/smart_ptr/include/boost/smart_ptr/detail/atomic_count_pt.hpp

   1 #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
   2 #define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
   3
   4 //
   5 //  boost/detail/atomic_count_pthreads.hpp
   6 //
   7 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
   8 //
   9 // Distributed under the Boost Software License, Version 1.0. (See
  10 // accompanying file LICENSE_1_0.txt or copy at
  11 // http://www.boost.org/LICENSE_1_0.txt)
  12 //
  13
  14 #include <boost/assert.hpp>
  15 #include <pthread.h>
  16
  17 //
  18 //  The generic pthread_mutex-based implementation sometimes leads to
  19 //    inefficiencies. Example: a class with two atomic_count members
  20 //    can get away with a single mutex.
  21 //
  22 //  Users can detect this situation by checking BOOST_AC_USE_PTHREADS.
  23 //
  24
  25 namespace boost
  26 {
  27
  28 namespace detail
  29 {
  30
  31 class atomic_count
  32 {
  33 private:
  34
  35     class scoped_lock
  36     {
  37     public:
  38
  39         scoped_lock(pthread_mutex_t & m): m_(m)
  40         {
  41             BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
  42         }
  43
  44         ~scoped_lock()
  45         {
  46             BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
  47         }
  48
  49     private:
  50
  51         pthread_mutex_t & m_;
  52     };
  53
  54 public:
  55
  56     explicit atomic_count(long v): value_(v)
  57     {
  58         BOOST_VERIFY( pthread_mutex_init( &mutex_, 0 ) == 0 );
  59     }
  60
  61     ~atomic_count()
  62     {
  63         BOOST_VERIFY( pthread_mutex_destroy( &mutex_ ) == 0 );
  64     }
  65
  66     long operator++()
  67     {
  68         scoped_lock lock(mutex_);
  69         return ++value_;
  70     }
  71
  72     long operator--()
  73     {
  74         scoped_lock lock(mutex_);
  75         return --value_;
  76     }
  77
  78     operator long() const
  79     {
  80         scoped_lock lock(mutex_);
  81         return value_;
  82     }
  83
  84 private:
  85
  86     atomic_count(atomic_count const &);
  87     atomic_count & operator=(atomic_count const &);
  88
  89     mutable pthread_mutex_t mutex_;
  90     long value_;
  91 };
  92
  93 } // namespace detail
  94
  95 } // namespace boost
  96
  97 #endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED