passenger 4.0.20 → 4.0.21

data/ext/boost/thread/future_error_code.hpp

@@ -0,0 +1,61 @@
+//  (C) Copyright 2008-10 Anthony Williams
+//  (C) Copyright 2011-2012 Vicente J. Botet Escriba
+//
+//  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)
+
+#ifndef BOOST_THREAD_FUTURE_ERROR_CODE_HPP
+#define BOOST_THREAD_FUTURE_ERROR_CODE_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/detail/scoped_enum_emulation.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+namespace boost
+{
+
+  //enum class future_errc
+  BOOST_SCOPED_ENUM_DECLARE_BEGIN(future_errc)
+  {
+      broken_promise = 1,
+      future_already_retrieved,
+      promise_already_satisfied,
+      no_state
+  }
+  BOOST_SCOPED_ENUM_DECLARE_END(future_errc)
+
+  namespace system
+  {
+    template <>
+    struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc> : public true_type {};
+
+    #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+    template <>
+    struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc::enum_type> : public true_type { };
+    #endif
+  } // system
+
+  BOOST_THREAD_DECL
+  const system::error_category& future_category() BOOST_NOEXCEPT;
+
+  namespace system
+  {
+    inline
+    error_code
+    make_error_code(future_errc e) BOOST_NOEXCEPT
+    {
+        return error_code(underlying_cast<int>(e), boost::future_category());
+    }
+
+    inline
+    error_condition
+    make_error_condition(future_errc e) BOOST_NOEXCEPT
+    {
+        return error_condition(underlying_cast<int>(e), future_category());
+    }
+  } // system
+} // boost
+
+#endif // header

data/ext/boost/thread/is_locked_by_this_thread.hpp

@@ -0,0 +1,39 @@
+// (C) Copyright 2012 Vicente J. Botet Escriba
+// 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)
+
+
+#ifndef BOOST_THREAD_IS_LOCKED_BY_THIS_THREAD_HPP
+#define BOOST_THREAD_IS_LOCKED_BY_THIS_THREAD_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+  template <typename Lockable>
+  class testable_mutex;
+
+  /**
+   * Overloaded function used to check if the mutex is locked when it is testable and do nothing otherwise.
+   *
+   * This function is used usually to assert the pre-condition when the function can only be called when the mutex
+   * must be locked by the current thread.
+   */
+  template <typename Lockable>
+  bool is_locked_by_this_thread(testable_mutex<Lockable> const& mtx)
+  {
+    return mtx.is_locked_by_this_thread();
+  }
+  template <typename Lockable>
+  bool is_locked_by_this_thread(Lockable const&)
+  {
+    return true;
+  }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif // header

data/ext/boost/thread/latch.hpp

@@ -0,0 +1,142 @@
+// 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 2013 Vicente J. Botet Escriba
+
+#ifndef BOOST_THREAD_LATCH_HPP
+#define BOOST_THREAD_LATCH_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/counter.hpp>
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/lock_types.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <boost/chrono/duration.hpp>
+#include <boost/chrono/time_point.hpp>
+#include <boost/assert.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+  class latch
+  {
+    /// @Requires: count_.value_ must be greater than 0
+    /// Effect: Decrement the count. Unlocks the lock notify anyone waiting if we reached zero.
+    /// Returns: true if count_.value_ reached the value 0.
+    /// @ThreadSafe ensured by the @c lk parameter
+    bool count_down(unique_lock<mutex> &lk)
+    /// pre_condition (count_.value_ > 0)
+    {
+      BOOST_ASSERT(count_.value_ > 0);
+      if (--count_.value_ == 0)
+      {
+        count_.cond_.notify_all();
+        lk.unlock();
+        return true;
+      }
+      return false;
+    }
+  public:
+    BOOST_THREAD_NO_COPYABLE( latch)
+
+    /// Constructs a latch with a given count.
+    latch(std::size_t count) :
+      count_(count)
+    {
+    }
+
+    /// Destructor
+    /// Precondition: No threads are waiting or invoking count_down on @c *this.
+
+    ~latch()
+    {
+
+    }
+
+    /// Blocks until the latch has counted down to zero.
+    void wait()
+    {
+      boost::unique_lock<boost::mutex> lk(mutex_);
+      count_.cond_.wait(lk, detail::counter_is_zero(count_));
+    }
+
+    /// @return true if the internal counter is already 0, false otherwise
+    bool try_wait()
+    {
+      boost::unique_lock<boost::mutex> lk(mutex_);
+      return (count_ == 0);
+    }
+
+    /// try to wait for a specified amount of time is elapsed.
+    /// @return whether there is a timeout or not.
+    template <class Rep, class Period>
+    cv_status wait_for(const chrono::duration<Rep, Period>& rel_time)
+    {
+      boost::unique_lock<boost::mutex> lk(mutex_);
+      return count_.cond_.wait_for(lk, rel_time, detail::counter_is_zero(count_))
+              ? cv_status::no_timeout
+              : cv_status::timeout;
+    }
+
+    /// try to wait until the specified time_point is reached
+    /// @return whether there were a timeout or not.
+    template <class Clock, class Duration>
+    cv_status wait_until(const chrono::time_point<Clock, Duration>& abs_time)
+    {
+      boost::unique_lock<boost::mutex> lk(mutex_);
+      return count_.cond_.wait_until(lk, abs_time, detail::counter_is_zero(count_))
+          ? cv_status::no_timeout
+          : cv_status::timeout;
+    }
+
+    /// Decrement the count and notify anyone waiting if we reach zero.
+    /// @Requires count must be greater than 0
+    void count_down()
+    {
+      boost::unique_lock<boost::mutex> lk(mutex_);
+      count_down(lk);
+    }
+    void signal()
+    {
+      count_down();
+    }
+
+    /// Decrement the count and notify anyone waiting if we reach zero.
+    /// Blocks until the latch has counted down to zero.
+    /// @Requires count must be greater than 0
+    void count_down_and_wait()
+    {
+      boost::unique_lock<boost::mutex> lk(mutex_);
+      if (count_down(lk))
+      {
+        return;
+      }
+      count_.cond_.wait(lk, detail::counter_is_zero(count_));
+    }
+    void sync()
+    {
+      count_down_and_wait();
+    }
+
+    /// Reset the counter
+    /// #Requires This method may only be invoked when there are no other threads currently inside the count_down_and_wait() method.
+    void reset(std::size_t count)
+    {
+      boost::lock_guard<boost::mutex> lk(mutex_);
+      //BOOST_ASSERT(count_ == 0);
+      count_ = count;
+    }
+
+  private:
+    mutex mutex_;
+    detail::counter count_;
+  };
+
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

data/ext/boost/thread/lock_algorithms.hpp

@@ -0,0 +1,468 @@
+// 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 <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