FM / thread

/usr/include/boost/thread

Name	Size	Mode	Actions
concurrent_queues/	-	0755	rm
csbl/	-	0755	rm
detail/	-	0755	rm
executors/	-	0755	rm
experimental/	-	0755	rm
futures/	-	0755	rm
pthread/	-	0755	rm
v2/	-	0755	rm
win32/	-	0755	rm
barrier.hpp	7421	0644	edit dl rm
caller_context.hpp	1526	0644	edit dl rm
completion_latch.hpp	6579	0644	edit dl rm
condition.hpp	490	0644	edit dl rm
condition_variable.hpp	634	0644	edit dl rm
cv_status.hpp	531	0644	edit dl rm
exceptional_ptr.hpp	1098	0644	edit dl rm
exceptions.hpp	6286	0644	edit dl rm
executor.hpp	476	0644	edit dl rm
externally_locked.hpp	10792	0644	edit dl rm
externally_locked_stream.hpp	4784	0644	edit dl rm
future.hpp	203792	0644	edit dl rm
interruption.hpp	596	0644	edit dl rm
is_locked_by_this_thread.hpp	1062	0644	edit dl rm
latch.hpp	4967	0644	edit dl rm
lockable_adapter.hpp	6043	0644	edit dl rm
lockable_concepts.hpp	4114	0644	edit dl rm
lockable_traits.hpp	7853	0644	edit dl rm
locks.hpp	572	0644	edit dl rm
lock_algorithms.hpp	13201	0644	edit dl rm
lock_concepts.hpp	4792	0644	edit dl rm
lock_factories.hpp	2317	0644	edit dl rm
lock_guard.hpp	2290	0644	edit dl rm
lock_options.hpp	701	0644	edit dl rm
lock_traits.hpp	1234	0644	edit dl rm
lock_types.hpp	34418	0644	edit dl rm
mutex.hpp	1166	0644	edit dl rm
null_mutex.hpp	6346	0644	edit dl rm
once.hpp	1324	0644	edit dl rm
ostream_buffer.hpp	925	0644	edit dl rm
poly_lockable.hpp	2100	0644	edit dl rm
poly_lockable_adapter.hpp	2124	0644	edit dl rm
poly_shared_lockable.hpp	5807	0644	edit dl rm
poly_shared_lockable_adapter.hpp	4792	0644	edit dl rm
recursive_mutex.hpp	1535	0644	edit dl rm
reverse_lock.hpp	1316	0644	edit dl rm
scoped_thread.hpp	8547	0644	edit dl rm
shared_lock_guard.hpp	1192	0644	edit dl rm
shared_mutex.hpp	1400	0644	edit dl rm
strict_lock.hpp	6246	0644	edit dl rm
synchronized_value.hpp	31110	0644	edit dl rm
sync_bounded_queue.hpp	595	0644	edit dl rm
sync_queue.hpp	571	0644	edit dl rm
testable_mutex.hpp	3925	0644	edit dl rm
thread.hpp	385	0644	edit dl rm
thread_functors.hpp	1366	0644	edit dl rm
thread_guard.hpp	1069	0644	edit dl rm
thread_only.hpp	803	0644	edit dl rm
thread_pool.hpp	531	0644	edit dl rm
thread_time.hpp	1590	0644	edit dl rm
tss.hpp	2603	0644	edit dl rm
user_scheduler.hpp	5222	0644	edit dl rm
with_lock_guard.hpp	6052	0644	edit dl rm
xtime.hpp	2390	0644	edit dl rm

Edit: /usr/include/boost/thread/lock_algorithms.hpp (13201B)

#ifndef BOOST_THREAD_LOCK_ALGORITHMS_HPP
#define BOOST_THREAD_LOCK_ALGORITHMS_HPP

#include <boost/thread/detail/config.hpp>
#include <boost/thread/lock_types.hpp>
#include <boost/thread/lockable_traits.hpp>

#include <algorithm>
#include <iterator>

#include <boost/config/abi_prefix.hpp>

namespace boost
{
  namespace detail
  {
    template <typename MutexType1, typename MutexType2>
    unsigned try_lock_internal(MutexType1& m1, MutexType2& m2)
    {
      boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
      if (!l1)
      {
        return 1;
      }
      if (!m2.try_lock())
      {
        return 2;
      }
      l1.release();
      return 0;
    }

template <typename MutexType1, typename MutexType2, typename MutexType3>
    unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3)
    {
      boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
      if (!l1)
      {
        return 1;
      }
      if (unsigned const failed_lock=try_lock_internal(m2,m3))
      {
        return failed_lock + 1;
      }
      l1.release();
      return 0;
    }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
    unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
    {
      boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
      if (!l1)
      {
        return 1;
      }
      if (unsigned const failed_lock=try_lock_internal(m2,m3,m4))
      {
        return failed_lock + 1;
      }
      l1.release();
      return 0;
    }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
    unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
    {
      boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
      if (!l1)
      {
        return 1;
      }
      if (unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
      {
        return failed_lock + 1;
      }
      l1.release();
      return 0;
    }

template <typename MutexType1, typename MutexType2>
    unsigned lock_helper(MutexType1& m1, MutexType2& m2)
    {
      boost::unique_lock<MutexType1> l1(m1);
      if (!m2.try_lock())
      {
        return 1;
      }
      l1.release();
      return 0;
    }

template <typename MutexType1, typename MutexType2, typename MutexType3>
    unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3)
    {
      boost::unique_lock<MutexType1> l1(m1);
      if (unsigned const failed_lock=try_lock_internal(m2,m3))
      {
        return failed_lock;
      }
      l1.release();
      return 0;
    }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
    unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
    {
      boost::unique_lock<MutexType1> l1(m1);
      if (unsigned const failed_lock=try_lock_internal(m2,m3,m4))
      {
        return failed_lock;
      }
      l1.release();
      return 0;
    }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
    unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
    {
      boost::unique_lock<MutexType1> l1(m1);
      if (unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
      {
        return failed_lock;
      }
      l1.release();
      return 0;
    }
  }

namespace detail
  {
    template <bool x>
    struct is_mutex_type_wrapper
    {
    };

template <typename MutexType1, typename MutexType2>
    void lock_impl(MutexType1& m1, MutexType2& m2, is_mutex_type_wrapper<true> )
    {
      unsigned const lock_count = 2;
      unsigned lock_first = 0;
      for (;;)
      {
        switch (lock_first)
        {
        case 0:
          lock_first = detail::lock_helper(m1, m2);
          if (!lock_first) return;
          break;
        case 1:
          lock_first = detail::lock_helper(m2, m1);
          if (!lock_first) return;
          lock_first = (lock_first + 1) % lock_count;
          break;
        }
      }
    }

template <typename Iterator>
    void lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> );
  }

template <typename MutexType1, typename MutexType2>
  void lock(MutexType1& m1, MutexType2& m2)
  {
    detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2>
  void lock(const MutexType1& m1, MutexType2& m2)
  {
    detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2>
  void lock(MutexType1& m1, const MutexType2& m2)
  {
    detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2>
  void lock(const MutexType1& m1, const MutexType2& m2)
  {
    detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2, typename MutexType3>
  void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3)
  {
    unsigned const lock_count = 3;
    unsigned lock_first = 0;
    for (;;)
    {
      switch (lock_first)
      {
      case 0:
        lock_first = detail::lock_helper(m1, m2, m3);
        if (!lock_first) return;
        break;
      case 1:
        lock_first = detail::lock_helper(m2, m3, m1);
        if (!lock_first) return;
        lock_first = (lock_first + 1) % lock_count;
        break;
      case 2:
        lock_first = detail::lock_helper(m3, m1, m2);
        if (!lock_first) return;
        lock_first = (lock_first + 2) % lock_count;
        break;
      }
    }
  }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
  void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
  {
    unsigned const lock_count = 4;
    unsigned lock_first = 0;
    for (;;)
    {
      switch (lock_first)
      {
      case 0:
        lock_first = detail::lock_helper(m1, m2, m3, m4);
        if (!lock_first) return;
        break;
      case 1:
        lock_first = detail::lock_helper(m2, m3, m4, m1);
        if (!lock_first) return;
        lock_first = (lock_first + 1) % lock_count;
        break;
      case 2:
        lock_first = detail::lock_helper(m3, m4, m1, m2);
        if (!lock_first) return;
        lock_first = (lock_first + 2) % lock_count;
        break;
      case 3:
        lock_first = detail::lock_helper(m4, m1, m2, m3);
        if (!lock_first) return;
        lock_first = (lock_first + 3) % lock_count;
        break;
      }
    }
  }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
  void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
  {
    unsigned const lock_count = 5;
    unsigned lock_first = 0;
    for (;;)
    {
      switch (lock_first)
      {
      case 0:
        lock_first = detail::lock_helper(m1, m2, m3, m4, m5);
        if (!lock_first) return;
        break;
      case 1:
        lock_first = detail::lock_helper(m2, m3, m4, m5, m1);
        if (!lock_first) return;
        lock_first = (lock_first + 1) % lock_count;
        break;
      case 2:
        lock_first = detail::lock_helper(m3, m4, m5, m1, m2);
        if (!lock_first) return;
        lock_first = (lock_first + 2) % lock_count;
        break;
      case 3:
        lock_first = detail::lock_helper(m4, m5, m1, m2, m3);
        if (!lock_first) return;
        lock_first = (lock_first + 3) % lock_count;
        break;
      case 4:
        lock_first = detail::lock_helper(m5, m1, m2, m3, m4);
        if (!lock_first) return;
        lock_first = (lock_first + 4) % lock_count;
        break;
      }
    }
  }

namespace detail
  {
    template <typename Mutex, bool x = is_mutex_type<Mutex>::value>
    struct try_lock_impl_return
    {
      typedef int type;
    };

template <typename Iterator>
    struct try_lock_impl_return<Iterator, false>
    {
      typedef Iterator type;
    };

template <typename MutexType1, typename MutexType2>
    int try_lock_impl(MutexType1& m1, MutexType2& m2, is_mutex_type_wrapper<true> )
    {
      return ((int) detail::try_lock_internal(m1, m2)) - 1;
    }

template <typename Iterator>
    Iterator try_lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> );
  }

template <typename MutexType1, typename MutexType2>
  typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1, MutexType2& m2)
  {
    return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2>
  typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1, MutexType2& m2)
  {
    return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2>
  typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1, const MutexType2& m2)
  {
    return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2>
  typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1, const MutexType2& m2)
  {
    return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
  }

template <typename MutexType1, typename MutexType2, typename MutexType3>
  int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3)
  {
    return ((int) detail::try_lock_internal(m1, m2, m3)) - 1;
  }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
  int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
  {
    return ((int) detail::try_lock_internal(m1, m2, m3, m4)) - 1;
  }

template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
  int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
  {
    return ((int) detail::try_lock_internal(m1, m2, m3, m4, m5)) - 1;
  }

namespace detail
  {
    template <typename Iterator>
    struct range_lock_guard
    {
      Iterator begin;
      Iterator end;

range_lock_guard(Iterator begin_, Iterator end_) :
        begin(begin_), end(end_)
      {
        boost::lock(begin, end);
      }

void release()
      {
        begin = end;
      }

~range_lock_guard()
      {
        for (; begin != end; ++begin)
        {
          begin->unlock();
        }
      }
    };

template <typename Iterator>
    Iterator try_lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> )

{
      if (begin == end)
      {
        return end;
      }
      typedef typename std::iterator_traits<Iterator>::value_type lock_type;
      unique_lock<lock_type> guard(*begin, try_to_lock);

if (!guard.owns_lock())
      {
        return begin;
      }
      Iterator const failed = boost::try_lock(++begin, end);
      if (failed == end)
      {
        guard.release();
      }

return failed;
    }
  }

namespace detail
  {
    template <typename Iterator>
    void lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> )
    {
      typedef typename std::iterator_traits<Iterator>::value_type lock_type;

if (begin == end)
      {
        return;
      }
      bool start_with_begin = true;
      Iterator second = begin;
      ++second;
      Iterator next = second;

for (;;)
      {
        unique_lock<lock_type> begin_lock(*begin, defer_lock);
        if (start_with_begin)
        {
          begin_lock.lock();
          Iterator const failed_lock = boost::try_lock(next, end);
          if (failed_lock == end)
          {
            begin_lock.release();
            return;
          }
          start_with_begin = false;
          next = failed_lock;
        }
        else
        {
          detail::range_lock_guard<Iterator> guard(next, end);
          if (begin_lock.try_lock())
          {
            Iterator const failed_lock = boost::try_lock(second, next);
            if (failed_lock == next)
            {
              begin_lock.release();
              guard.release();
              return;
            }
            start_with_begin = false;
            next = failed_lock;
          }
          else
          {
            start_with_begin = true;
            next = second;
          }
        }
      }
    }

}

}
#include <boost/config/abi_suffix.hpp>

#endif

// 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) // (C) Copyright 2007 Anthony Williams // (C) Copyright 2011-2012 Vicente J. Botet Escriba #ifndef BOOST_THREAD_LOCK_ALGORITHMS_HPP #define BOOST_THREAD_LOCK_ALGORITHMS_HPP #include #include #include #include #include #include namespace boost { namespace detail { template unsigned try_lock_internal(MutexType1& m1, MutexType2& m2) { boost::unique_lock l1(m1, boost::try_to_lock); if (!l1) { return 1; } if (!m2.try_lock()) { return 2; } l1.release(); return 0; } template unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3) { boost::unique_lock l1(m1, boost::try_to_lock); if (!l1) { return 1; } if (unsigned const failed_lock=try_lock_internal(m2,m3)) { return failed_lock + 1; } l1.release(); return 0; } template unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4) { boost::unique_lock l1(m1, boost::try_to_lock); if (!l1) { return 1; } if (unsigned const failed_lock=try_lock_internal(m2,m3,m4)) { return failed_lock + 1; } l1.release(); return 0; } template unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5) { boost::unique_lock l1(m1, boost::try_to_lock); if (!l1) { return 1; } if (unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5)) { return failed_lock + 1; } l1.release(); return 0; } template unsigned lock_helper(MutexType1& m1, MutexType2& m2) { boost::unique_lock l1(m1); if (!m2.try_lock()) { return 1; } l1.release(); return 0; } template unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3) { boost::unique_lock l1(m1); if (unsigned const failed_lock=try_lock_internal(m2,m3)) { return failed_lock; } l1.release(); return 0; } template unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4) { boost::unique_lock l1(m1); if (unsigned const failed_lock=try_lock_internal(m2,m3,m4)) { return failed_lock; } l1.release(); return 0; } template unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5) { boost::unique_lock l1(m1); if (unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5)) { return failed_lock; } l1.release(); return 0; } } namespace detail { template struct is_mutex_type_wrapper { }; template void lock_impl(MutexType1& m1, MutexType2& m2, is_mutex_type_wrapper ) { unsigned const lock_count = 2; unsigned lock_first = 0; for (;;) { switch (lock_first) { case 0: lock_first = detail::lock_helper(m1, m2); if (!lock_first) return; break; case 1: lock_first = detail::lock_helper(m2, m1); if (!lock_first) return; lock_first = (lock_first + 1) % lock_count; break; } } } template void lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper ); } template void lock(MutexType1& m1, MutexType2& m2) { detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template void lock(const MutexType1& m1, MutexType2& m2) { detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template void lock(MutexType1& m1, const MutexType2& m2) { detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template void lock(const MutexType1& m1, const MutexType2& m2) { detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3) { unsigned const lock_count = 3; unsigned lock_first = 0; for (;;) { switch (lock_first) { case 0: lock_first = detail::lock_helper(m1, m2, m3); if (!lock_first) return; break; case 1: lock_first = detail::lock_helper(m2, m3, m1); if (!lock_first) return; lock_first = (lock_first + 1) % lock_count; break; case 2: lock_first = detail::lock_helper(m3, m1, m2); if (!lock_first) return; lock_first = (lock_first + 2) % lock_count; break; } } } template void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4) { unsigned const lock_count = 4; unsigned lock_first = 0; for (;;) { switch (lock_first) { case 0: lock_first = detail::lock_helper(m1, m2, m3, m4); if (!lock_first) return; break; case 1: lock_first = detail::lock_helper(m2, m3, m4, m1); if (!lock_first) return; lock_first = (lock_first + 1) % lock_count; break; case 2: lock_first = detail::lock_helper(m3, m4, m1, m2); if (!lock_first) return; lock_first = (lock_first + 2) % lock_count; break; case 3: lock_first = detail::lock_helper(m4, m1, m2, m3); if (!lock_first) return; lock_first = (lock_first + 3) % lock_count; break; } } } template void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5) { unsigned const lock_count = 5; unsigned lock_first = 0; for (;;) { switch (lock_first) { case 0: lock_first = detail::lock_helper(m1, m2, m3, m4, m5); if (!lock_first) return; break; case 1: lock_first = detail::lock_helper(m2, m3, m4, m5, m1); if (!lock_first) return; lock_first = (lock_first + 1) % lock_count; break; case 2: lock_first = detail::lock_helper(m3, m4, m5, m1, m2); if (!lock_first) return; lock_first = (lock_first + 2) % lock_count; break; case 3: lock_first = detail::lock_helper(m4, m5, m1, m2, m3); if (!lock_first) return; lock_first = (lock_first + 3) % lock_count; break; case 4: lock_first = detail::lock_helper(m5, m1, m2, m3, m4); if (!lock_first) return; lock_first = (lock_first + 4) % lock_count; break; } } } namespace detail { template ::value> struct try_lock_impl_return { typedef int type; }; template struct try_lock_impl_return { typedef Iterator type; }; template int try_lock_impl(MutexType1& m1, MutexType2& m2, is_mutex_type_wrapper ) { return ((int) detail::try_lock_internal(m1, m2)) - 1; } template Iterator try_lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper ); } template typename detail::try_lock_impl_return::type try_lock(MutexType1& m1, MutexType2& m2) { return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template typename detail::try_lock_impl_return::type try_lock(const MutexType1& m1, MutexType2& m2) { return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template typename detail::try_lock_impl_return::type try_lock(MutexType1& m1, const MutexType2& m2) { return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template typename detail::try_lock_impl_return::type try_lock(const MutexType1& m1, const MutexType2& m2) { return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper::value>()); } template int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3) { return ((int) detail::try_lock_internal(m1, m2, m3)) - 1; } template int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4) { return ((int) detail::try_lock_internal(m1, m2, m3, m4)) - 1; } template int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5) { return ((int) detail::try_lock_internal(m1, m2, m3, m4, m5)) - 1; } namespace detail { template struct range_lock_guard { Iterator begin; Iterator end; range_lock_guard(Iterator begin_, Iterator end_) : begin(begin_), end(end_) { boost::lock(begin, end); } void release() { begin = end; } ~range_lock_guard() { for (; begin != end; ++begin) { begin->unlock(); } } }; template Iterator try_lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper ) { if (begin == end) { return end; } typedef typename std::iterator_traits::value_type lock_type; unique_lock guard(*begin, try_to_lock); if (!guard.owns_lock()) { return begin; } Iterator const failed = boost::try_lock(++begin, end); if (failed == end) { guard.release(); } return failed; } } namespace detail { template void lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper ) { typedef typename std::iterator_traits::value_type lock_type; if (begin == end) { return; } bool start_with_begin = true; Iterator second = begin; ++second; Iterator next = second; for (;;) { unique_lock begin_lock(*begin, defer_lock); if (start_with_begin) { begin_lock.lock(); Iterator const failed_lock = boost::try_lock(next, end); if (failed_lock == end) { begin_lock.release(); return; } start_with_begin = false; next = failed_lock; } else { detail::range_lock_guard guard(next, end); if (begin_lock.try_lock()) { Iterator const failed_lock = boost::try_lock(second, next); if (failed_lock == next) { begin_lock.release(); guard.release(); return; } start_with_begin = false; next = failed_lock; } else { start_with_begin = true; next = second; } } } } } } #include #endif