passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/mutex.hpp

@@ -1,14 +1,16 @@
 #ifndef BOOST_THREAD_PTHREAD_MUTEX_HPP
 #define BOOST_THREAD_PTHREAD_MUTEX_HPP
 // (C) Copyright 2007-8 Anthony Williams
-// (C) Copyright 2011-2012 Vicente J. Botet Escriba
+// (C) Copyright 2011,2012,2015 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)
 
 #include <boost/thread/detail/config.hpp>
+#include <boost/assert.hpp>
 #include <pthread.h>
 #include <boost/throw_exception.hpp>
+#include <boost/core/ignore_unused.hpp>
 #include <boost/thread/exceptions.hpp>
 #if defined BOOST_THREAD_PROVIDES_NESTED_LOCKS
 #include <boost/thread/lock_types.hpp>
@@ -25,13 +27,12 @@
 #endif
 #include <boost/thread/detail/delete.hpp>
 
-#ifdef _POSIX_TIMEOUTS
-#if _POSIX_TIMEOUTS >= 0 && _POSIX_TIMEOUTS>=200112L
+#if (defined(_POSIX_TIMEOUTS) && (_POSIX_TIMEOUTS-0)>=200112L) \
+ || (defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__ >= 21)
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
 #define BOOST_PTHREAD_HAS_TIMEDLOCK
 #endif
 #endif
-#endif
 
 
 #include <boost/config/abi_prefix.hpp>
@@ -105,7 +106,9 @@ namespace boost
         }
         ~mutex()
         {
-          BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
+          int const res = posix::pthread_mutex_destroy(&m);
+          boost::ignore_unused(res);
+          BOOST_ASSERT(!res);
         }
 
         void lock()
@@ -120,10 +123,12 @@ namespace boost
         void unlock()
         {
             int res = posix::pthread_mutex_unlock(&m);
-            if (res)
-            {
-                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
-            }
+            (void)res;
+            BOOST_ASSERT(res == 0);
+//            if (res)
+//            {
+//                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
+//            }
         }
 
         bool try_lock()
@@ -216,10 +221,12 @@ namespace boost
         void unlock()
         {
             int res = posix::pthread_mutex_unlock(&m);
-            if (res)
-            {
-                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
-            }
+            (void)res;
+            BOOST_ASSERT(res == 0);
+//            if (res)
+//            {
+//                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
+//            }
         }
 
         bool try_lock()

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/once.hpp

@@ -16,7 +16,7 @@
 
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 #include <boost/thread/detail/delete.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 
 #include <boost/bind.hpp>
 #include <boost/assert.hpp>
@@ -42,7 +42,7 @@ namespace boost
   }
 
 #ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template<typename Function, class ...ArgTypes>
     inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f, BOOST_THREAD_RV_REF(ArgTypes)... args);
 #else
@@ -65,7 +65,7 @@ namespace boost
   private:
       volatile thread_detail::uintmax_atomic_t epoch;
 
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       template<typename Function, class ...ArgTypes>
       friend void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f, BOOST_THREAD_RV_REF(ArgTypes)... args);
 #else
@@ -118,7 +118,7 @@ namespace boost
     // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html
 
 
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
 
   template<typename Function, class ...ArgTypes>

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/once_atomic.hpp

@@ -15,7 +15,7 @@
 #include <boost/cstdint.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/detail/invoke.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 #include <boost/bind.hpp>
 #include <boost/atomic.hpp>
 
@@ -115,7 +115,7 @@ namespace boost
 #endif
 
 
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
   template<typename Function, class ...ArgTypes>
   inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f, BOOST_THREAD_RV_REF(ArgTypes)... args)
@@ -214,7 +214,7 @@ namespace boost
       thread_detail::commit_once_region(flag);
     }
   }
-
+#if !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
   template<typename Function>
   inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f)
   {
@@ -302,7 +302,7 @@ namespace boost
     }
   }
 
-
+#endif // __SUNPRO_CC
 
 #endif
 }

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/recursive_mutex.hpp

@@ -27,16 +27,19 @@
 #endif
 #include <boost/thread/detail/delete.hpp>
 
-#ifdef _POSIX_TIMEOUTS
-#if _POSIX_TIMEOUTS >= 0 && _POSIX_TIMEOUTS>=200112L
+#if (defined _POSIX_TIMEOUTS && (_POSIX_TIMEOUTS-0)>=200112L) \
+ || (defined __ANDROID__ && defined __ANDROID_API__ && __ANDROID_API__ >= 21)
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
 #define BOOST_PTHREAD_HAS_TIMEDLOCK
 #endif
 #endif
-#endif
 
+#if  defined BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE \
+ ||  defined __ANDROID__
+#define BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#endif
 
-#if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE) && defined(BOOST_PTHREAD_HAS_TIMEDLOCK)
+#if defined BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE && defined BOOST_PTHREAD_HAS_TIMEDLOCK
 #define BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
 #endif
 
@@ -48,7 +51,7 @@ namespace boost
     {
     private:
         pthread_mutex_t m;
-#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifndef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
         pthread_cond_t cond;
         bool is_locked;
         pthread_t owner;
@@ -58,7 +61,7 @@ namespace boost
         BOOST_THREAD_NO_COPYABLE(recursive_mutex)
         recursive_mutex()
         {
-#ifdef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifdef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
             pthread_mutexattr_t attr;
 
             int const init_attr_res=pthread_mutexattr_init(&attr);
@@ -99,12 +102,12 @@ namespace boost
         ~recursive_mutex()
         {
             BOOST_VERIFY(!pthread_mutex_destroy(&m));
-#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifndef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
             BOOST_VERIFY(!pthread_cond_destroy(&cond));
 #endif
         }
 
-#ifdef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifdef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
         void lock()
         {
             BOOST_VERIFY(!pthread_mutex_lock(&m));

data/src/cxx_supportlib/vendor-modified/boost/thread/pthread/thread_data.hpp

@@ -15,7 +15,6 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
-#include <boost/optional.hpp>
 #include <boost/assert.hpp>
 #ifdef BOOST_THREAD_USES_CHRONO
 #include <boost/chrono/system_clocks.hpp>
@@ -26,7 +25,9 @@
 #include <utility>
 
 #if defined(__ANDROID__)
-#include <asm/page.h> // http://code.google.com/p/android/issues/detail?id=39983
+# ifndef PAGE_SIZE
+#  define PAGE_SIZE 4096
+# endif
 #endif
 
 #include <pthread.h>
@@ -82,7 +83,7 @@ namespace boost
 
     namespace detail
     {
-        struct future_object_base;
+        struct shared_state_base;
         struct tss_cleanup_function;
         struct thread_exit_callback_node;
         struct tss_data_node
@@ -114,14 +115,19 @@ namespace boost
             boost::detail::thread_exit_callback_node* thread_exit_callbacks;
             std::map<void const*,boost::detail::tss_data_node> tss_data;
 
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            // These data must be at the end so that the access to the other fields doesn't change
+            // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined.
+            // Another option is to have them always
             pthread_mutex_t* cond_mutex;
             pthread_cond_t* current_cond;
+//#endif
             typedef std::vector<std::pair<condition_variable*, mutex*>
             //, hidden_allocator<std::pair<condition_variable*, mutex*> >
             > notify_list_t;
             notify_list_t notify;
 
-            typedef std::vector<shared_ptr<future_object_base> > async_states_t;
+            typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
 
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
@@ -135,8 +141,10 @@ namespace boost
                 thread_handle(0),
                 done(false),join_started(false),joined(false),
                 thread_exit_callbacks(0),
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 cond_mutex(0),
                 current_cond(0),
+//#endif
                 notify(),
                 async_states_()
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
@@ -154,7 +162,7 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
-            void make_ready_at_thread_exit(shared_ptr<future_object_base> as)
+            void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }
@@ -220,11 +228,11 @@ namespace boost
 
     namespace this_thread
     {
-      namespace hiden
-      {
-        void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-        void BOOST_THREAD_DECL sleep_until(const timespec& ts);
-      }
+        namespace hiden
+        {
+          void BOOST_THREAD_DECL sleep_for(const timespec& ts);
+          void BOOST_THREAD_DECL sleep_until(const timespec& ts);
+        }
 
 #ifdef BOOST_THREAD_USES_CHRONO
 #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY
@@ -237,6 +245,27 @@ namespace boost
 #endif
 #endif // BOOST_THREAD_USES_CHRONO
 
+        namespace no_interruption_point
+        {
+          namespace hiden
+          {
+            void BOOST_THREAD_DECL sleep_for(const timespec& ts);
+            void BOOST_THREAD_DECL sleep_until(const timespec& ts);
+          }
+
+    #ifdef BOOST_THREAD_USES_CHRONO
+    #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY
+
+          inline
+          void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
+          {
+              return boost::this_thread::no_interruption_point::hiden::sleep_for(boost::detail::to_timespec(ns));
+          }
+    #endif
+    #endif // BOOST_THREAD_USES_CHRONO
+
+        } // no_interruption_point
+
         void BOOST_THREAD_DECL yield() BOOST_NOEXCEPT;
 
 #if defined BOOST_THREAD_USES_DATETIME

data/src/cxx_supportlib/vendor-modified/boost/thread/scoped_thread.hpp

@@ -47,14 +47,13 @@ namespace boost
      *
      */
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <class F, class ...Args>
-    explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args,
-        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+    template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type>
+    explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args) :
       t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
 #else
     template <class F>
     explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f,
-        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+        typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type=0) :
       t_(boost::forward<F>(f)) {}
     template <class F, class A1>
     strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
@@ -138,14 +137,13 @@ namespace boost
      */
 
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <class F, class ...Args>
-    explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args,
-        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+    template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type>
+    explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args) :
       t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
 #else
     template <class F>
     explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f,
-        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+        typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type=0) :
       t_(boost::forward<F>(f)) {}
     template <class F, class A1>
     scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
@@ -179,7 +177,7 @@ namespace boost
      * Move constructor.
      */
     scoped_thread(BOOST_RV_REF(scoped_thread) x) BOOST_NOEXCEPT :
-    t_(boost::move(x.t_))
+    t_(boost::move(BOOST_THREAD_RV(x).t_))
     {}
 
     /**
@@ -199,7 +197,7 @@ namespace boost
      */
     scoped_thread& operator=(BOOST_RV_REF(scoped_thread) x)
     {
-      t_ = boost::move(x.t_);
+      t_ = boost::move(BOOST_THREAD_RV(x).t_);
       return *this;
     }
 
@@ -263,11 +261,17 @@ namespace boost
     }
 #endif
 
-    static unsigned hardware_concurrency()BOOST_NOEXCEPT
+    static unsigned hardware_concurrency() BOOST_NOEXCEPT
     {
       return thread::hardware_concurrency();
     }
 
+#ifdef BOOST_THREAD_PROVIDES_PHYSICAL_CONCURRENCY
+    static unsigned physical_concurrency() BOOST_NOEXCEPT
+    {
+      return thread::physical_concurrency();
+    }
+#endif
   };
 
   /**

data/src/cxx_supportlib/vendor-modified/boost/thread/shared_mutex.hpp

@@ -28,6 +28,7 @@
 
 namespace boost
 {
+  typedef shared_mutex shared_timed_mutex;
   namespace sync
   {
 #ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES

data/src/cxx_supportlib/vendor-modified/boost/thread/sync_bounded_queue.hpp

@@ -3,7 +3,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Vicente J. Botet Escriba 2013. Distributed under the Boost
+// (C) Copyright Vicente J. Botet Escriba 2013-2014. 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)
 //
@@ -11,584 +11,6 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-
-  BOOST_SCOPED_ENUM_DECLARE_BEGIN(queue_op_status)
-  { success = 0, empty, full, closed, busy }
-  BOOST_SCOPED_ENUM_DECLARE_END(queue_op_status)
-
-  struct no_block_tag{};
-  BOOST_CONSTEXPR_OR_CONST no_block_tag no_block = {};
-
-  struct sync_queue_is_closed : std::exception {};
-
-  template <typename ValueType>
-  class sync_bounded_queue
-  {
-  public:
-    typedef ValueType value_type;
-    typedef std::size_t size_type;
-
-    // Constructors/Assignment/Destructors
-    BOOST_THREAD_NO_COPYABLE(sync_bounded_queue)
-    explicit sync_bounded_queue(size_type max_elems);
-    template <typename Range>
-    sync_bounded_queue(size_type max_elems, Range range);
-    ~sync_bounded_queue();
-
-    // Observers
-    bool empty() const;
-    bool full() const;
-    size_type capacity() const;
-    size_type size() const;
-    bool closed() const;
-
-    // Modifiers
-    void close();
-
-    void push(const value_type& x);
-    void push(BOOST_THREAD_RV_REF(value_type) x);
-    bool try_push(const value_type& x);
-    bool try_push(BOOST_THREAD_RV_REF(value_type) x);
-    bool try_push(no_block_tag, const value_type& x);
-    bool try_push(no_block_tag, BOOST_THREAD_RV_REF(value_type) x);
-
-    // Observers/Modifiers
-    void pull(value_type&);
-    void pull(ValueType& elem, bool & closed);
-    // enable_if is_nothrow_copy_movable<value_type>
-    value_type pull();
-    shared_ptr<ValueType> ptr_pull();
-    bool try_pull(value_type&);
-    bool try_pull(no_block_tag,value_type&);
-    shared_ptr<ValueType> try_pull();
-
-  private:
-    mutable mutex mtx_;
-    condition_variable not_empty_;
-    condition_variable not_full_;
-    size_type waiting_full_;
-    size_type waiting_empty_;
-    value_type* data_;
-    size_type in_;
-    size_type out_;
-    size_type capacity_;
-    bool closed_;
-
-    size_type inc(size_type idx) const BOOST_NOEXCEPT
-    {
-      return (idx + 1) % capacity_;
-    }
-
-    bool empty(unique_lock<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return in_ == out_;
-    }
-    bool empty(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return in_ == out_;
-    }
-    size_type capacity(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return capacity;
-    }
-    size_type size(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return ((out_+capacity_-in_) % capacity_)-1;
-    }
-
-    void throw_if_closed(unique_lock<mutex>&);
-
-    bool try_pull(value_type& x, unique_lock<mutex>& lk);
-    bool try_push(const value_type& x, unique_lock<mutex>& lk);
-    bool try_push(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-    shared_ptr<value_type> try_pull(unique_lock<mutex>& lk);
-
-    void wait_until_not_empty(unique_lock<mutex>& lk);
-    void wait_until_not_empty(unique_lock<mutex>& lk, bool&);
-    size_type wait_until_not_full(unique_lock<mutex>& lk);
-    size_type wait_until_not_full(unique_lock<mutex>& lk, bool&);
-
-
-    void notify_not_empty_if_needed(unique_lock<mutex>& lk)
-    {
-      if (waiting_empty_ > 0)
-      {
-        --waiting_empty_;
-        lk.unlock();
-        not_empty_.notify_one();
-      }
-    }
-    void notify_not_full_if_needed(unique_lock<mutex>& lk)
-    {
-      if (waiting_full_ > 0)
-      {
-        --waiting_full_;
-        lk.unlock();
-        not_full_.notify_one();
-      }
-    }
-
-    void pull(value_type& elem, unique_lock<mutex>& lk)
-    {
-      elem = boost::move(data_[out_]);
-      out_ = inc(out_);
-      notify_not_full_if_needed(lk);
-    }
-    boost::shared_ptr<value_type> ptr_pull(unique_lock<mutex>& lk)
-    {
-      shared_ptr<value_type> res = make_shared<value_type>(boost::move(data_[out_]));
-      out_ = inc(out_);
-      notify_not_full_if_needed(lk);
-      return res;
-    }
-
-
-    void set_in(size_type in, unique_lock<mutex>& lk)
-    {
-      in_ = in;
-      notify_not_empty_if_needed(lk);
-    }
-
-    void push_at(const value_type& elem, size_type in_p_1, unique_lock<mutex>& lk)
-    {
-      data_[in_] = elem;
-      set_in(in_p_1, lk);
-    }
-
-    void push_at(BOOST_THREAD_RV_REF(value_type) elem, size_type in_p_1, unique_lock<mutex>& lk)
-    {
-      data_[in_] = boost::move(elem);
-      set_in(in_p_1, lk);
-    }
-
-
-  };
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>::sync_bounded_queue(typename sync_bounded_queue<ValueType>::size_type max_elems) :
-    waiting_full_(0), waiting_empty_(0), data_(new value_type[max_elems + 1]), in_(0), out_(0), capacity_(max_elems + 1),
-        closed_(false)
-  {
-    BOOST_ASSERT_MSG(max_elems >= 1, "number of elements must be > 1");
-  }
-
-//  template <typename ValueType>
-//  template <typename Range>
-//  sync_bounded_queue<ValueType>::sync_bounded_queue(size_type max_elems, Range range) :
-//    waiting_full_(0), waiting_empty_(0), data_(new value_type[max_elems + 1]), in_(0), out_(0), capacity_(max_elems + 1),
-//        closed_(false)
-//  {
-//    BOOST_ASSERT_MSG(max_elems >= 1, "number of elements must be > 1");
-//    BOOST_ASSERT_MSG(max_elems == size(range), "number of elements must match range's size");
-//    try
-//    {
-//      typedef typename Range::iterator iterator_t;
-//      iterator_t first = boost::begin(range);
-//      iterator_t end = boost::end(range);
-//      size_type in = 0;
-//      for (iterator_t cur = first; cur != end; ++cur, ++in)
-//      {
-//        data_[in] = *cur;
-//      }
-//      set_in(in);
-//    }
-//    catch (...)
-//    {
-//      delete[] data_;
-//    }
-//  }
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>::~sync_bounded_queue()
-  {
-    delete[] data_;
-  }
-
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::close()
-  {
-    {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;
-    }
-    not_empty_.notify_all();
-    not_full_.notify_all();
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::closed() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return closed_;
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::empty() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return empty(lk);
-  }
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::full() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return full(lk);
-  }
-
-  template <typename ValueType>
-  typename sync_bounded_queue<ValueType>::size_type sync_bounded_queue<ValueType>::capacity() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return capacity(lk);
-  }
-
-  template <typename ValueType>
-  typename sync_bounded_queue<ValueType>::size_type sync_bounded_queue<ValueType>::size() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return size(lk);
-  }
-
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_pull(ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (empty(lk))
-    {
-      throw_if_closed(lk);
-      return false;
-    }
-    pull(elem, lk);
-    return true;
-  }
-  template <typename ValueType>
-  shared_ptr<ValueType> sync_bounded_queue<ValueType>::try_pull(unique_lock<mutex>& lk)
-  {
-    if (empty(lk))
-    {
-      throw_if_closed(lk);
-      return shared_ptr<ValueType>();
-    }
-    return ptr_pull(lk);
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_pull(ValueType& elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      return try_pull(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_pull(no_block_tag,ValueType& elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock())
-      {
-        return false;
-      }
-      return try_pull(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-  template <typename ValueType>
-  boost::shared_ptr<ValueType> sync_bounded_queue<ValueType>::try_pull()
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      return try_pull(lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::throw_if_closed(unique_lock<mutex>&)
-  {
-    if (closed_)
-    {
-      BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-    }
-  }
-
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::wait_until_not_empty(unique_lock<mutex>& lk)
-  {
-    for (;;)
-    {
-      if (out_ != in_) break;
-      throw_if_closed(lk);
-      ++waiting_empty_;
-      not_empty_.wait(lk);
-    }
-  }
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::wait_until_not_empty(unique_lock<mutex>& lk, bool & closed)
-  {
-    for (;;)
-    {
-      if (out_ != in_) break;
-      if (closed_) {closed=true; return;}
-      ++waiting_empty_;
-      not_empty_.wait(lk);
-    }
-  }
-
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::pull(ValueType& elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk);
-      pull(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::pull(ValueType& elem, bool & closed)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk, closed);
-      if (closed) {return;}
-      pull(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  // enable if ValueType is nothrow movable
-  template <typename ValueType>
-  ValueType sync_bounded_queue<ValueType>::pull()
-  {
-    try
-    {
-      value_type elem;
-      pull(elem);
-      return boost::move(elem);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-  template <typename ValueType>
-  boost::shared_ptr<ValueType> sync_bounded_queue<ValueType>::ptr_pull()
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk);
-      return ptr_pull(lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(const ValueType& elem, unique_lock<mutex>& lk)
-  {
-    throw_if_closed(lk);
-    size_type in_p_1 = inc(in_);
-    if (in_p_1 == out_)  // full()
-    {
-      return false;
-    }
-    push_at(elem, in_p_1, lk);
-    return true;
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(const ValueType& elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      return try_push(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(no_block_tag, const ValueType& elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock()) return false;
-      return try_push(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-
-  template <typename ValueType>
-  typename sync_bounded_queue<ValueType>::size_type sync_bounded_queue<ValueType>::wait_until_not_full(unique_lock<mutex>& lk)
-  {
-    for (;;)
-    {
-      throw_if_closed(lk);
-      size_type in_p_1 = inc(in_);
-      if (in_p_1 != out_) // ! full()
-      {
-        return in_p_1;
-      }
-      ++waiting_full_;
-      not_full_.wait(lk);
-    }
-  }
-
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::push(const ValueType& elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      push_at(elem, wait_until_not_full(lk), lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(BOOST_THREAD_RV_REF(ValueType) elem, unique_lock<mutex>& lk)
-  {
-    throw_if_closed(lk);
-    size_type in_p_1 = inc(in_);
-    if (in_p_1 == out_) // full()
-    {
-      return false;
-    }
-    push_at(boost::move(elem), in_p_1, lk);
-    return true;
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      return try_push(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(no_block_tag, BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock())
-      {
-        return false;
-      }
-      return try_push(elem, lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::push(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    try
-    {
-      unique_lock<mutex> lk(mtx_);
-      push_at(elem, wait_until_not_full(lk), lk);
-    }
-    catch (...)
-    {
-      close();
-      throw;
-    }
-  }
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    sbq.push(boost::forward<ValueType>(elem));
-    return sbq;
-  }
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, ValueType const&elem)
-  {
-    sbq.push(elem);
-    return sbq;
-  }
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>& operator>>(sync_bounded_queue<ValueType>& sbq, ValueType &elem)
-  {
-    sbq.pull(elem);
-    return sbq;
-  }
-
-}
-
-#include <boost/config/abi_suffix.hpp>
+#include <boost/thread/concurrent_queues/sync_bounded_queue.hpp>
 
 #endif