sync/detail/locks.hpp

0001 //////////////////////////////////////////////////////////////////////////////
0002 //
0003 // (C) Copyright Ion Gaztanaga 2012-2012. Distributed under the Boost
0004 // Software License, Version 1.0. (See accompanying file
0005 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0006 //
0007 // See http://www.boost.org/libs/interprocess for documentation.
0008 //
0009 //////////////////////////////////////////////////////////////////////////////
0010
0011 #ifndef BOOST_INTERPROCESS_DETAIL_LOCKS_HPP
0012 #define BOOST_INTERPROCESS_DETAIL_LOCKS_HPP
0013
0014 #ifndef BOOST_CONFIG_HPP
0015 #  include <boost/config.hpp>
0016 #endif
0017 0018 ">#
0019 #if defined(BOOST_HAS_PRAGMA_ONCE)
0020 #  pragma once
0021 #endif
0022
0023 #include <boost/interprocess/detail/config_begin.hpp>
0024 #include <boost/interprocess/detail/workaround.hpp>
0025
0026 namespace boost {
0027 namespace interprocess {
0028 namespace ipcdetail {
0029
0030 template<class Lock>
0031 class internal_mutex_lock
0032 {
0033    typedef void (internal_mutex_lock::*unspecified_bool_type)();
0034    public:
0035
0036    typedef typename Lock::mutex_type::internal_mutex_type  mutex_type;
0037
0038
0039    BOOST_INTERPROCESS_FORCEINLINE internal_mutex_lock(Lock &l)
0040       : l_(l)
0041    {}
0042
0043    BOOST_INTERPROCESS_FORCEINLINE mutex_type* mutex() const
0044    {  return l_ ? &l_.mutex()->internal_mutex() : 0;  }
0045
0046    BOOST_INTERPROCESS_FORCEINLINE void lock()    { l_.lock(); }
0047
0048    BOOST_INTERPROCESS_FORCEINLINE void unlock()  { l_.unlock(); }
0049
0050    BOOST_INTERPROCESS_FORCEINLINE operator unspecified_bool_type() const
0051    {  return l_ ? &internal_mutex_lock::lock : 0;  }
0052
0053    private:
0054    Lock &l_;
0055 };
0056
0057 template <class Lock>
0058 class lock_inverter
0059 {
0060    Lock &l_;
0061    public:
0062    BOOST_INTERPROCESS_FORCEINLINE lock_inverter(Lock &l)
0063       :  l_(l)
0064    {}
0065
0066    BOOST_INTERPROCESS_FORCEINLINE void lock()    {   l_.unlock();   }
0067
0068    BOOST_INTERPROCESS_FORCEINLINE void unlock()  {   l_.lock();     }
0069 };
0070
0071 template <class Lock>
0072 class lock_to_sharable
0073 {
0074    Lock &l_;
0075
0076    public:
0077    BOOST_INTERPROCESS_FORCEINLINE explicit lock_to_sharable(Lock &l)
0078       :  l_(l)
0079    {}
0080
0081    BOOST_INTERPROCESS_FORCEINLINE void lock()    {  l_.lock_sharable();     }
0082
0083    BOOST_INTERPROCESS_FORCEINLINE bool try_lock(){  return l_.try_lock_sharable(); }
0084
0085    BOOST_INTERPROCESS_FORCEINLINE void unlock()  {  l_.unlock_sharable();   }
0086 };
0087
0088 template <class Lock>
0089 class lock_to_wait
0090 {
0091    Lock &l_;
0092
0093    public:
0094    BOOST_INTERPROCESS_FORCEINLINE explicit lock_to_wait(Lock &l)
0095       :  l_(l)
0096    {}
0097    BOOST_INTERPROCESS_FORCEINLINE void lock()     {  l_.wait();     }
0098
0099    BOOST_INTERPROCESS_FORCEINLINE bool try_lock() {  return l_.try_wait(); }
0100
0101    template<class TimePoint>
0102    BOOST_INTERPROCESS_FORCEINLINE bool timed_lock(const TimePoint &abs_time)
0103       {  return l_.timed_wait(abs_time);   }
0104 };
0105
0106 }  //namespace ipcdetail
0107 }  //namespace interprocess
0108 }  //namespace boost
0109
0110 #include <boost/interprocess/detail/config_end.hpp>
0111
0112 #endif   //BOOST_INTERPROCESS_DETAIL_LOCKS_HPP