//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2012-2012. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_INTERPROCESS_DETAIL_LOCKS_HPP
#define BOOST_INTERPROCESS_DETAIL_LOCKS_HPP

#ifndef BOOST_CONFIG_HPP
#  include <boost/config.hpp>
#endif
#
#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/detail/workaround.hpp>
#include <boost/interprocess/detail/posix_time_types_wrk.hpp>

namespace boost {
namespace interprocess {
namespace ipcdetail {

template<class Lock>
class internal_mutex_lock
{
   typedef void (internal_mutex_lock::*unspecified_bool_type)();
   public:

   typedef typename Lock::mutex_type::internal_mutex_type  mutex_type;


   BOOST_INTERPROCESS_FORCEINLINE internal_mutex_lock(Lock &l)
      : l_(l)
   {}

   BOOST_INTERPROCESS_FORCEINLINE mutex_type* mutex() const
   {  return l_ ? &l_.mutex()->internal_mutex() : 0;  }

   BOOST_INTERPROCESS_FORCEINLINE void lock()    { l_.lock(); }

   BOOST_INTERPROCESS_FORCEINLINE void unlock()  { l_.unlock(); }

   BOOST_INTERPROCESS_FORCEINLINE operator unspecified_bool_type() const
   {  return l_ ? &internal_mutex_lock::lock : 0;  }

   private:
   Lock &l_;
};

template <class Lock>
class lock_inverter
{
   Lock &l_;
   public:
   BOOST_INTERPROCESS_FORCEINLINE lock_inverter(Lock &l)
      :  l_(l)
   {}

   BOOST_INTERPROCESS_FORCEINLINE void lock()    {   l_.unlock();   }

   BOOST_INTERPROCESS_FORCEINLINE void unlock()  {   l_.lock();     }
};

template <class Lock>
class lock_to_sharable
{
   Lock &l_;

   public:
   BOOST_INTERPROCESS_FORCEINLINE explicit lock_to_sharable(Lock &l)
      :  l_(l)
   {}

   BOOST_INTERPROCESS_FORCEINLINE void lock()    {  l_.lock_sharable();     }

   BOOST_INTERPROCESS_FORCEINLINE bool try_lock(){  return l_.try_lock_sharable(); }

   BOOST_INTERPROCESS_FORCEINLINE void unlock()  {  l_.unlock_sharable();   }
};

template <class Lock>
class lock_to_wait
{
   Lock &l_;

   public:
   BOOST_INTERPROCESS_FORCEINLINE explicit lock_to_wait(Lock &l)
      :  l_(l)
   {}
   BOOST_INTERPROCESS_FORCEINLINE void lock()     {  l_.wait();     }

   BOOST_INTERPROCESS_FORCEINLINE bool try_lock() {  return l_.try_wait(); }

   BOOST_INTERPROCESS_FORCEINLINE bool timed_lock(const boost::posix_time::ptime &abs_time)
      {  return l_.timed_wait(abs_time);   }
};

}  //namespace ipcdetail
}  //namespace interprocess
}  //namespace boost

#include <boost/interprocess/detail/config_end.hpp>

#endif   //BOOST_INTERPROCESS_DETAIL_LOCKS_HPP