passenger 4.0.20 → 4.0.21

data/ext/boost/thread/mutex.hpp

@@ -3,7 +3,7 @@
 
 //  mutex.hpp
 //
-//  (C) Copyright 2007 Anthony Williams 
+//  (C) Copyright 2007 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -18,4 +18,36 @@
 #error "Boost threads unavailable on this platform"
 #endif
 
+#include <boost/thread/lockable_traits.hpp>
+
+
+namespace boost
+{
+  namespace sync
+  {
+#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
+    template<>
+    struct is_basic_lockable<mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_lockable<mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_basic_lockable<timed_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_lockable<timed_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+#endif
+  }
+}
+
 #endif

data/ext/boost/thread/null_mutex.hpp

@@ -0,0 +1,243 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009,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/thread for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_THREAD_NULL_MUTEX_HPP
+#define BOOST_THREAD_NULL_MUTEX_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/chrono/chrono.hpp>
+
+/// \file
+/// Describes null_mutex class
+
+namespace boost
+{
+
+  /// Implements a mutex that simulates a mutex without doing any operation and
+  /// simulates a successful operation.
+  class null_mutex
+  {
+  public:
+
+    BOOST_THREAD_NO_COPYABLE( null_mutex) /*< no copyable >*/
+
+    null_mutex() {}
+
+    /// Simulates a mutex lock() operation. Empty function.
+    void lock()
+    {
+    }
+
+    /// Simulates a mutex try_lock() operation.
+    /// Equivalent to "return true;"
+    bool try_lock()
+    {
+      return true;
+    }
+
+    /// Simulates a mutex unlock() operation.
+    /// Empty function.
+    void unlock()
+    {
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_lock_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_lock_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_lock_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_lock_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates a mutex lock_shared() operation.
+    /// Empty function.
+    void lock_shared()
+    {
+    }
+
+    /// Simulates a mutex try_lock_shared() operation.
+    /// Equivalent to "return true;"
+    bool try_lock_shared()
+    {
+      return true;
+    }
+
+    /// Simulates a mutex unlock_shared() operation.
+    /// Empty function.
+    void unlock_shared()
+    {
+    }
+
+    /// Simulates a mutex try_lock_shared_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_lock_shared_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+    /// Simulates a mutex try_lock_shared_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_lock_shared_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex lock_upgrade() operation.
+    /// Empty function.
+    void lock_upgrade()
+    {
+    }
+
+    /// Simulates a mutex try_lock_upgrade() operation.
+    /// Equivalent to "return true;"
+    bool try_lock_upgrade()
+    {
+      return true;
+    }
+
+    /// Simulates a mutex unlock_upgrade() operation.
+    /// Empty function.
+    void unlock_upgrade()
+    {
+    }
+
+    /// Simulates a mutex try_lock_upgrade_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_lock_upgrade_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_lock_upgrade_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_lock_upgrade_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock() operation.
+    /// Equivalent to "return true;"
+    bool try_unlock_shared_and_lock()
+    {
+      return true;
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_unlock_shared_and_lock_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_unlock_shared_and_lock_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_unlock_shared_and_lock_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates unlock_and_lock_shared().
+    /// Empty function.
+    void unlock_and_lock_shared()
+    {
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock_upgrade() operation.
+    /// Equivalent to "return true;"
+    bool try_unlock_shared_and_lock_upgrade()
+    {
+      return true;
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_unlock_shared_and_lock_upgrade_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock_upgrade_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_unlock_shared_and_lock_upgrade_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates unlock_and_lock_upgrade().
+    /// Empty function.
+    void unlock_and_lock_upgrade()
+    {
+    }
+
+    /// Simulates unlock_upgrade_and_lock().
+    /// Empty function.
+    void unlock_upgrade_and_lock()
+    {
+    }
+
+    /// Simulates a mutex try_unlock_upgrade_and_lock() operation.
+    /// Equivalent to "return true;"
+    bool try_unlock_upgrade_and_lock()
+    {
+      return true;
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_unlock_upgrade_and_lock_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_unlock_upgrade_and_lock_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_upgrade_and_lock_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_unlock_upgrade_and_lock_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates unlock_upgrade_and_lock_shared().
+    /// Empty function.
+    void unlock_upgrade_and_lock_shared()
+    {
+    }
+
+  };
+
+} //namespace boost {
+
+
+#endif

data/ext/boost/thread/once.hpp

@@ -9,11 +9,18 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/thread/detail/config.hpp>
 #include <boost/thread/detail/platform.hpp>
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
 #include <boost/thread/win32/once.hpp>
 #elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#if defined BOOST_THREAD_ONCE_FAST_EPOCH
 #include <boost/thread/pthread/once.hpp>
+#elif defined BOOST_THREAD_ONCE_ATOMIC
+#include <boost/thread/pthread/once_atomic.hpp>
+#else
+#error "Once Not Implemented"
+#endif
 #else
 #error "Boost threads unavailable on this platform"
 #endif
@@ -24,7 +31,9 @@ namespace boost
 {
   // template<class Callable, class ...Args> void
   // call_once(once_flag& flag, Callable&& func, Args&&... args);
-    inline void call_once(void (*func)(),once_flag& flag)
+template<typename Function>
+inline void call_once(Function func,once_flag& flag)
+//inline void call_once(void (*func)(),once_flag& flag)
     {
         call_once(flag,func);
     }

data/ext/boost/thread/poly_lockable.hpp

@@ -0,0 +1,68 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009,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/thread for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_THREAD_POLY_LOCKABLE_HPP
+#define BOOST_THREAD_POLY_LOCKABLE_HPP
+
+#include <boost/thread/detail/delete.hpp>
+#include <boost/chrono/chrono.hpp>
+
+namespace boost
+{
+
+  //[basic_poly_lockable
+  class basic_poly_lockable
+  {
+  public:
+
+    virtual ~basic_poly_lockable() = 0;
+
+    virtual void lock() = 0;
+    virtual void unlock() = 0;
+
+  };
+  //]
+
+  //[poly_lockable
+  class poly_lockable : public basic_poly_lockable<Lockable>
+  {
+  public:
+
+    virtual ~poly_lockable() = 0;
+    virtual bool try_lock() = 0;
+  };
+  //]
+
+  //[timed_poly_lockable
+  class timed_poly_lockable: public poly_lockable<TimedLock>
+  {
+  public:
+    virtual ~timed_poly_lockable()=0;
+
+    virtual bool try_lock_until(chrono::system_clock::time_point const & abs_time)=0;
+    virtual bool try_lock_until(chrono::steady_clock::time_point const & abs_time)=0;
+    template <typename Clock, typename Duration>
+    bool try_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
+    {
+      return try_lock_until(time_point_cast<Clock::time_point>(abs_time));
+    }
+
+    virtual bool try_lock_for(chrono::nanoseconds const & relative_time)=0;
+    template <typename Rep, typename Period>
+    bool try_lock_for(chrono::duration<Rep, Period> const & rel_time)
+    {
+      return try_lock_for(duration_cast<Clock::duration>(rel_time));
+    }
+
+  };
+  //]
+
+}
+#endif

data/ext/boost/thread/poly_lockable_adapter.hpp

@@ -0,0 +1,89 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009,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/thread for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_THREAD_POLY_LOCKABLE_ADAPTER_HPP
+#define BOOST_THREAD_POLY_LOCKABLE_ADAPTER_HPP
+
+#include <boost/thread/poly_lockable.hpp>
+
+namespace boost
+{
+
+  //[poly_basic_lockable_adapter
+  template <typename Mutex, typename Base=poly_basic_lockable>
+  class poly_basic_lockable_adapter : public Base
+  {
+  public:
+    typedef Mutex mutex_type;
+
+  protected:
+    mutex_type& mtx() const
+    {
+      return mtx_;
+    }
+    mutable mutex_type mtx_; /*< mutable so that it can be modified by const functions >*/
+  public:
+
+    BOOST_THREAD_NO_COPYABLE( poly_basic_lockable_adapter) /*< no copyable >*/
+
+    poly_basic_lockable_adapter()
+    {}
+
+    void lock()
+    {
+      mtx().lock();
+    }
+    void unlock()
+    {
+      mtx().unlock();
+    }
+
+  };
+  //]
+
+  //[poly_lockable_adapter
+  template <typename Mutex, typename Base=poly_lockable>
+  class poly_lockable_adapter : public poly_basic_lockable_adapter<Mutex, Base>
+  {
+  public:
+    typedef Mutex mutex_type;
+
+    bool try_lock()
+    {
+      return this->mtx().try_lock();
+    }
+  };
+  //]
+
+  //[poly_timed_lockable_adapter
+  template <typename Mutex, typename Base=poly_timed_lockable>
+  class poly_timed_lockable_adapter: public poly_lockable_adapter<Mutex, Base>
+  {
+  public:
+    typedef Mutex mutex_type;
+
+    bool try_lock_until(chrono::system_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_lock_until(abs_time);
+    }
+    bool try_lock_until(chrono::steady_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_lock_until(abs_time);
+    }
+    bool try_lock_for(chrono::nanoseconds const & rel_time)
+    {
+      return this->mtx().try_lock_for(rel_time);
+    }
+
+  };
+  //]
+
+}
+#endif