Reimport boost/thread as a separate library

CMakeLists.darwin.txt

@@ -351,10 +351,10 @@ add_subdirectory(contrib/libs/libevent/event_core)
 add_subdirectory(contrib/libs/libevent/event_extra)
 add_subdirectory(contrib/libs/libevent/event_openssl)
 add_subdirectory(contrib/libs/libevent/event_thread)
-add_subdirectory(contrib/restricted/boost/libs/thread)
-add_subdirectory(contrib/restricted/boost/date_time)
+add_subdirectory(contrib/restricted/boost/thread)
 add_subdirectory(contrib/restricted/boost/chrono)
 add_subdirectory(contrib/restricted/boost/ratio)
+add_subdirectory(contrib/restricted/boost/date_time)
 add_subdirectory(contrib/restricted/uriparser)
 add_subdirectory(contrib/libs/cctz/tzdata)
 add_subdirectory(contrib/libs/cctz)

CMakeLists.linux.txt

@@ -354,10 +354,10 @@ add_subdirectory(contrib/libs/libevent/event_core)
 add_subdirectory(contrib/libs/libevent/event_extra)
 add_subdirectory(contrib/libs/libevent/event_openssl)
 add_subdirectory(contrib/libs/libevent/event_thread)
-add_subdirectory(contrib/restricted/boost/libs/thread)
-add_subdirectory(contrib/restricted/boost/date_time)
+add_subdirectory(contrib/restricted/boost/thread)
 add_subdirectory(contrib/restricted/boost/chrono)
 add_subdirectory(contrib/restricted/boost/ratio)
+add_subdirectory(contrib/restricted/boost/date_time)
 add_subdirectory(contrib/restricted/uriparser)
 add_subdirectory(contrib/libs/cctz/tzdata)
 add_subdirectory(contrib/libs/cctz)

contrib/restricted/boost/boost/thread/caller_context.hpp

@@ -1,59 +0,0 @@
-// (C) Copyright 2013,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)
-
-
-#ifndef BOOST_THREAD_CALL_CONTEXT_HPP
-#define BOOST_THREAD_CALL_CONTEXT_HPP
-
-#include <boost/thread/detail/config.hpp>
-#if defined BOOST_THREAD_USES_LOG_THREAD_ID
-#include <boost/thread/thread.hpp>
-#endif
-#include <boost/current_function.hpp>
-#include <boost/io/ios_state.hpp>
-#include <iomanip>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-
-  struct caller_context_t
-  {
-    const char * filename;
-    unsigned lineno;
-    const char * func;
-    caller_context_t(const char * filename, unsigned lineno, const char * func) :
-      filename(filename), lineno(lineno), func(func)
-    {
-    }
-  };
-
-#define BOOST_CONTEXTOF boost::caller_context_t(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
-
-  template <typename OStream>
-  OStream& operator<<(OStream& os, caller_context_t const& ctx)
-  {
-#if defined BOOST_THREAD_USES_LOG_THREAD_ID
-    {
-      io::ios_flags_saver ifs( os );
-      os << std::left << std::setw(14) << boost::this_thread::get_id() << " ";
-    }
-#endif
-    {
-      io::ios_flags_saver ifs(os);
-      os << std::setw(50) << ctx.filename << "["
-         << std::setw(4) << std::right << std::dec<< ctx.lineno << "] ";
-#if defined BOOST_THREAD_USES_LOG_CURRENT_FUNCTION
-      os << ctx.func << " " ;
-#endif
-    }
-    return os;
-  }
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif // header

contrib/restricted/boost/boost/thread/completion_latch.hpp

@@ -1,225 +0,0 @@
-// 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_COMPLETION_LATCH_HPP
-#define BOOST_THREAD_COMPLETION_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/thread/detail/nullary_function.hpp>
-#include <boost/thread/csbl/functional.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-  namespace thread_detail
-  {
-    void noop()
-    {
-    }
-  }
-  class completion_latch
-  {
-  public:
-    /// the implementation defined completion function type
-    //typedef detail::nullary_function<void()> completion_function;
-    typedef csbl::function<void()> completion_function;
-    /// noop completion function factory
-    static completion_function noop()
-    {
-      return completion_function(&thread_detail::noop);
-    }
-
-  private:
-    struct around_wait;
-    friend struct around_wait;
-    struct around_wait
-    {
-      completion_latch &that_;
-      boost::unique_lock<boost::mutex> &lk_;
-      around_wait(completion_latch &that, boost::unique_lock<boost::mutex> &lk)
-      : that_(that), lk_(lk)
-      {
-        that_.leavers_.cond_.wait(lk, detail::counter_is_zero(that_.leavers_));
-        that_.waiters_.inc_and_notify_all();
-        that_.leavers_.cond_.wait(lk, detail::counter_is_not_zero(that_.leavers_));
-      }
-      ~around_wait()
-      {
-        that_.waiters_.dec_and_notify_all();
-      }
-    };
-
-    bool count_down(unique_lock<mutex> &lk)
-    {
-      BOOST_ASSERT(count_ > 0);
-      if (--count_ == 0)
-      {
-        waiters_.cond_.wait(lk, detail::counter_is_not_zero(waiters_));
-        leavers_.assign_and_notify_all(waiters_);
-        count_.cond_.notify_all();
-        waiters_.cond_.wait(lk, detail::counter_is_zero(waiters_));
-        leavers_.assign_and_notify_all(0);
-        lk.unlock();
-        funct_();
-        return true;
-      }
-      return false;
-    }
-
-  public:
-    BOOST_THREAD_NO_COPYABLE( completion_latch )
-
-    /// Constructs a latch with a given count.
-    completion_latch(std::size_t count) :
-      count_(count), funct_(noop()), waiters_(0), leavers_(0)
-    {
-    }
-
-    /// Constructs a latch with a given count and a completion function.
-    template <typename F>
-    completion_latch(std::size_t count, BOOST_THREAD_RV_REF(F) funct) :
-    count_(count),
-    funct_(boost::move(funct)),
-    waiters_(0),
-    leavers_(0)
-    {
-    }
-    completion_latch(std::size_t count, void(*funct)()) :
-      count_(count), funct_(funct), waiters_(0), leavers_(0)
-    {
-    }
-
-    ///
-    ~completion_latch()
-    {
-    }
-
-    /// Blocks until the latch has counted down to zero.
-    void wait()
-    {
-      boost::unique_lock<boost::mutex> lk(mutex_);
-      around_wait aw(*this, lk);
-      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_);
-      around_wait aw(*this, lk);
-      return (count_ == 0);
-    }
-
-    /// try to wait for a specified amount of time
-    /// @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_);
-      around_wait aw(*this, lk);
-      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 is 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_);
-      around_wait aw(*this, lk);
-      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()
-    {
-      unique_lock<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;
-      }
-      around_wait aw(*this, lk);
-      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;
-    }
-
-    /// Resets the latch with the new completion function.
-    /// The next time the internal count reaches 0, this function will be invoked.
-    /// This completion function may only be invoked when there are no other threads
-    /// currently inside the count_down and wait related functions.
-    /// It may also be invoked from within the registered completion function.
-    /// @Returns the old completion function if any or noop if
-
-#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
-    template <typename F>
-    completion_function then(BOOST_THREAD_RV_REF(F) funct)
-    {
-      boost::lock_guard<boost::mutex> lk(mutex_);
-      completion_function tmp(funct_);
-      funct_ = boost::move(funct);
-      return tmp;
-    }
-#endif
-    completion_function then(void(*funct)())
-    {
-      boost::lock_guard<boost::mutex> lk(mutex_);
-      completion_function tmp(funct_);
-      funct_ = completion_function(funct);
-      return tmp;
-    }
-
-  private:
-    mutex mutex_;
-    detail::counter count_;
-    completion_function funct_;
-    detail::counter waiters_;
-    detail::counter leavers_;
-  };
-
-} // namespace boost
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif

contrib/restricted/boost/boost/thread/concurrent_queues/deque_adaptor.hpp

@@ -1,209 +0,0 @@
-#ifndef BOOST_THREAD_CONCURRENT_DEQUE_ADAPTOR_HPP
-#define BOOST_THREAD_CONCURRENT_DEQUE_ADAPTOR_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 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)
-//
-// See http://www.boost.org/libs/thread for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-#include <boost/thread/concurrent_queues/deque_base.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-namespace detail
-{
-
-  template <typename Queue>
-  class deque_adaptor_copyable_only :
-    public boost::deque_base<typename Queue::value_type, typename Queue::size_type>
-  {
-      Queue queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-    deque_adaptor_copyable_only()  {}
-
-    // Observers
-    bool empty() const  { return queue.empty(); }
-    bool full() const { return queue.full(); }
-    size_type size() const { return queue.size(); }
-    bool closed() const { return queue.closed(); }
-
-    // Modifiers
-    void close() { queue.close(); }
-
-    void push_back(const value_type& x) { queue.push_back(x); }
-
-    void pull_front(value_type& x) { queue.pull_front(x); };
-    value_type pull_front() { return queue.pull_front(); }
-
-    queue_op_status try_push_back(const value_type& x) { return queue.try_push_back(x); }
-    queue_op_status try_pull_front(value_type& x)  { return queue.try_pull_front(x); }
-
-    queue_op_status nonblocking_push_back(const value_type& x) { return queue.nonblocking_push_back(x); }
-    queue_op_status nonblocking_pull_front(value_type& x)  { return queue.nonblocking_pull_front(x); }
-
-    queue_op_status wait_push_back(const value_type& x) { return queue.wait_push_back(x); }
-    queue_op_status wait_pull_front(value_type& x) { return queue.wait_pull_front(x); }
-
-  };
-  template <typename Queue>
-  class deque_adaptor_movable_only :
-    public boost::deque_base<typename Queue::value_type, typename Queue::size_type>
-  {
-      Queue queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-
-    deque_adaptor_movable_only()  {}
-
-    // Observers
-    bool empty() const  { return queue.empty(); }
-    bool full() const { return queue.full(); }
-    size_type size() const { return queue.size(); }
-    bool closed() const { return queue.closed(); }
-
-    // Modifiers
-    void close() { queue.close(); }
-
-
-    void pull_front(value_type& x) { queue.pull_front(x); };
-    // enable_if is_nothrow_copy_movable<value_type>
-    value_type pull_front() { return queue.pull_front(); }
-
-    queue_op_status try_pull_front(value_type& x)  { return queue.try_pull_front(x); }
-
-    queue_op_status nonblocking_pull_front(value_type& x)  { return queue.nonblocking_pull_front(x); }
-
-    queue_op_status wait_pull_front(value_type& x) { return queue.wait_pull_front(x); }
-
-    void push_back(BOOST_THREAD_RV_REF(value_type) x) { queue.push_back(boost::move(x)); }
-    queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x) { return queue.try_push_back(boost::move(x)); }
-    queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x) { return queue.nonblocking_push_back(boost::move(x)); }
-    queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x) { return queue.wait_push_back(boost::move(x)); }
-  };
-
-  template <typename Queue>
-  class deque_adaptor_copyable_and_movable :
-    public boost::deque_base<typename Queue::value_type, typename Queue::size_type>
-  {
-      Queue queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-
-    deque_adaptor_copyable_and_movable()  {}
-
-    // Observers
-    bool empty() const  { return queue.empty(); }
-    bool full() const { return queue.full(); }
-    size_type size() const { return queue.size(); }
-    bool closed() const { return queue.closed(); }
-
-    // Modifiers
-    void close() { queue.close(); }
-
-
-    void push_back(const value_type& x) { queue.push_back(x); }
-
-    void pull_front(value_type& x) { queue.pull_front(x); };
-    // enable_if is_nothrow_copy_movable<value_type>
-    value_type pull_front() { return queue.pull_front(); }
-
-    queue_op_status try_push_back(const value_type& x) { return queue.try_push_back(x); }
-    queue_op_status try_pull_front(value_type& x)  { return queue.try_pull_front(x); }
-
-    queue_op_status nonblocking_push_back(const value_type& x) { return queue.nonblocking_push_back(x); }
-    queue_op_status nonblocking_pull_front(value_type& x)  { return queue.nonblocking_pull_front(x); }
-
-    queue_op_status wait_push_back(const value_type& x) { return queue.wait_push_back(x); }
-    queue_op_status wait_pull_front(value_type& x) { return queue.wait_pull_front(x); }
-
-    void push_back(BOOST_THREAD_RV_REF(value_type) x) { queue.push_back(boost::move(x)); }
-    queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x) { return queue.try_push_back(boost::move(x)); }
-    queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x) { return queue.nonblocking_push_back(boost::move(x)); }
-    queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x) { return queue.wait_push_back(boost::move(x)); }
-  };
-
-
-  template <class Q, class T,
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-#if defined __GNUC__ && ! defined __clang__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = true
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif // __GNUC__
-#elif defined _MSC_VER
-#if _MSC_VER < 1700
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = true
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif // _MSC_VER
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif
-#else
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = has_move_emulation_enabled<T>::value
-#endif
-      >
-  struct deque_adaptor;
-
-  template <class Q, class T>
-  struct deque_adaptor<Q, T, true, true> {
-    typedef deque_adaptor_copyable_and_movable<Q> type;
-  };
-  template <class Q, class T>
-  struct deque_adaptor<Q, T, true, false> {
-    typedef deque_adaptor_copyable_only<Q> type;
-  };
-  template <class Q, class T>
-  struct deque_adaptor<Q, T, false, true> {
-    typedef deque_adaptor_movable_only<Q> type;
-  };
-
-}
-
-  template <typename Queue>
-  class deque_adaptor :
-    public detail::deque_adaptor<Queue, typename Queue::value_type>::type
-  {
-  public:
-      typedef typename Queue::value_type value_type;
-      typedef typename Queue::size_type size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~deque_adaptor() {};
-  };
-}
-using concurrent::deque_adaptor;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif

contrib/restricted/boost/boost/thread/concurrent_queues/deque_base.hpp

@@ -1,202 +0,0 @@
-#ifndef BOOST_THREAD_CONCURRENT_DEQUE_BASE_HPP
-#define BOOST_THREAD_CONCURRENT_DEQUE_BASE_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 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)
-//
-// See http://www.boost.org/libs/thread for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_copy_constructible.hpp>
-
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-namespace detail
-{
-
-  template <typename ValueType, class SizeType>
-  class deque_base_copyable_only
-  {
-  public:
-    typedef ValueType value_type;
-    typedef SizeType size_type;
-
-    // Constructors/Assignment/Destructors
-    virtual ~deque_base_copyable_only() {};
-
-    // Observers
-    virtual bool empty() const = 0;
-    virtual bool full() const = 0;
-    virtual size_type size() const = 0;
-    virtual bool closed() const = 0;
-
-    // Modifiers
-    virtual void close() = 0;
-
-    virtual void push_back(const value_type& x) = 0;
-
-    virtual void pull_front(value_type&) = 0;
-    virtual value_type pull_front() = 0;
-
-    virtual queue_op_status try_push_back(const value_type& x) = 0;
-    virtual queue_op_status try_pull_front(value_type&) = 0;
-
-    virtual queue_op_status nonblocking_push_back(const value_type& x) = 0;
-    virtual queue_op_status nonblocking_pull_front(value_type&) = 0;
-
-    virtual queue_op_status wait_push_back(const value_type& x) = 0;
-    virtual queue_op_status wait_pull_front(value_type& elem) = 0;
-
-  };
-
-  template <typename ValueType, class SizeType>
-  class deque_base_movable_only
-  {
-  public:
-    typedef ValueType value_type;
-    typedef SizeType size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~deque_base_movable_only() {};
-
-    // Observers
-    virtual bool empty() const = 0;
-    virtual bool full() const = 0;
-    virtual size_type size() const = 0;
-    virtual bool closed() const = 0;
-
-    // Modifiers
-    virtual void close() = 0;
-
-    virtual void pull_front(value_type&) = 0;
-    // enable_if is_nothrow_movable<value_type>
-    virtual value_type pull_front() = 0;
-
-    virtual queue_op_status try_pull_front(value_type&) = 0;
-
-    virtual queue_op_status nonblocking_pull_front(value_type&) = 0;
-
-    virtual queue_op_status wait_pull_front(value_type& elem) = 0;
-
-    virtual void push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-  };
-
-
-  template <typename ValueType, class SizeType>
-  class deque_base_copyable_and_movable
-  {
-  public:
-    typedef ValueType value_type;
-    typedef SizeType size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~deque_base_copyable_and_movable() {};
-
-
-    // Observers
-    virtual bool empty() const = 0;
-    virtual bool full() const = 0;
-    virtual size_type size() const = 0;
-    virtual bool closed() const = 0;
-
-    // Modifiers
-    virtual void close() = 0;
-
-    virtual void push_back(const value_type& x) = 0;
-
-    virtual void pull_front(value_type&) = 0;
-    // enable_if is_nothrow_copy_movable<value_type>
-    virtual value_type pull_front() = 0;
-
-    virtual queue_op_status try_push_back(const value_type& x) = 0;
-    virtual queue_op_status try_pull_front(value_type&) = 0;
-
-    virtual queue_op_status nonblocking_push_back(const value_type& x) = 0;
-    virtual queue_op_status nonblocking_pull_front(value_type&) = 0;
-
-    virtual queue_op_status wait_push_back(const value_type& x) = 0;
-    virtual queue_op_status wait_pull_front(value_type& elem) = 0;
-
-    virtual void push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-  };
-
-  template <class T, class ST,
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-#if defined __GNUC__ && ! defined __clang__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = true
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif // __GNUC__
-#elif defined _MSC_VER
-#if _MSC_VER < 1700
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = true
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif // _MSC_VER
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif
-#else
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = has_move_emulation_enabled<T>::value
-#endif
-      >
-  struct deque_base;
-
-  template <class T, class ST>
-  struct deque_base<T, ST, true, true> {
-    typedef deque_base_copyable_and_movable<T, ST> type;
-  };
-  template <class T, class ST>
-  struct deque_base<T, ST, true, false> {
-    typedef deque_base_copyable_only<T, ST> type;
-  };
-  template <class T, class ST>
-  struct deque_base<T, ST, false, true> {
-    typedef deque_base_movable_only<T, ST> type;
-  };
-
-}
-
-  template <class ValueType, class SizeType=std::size_t>
-  class deque_base :
-    public detail::deque_base<ValueType, SizeType>::type
-  {
-  public:
-      typedef ValueType value_type;
-      typedef SizeType size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~deque_base() {};
-  };
-
-}
-using concurrent::deque_base;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif

contrib/restricted/boost/boost/thread/concurrent_queues/deque_views.hpp

@@ -1,165 +0,0 @@
-#ifndef BOOST_THREAD_QUEUE_VIEWS_HPP
-#define BOOST_THREAD_QUEUE_VIEWS_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 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)
-//
-// See http://www.boost.org/libs/thread for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-#include <boost/thread/concurrent_queues/deque_base.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-
-  template <typename Queue>
-  class deque_back_view
-  {
-   Queue* queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-    deque_back_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
-
-    // Observers
-    bool empty() const  { return queue->empty(); }
-    bool full() const { return queue->full(); }
-    size_type size() const { return queue->size(); }
-    bool closed() const { return queue->closed(); }
-
-    // Modifiers
-    void close() { queue->close(); }
-
-    void push(const value_type& x) { queue->push_back(x); }
-
-    void pull(value_type& x) { queue->pull_back(x); }
-    // enable_if is_nothrow_copy_movable<value_type>
-    value_type pull()  { return queue->pull_back(); }
-
-    queue_op_status try_push(const value_type& x) { return queue->try_push_back(x); }
-
-    queue_op_status try_pull(value_type& x) { return queue->try_pull_back(x); }
-
-    queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push_back(x); }
-
-    queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull_back(x); }
-
-    queue_op_status wait_push(const value_type& x) { return queue->wait_push_back(x); }
-    queue_op_status wait_pull(value_type& x) { return queue->wait_pull_back(x); }
-
-    void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push_back(boost::move(x)); }
-    queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->try_push_back(boost::move(x)); }
-    queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->nonblocking_push_back(boost::move(x)); }
-    queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->wait_push_back(boost::move(x)); }
-  };
-
-  template <typename Queue>
-  class deque_front_view
-  {
-   Queue* queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-    deque_front_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
-
-    // Observers
-    bool empty() const  { return queue->empty(); }
-    bool full() const { return queue->full(); }
-    size_type size() const { return queue->size(); }
-    bool closed() const { return queue->closed(); }
-
-    // Modifiers
-    void close() { queue->close(); }
-
-    void push(const value_type& x) { queue->push_front(x); }
-
-    void pull(value_type& x) { queue->pull_front(x); };
-    // enable_if is_nothrow_copy_movable<value_type>
-    value_type pull()  { return queue->pull_front(); }
-
-    queue_op_status try_push(const value_type& x) { return queue->try_push_front(x); }
-
-    queue_op_status try_pull(value_type& x) { return queue->try_pull_front(x); }
-
-    queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push_front(x); }
-
-    queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull_front(x); }
-
-    queue_op_status wait_push(const value_type& x) { return queue->wait_push_front(x); }
-    queue_op_status wait_pull(value_type& x) { return queue->wait_pull_front(x); }
-    void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push_front(forward<value_type>(x)); }
-    queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->try_push_front(forward<value_type>(x)); }
-    queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->nonblocking_push_front(forward<value_type>(x)); }
-    queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->wait_push_front(forward<value_type>(x)); }
-
-  };
-
-#if ! defined BOOST_NO_CXX11_TEMPLATE_ALIASES
-
-  template <class T>
-  using deque_back = deque_back_view<deque_base<T> > ;
-  template <class T>
-  using deque_front = deque_front_view<deque_base<T> > ;
-
-#else
-
-  template <class T>
-  struct deque_back : deque_back_view<deque_base<T> >
-  {
-    typedef deque_back_view<deque_base<T> > base_type;
-    deque_back(deque_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
-  };
-  template <class T>
-  struct deque_front : deque_front_view<deque_base<T> >
-  {
-    typedef deque_front_view<deque_base<T> > base_type;
-    deque_front(deque_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
-
-  };
-
-#endif
-
-//  template <class Queue>
-//  deque_back_view<Queue> back(Queue & q) { return deque_back_view<Queue>(q); }
-//  template <class Queue>
-//  deque_front_view<Queue> front(Queue & q) { return deque_front_view<Queue>(q); }
-//#if 0
-//  template <class T>
-//  deque_back<T> back(deque_base<T> & q) { return deque_back<T>(q); }
-//  template <class T>
-//  deque_front<T> front(deque_base<T> & q) { return deque_front<T>(q); }
-//#else
-//  template <class T>
-//  typename deque_back<T>::type back(deque_base<T> & q) { return typename deque_back<T>::type(q); }
-//  template <class T>
-//  typename deque_front<T>::type front(deque_base<T> & q) { return typename deque_front<T>::type(q); }
-//#endif
-}
-
-using concurrent::deque_back_view;
-using concurrent::deque_front_view;
-using concurrent::deque_back;
-using concurrent::deque_front;
-//using concurrent::back;
-//using concurrent::front;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif

contrib/restricted/boost/boost/thread/concurrent_queues/detail/sync_deque_base.hpp

@@ -1,223 +0,0 @@
-#ifndef BOOST_THREAD_CONCURRENT_QUEUES_DETAIL_SYNC_DEQUE_BASE_HPP
-#define BOOST_THREAD_CONCURRENT_QUEUES_DETAIL_SYNC_DEQUE_BASE_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 2013-2017. 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.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include <boost/bind.hpp>
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-
-#include <boost/chrono/time_point.hpp>
-#include <boost/throw_exception.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-namespace detail
-{
-
-  template <class ValueType, class Queue>
-  class sync_deque_base
-  {
-  public:
-    typedef ValueType value_type;
-    typedef Queue underlying_queue_type;
-    typedef typename Queue::size_type size_type;
-    typedef queue_op_status op_status;
-
-    // Constructors/Assignment/Destructors
-    BOOST_THREAD_NO_COPYABLE(sync_deque_base)
-    inline sync_deque_base();
-    //template <typename Range>
-    //inline explicit sync_deque(Range range);
-    inline ~sync_deque_base();
-
-    // Observers
-    inline bool empty() const;
-    inline bool full() const;
-    inline size_type size() const;
-    inline bool closed() const;
-
-    // Modifiers
-    inline void close();
-
-    inline underlying_queue_type underlying_queue() {
-      lock_guard<mutex> lk(mtx_);
-      return boost::move(data_);
-    }
-
-  protected:
-    mutable mutex mtx_;
-    condition_variable not_empty_;
-    underlying_queue_type data_;
-    bool closed_;
-
-    inline bool empty(unique_lock<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return data_.empty();
-    }
-    inline bool empty(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return data_.empty();
-    }
-
-    inline size_type size(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return data_.size();
-    }
-    inline bool closed(unique_lock<mutex>& lk) const;
-    inline bool closed(lock_guard<mutex>& lk) const;
-
-    inline void throw_if_closed(unique_lock<mutex>&);
-    inline void throw_if_closed(lock_guard<mutex>&);
-
-    inline bool not_empty_or_closed(unique_lock<mutex>& ) const;
-
-    inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);
-
-    inline void notify_not_empty_if_needed(unique_lock<mutex>& )
-    {
-      not_empty_.notify_one();
-    }
-    inline void notify_not_empty_if_needed(lock_guard<mutex>& )
-    {
-      not_empty_.notify_one();
-    }
-
-  };
-
-  template <class ValueType, class Queue>
-  sync_deque_base<ValueType, Queue>::sync_deque_base() :
-    data_(), closed_(false)
-  {
-    BOOST_ASSERT(data_.empty());
-  }
-
-  template <class ValueType, class Queue>
-  sync_deque_base<ValueType, Queue>::~sync_deque_base()
-  {
-  }
-
-  template <class ValueType, class Queue>
-  void sync_deque_base<ValueType, Queue>::close()
-  {
-    {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;
-    }
-    not_empty_.notify_all();
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::closed() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return closed(lk);
-  }
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::closed(unique_lock<mutex>&) const
-  {
-    return closed_;
-  }
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::closed(lock_guard<mutex>&) const
-  {
-    return closed_;
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::empty() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return empty(lk);
-  }
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::full() const
-  {
-    return false;
-  }
-
-  template <class ValueType, class Queue>
-  typename sync_deque_base<ValueType, Queue>::size_type sync_deque_base<ValueType, Queue>::size() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return size(lk);
-  }
-
-  template <class ValueType, class Queue>
-  void sync_deque_base<ValueType, Queue>::throw_if_closed(unique_lock<mutex>& lk)
-  {
-    if (closed(lk))
-    {
-      BOOST_THROW_EXCEPTION( sync_deque_is_closed() );
-    }
-  }
-  template <class ValueType, class Queue>
-  void sync_deque_base<ValueType, Queue>::throw_if_closed(lock_guard<mutex>& lk)
-  {
-    if (closed(lk))
-    {
-      BOOST_THROW_EXCEPTION( sync_deque_is_closed() );
-    }
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::not_empty_or_closed(unique_lock<mutex>& ) const
-  {
-    return ! data_.empty() || closed_;
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::wait_until_not_empty_or_closed(unique_lock<mutex>& lk)
-  {
-    not_empty_.wait(lk, boost::bind(&sync_deque_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk)));
-    if (! empty(lk)) return false; // success
-    return true; // closed
-  }
-
-  template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_deque_base<ValueType, Queue>::wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
-  {
-    if (! not_empty_.wait_until(lk, tp, boost::bind(&sync_deque_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk))))
-      return queue_op_status::timeout;
-    if (! empty(lk)) return queue_op_status::success;
-    return queue_op_status::closed;
-  }
-
-  template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_deque_base<ValueType, Queue>::wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
-  {
-    bool (sync_queue_base<ValueType, Queue>::*closed_function_ptr)(unique_lock<mutex>&) const = &sync_queue_base<ValueType, Queue>::closed;
-    if (! not_empty_.wait_until(lk, tp, boost::bind(closed_function_ptr, boost::ref(*this), boost::ref(lk))))
-      return queue_op_status::timeout;
-    return queue_op_status::closed;
-  }
-
-} // detail
-} // concurrent
-} // boost
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif

contrib/restricted/boost/boost/thread/concurrent_queues/detail/sync_queue_base.hpp

@@ -1,223 +0,0 @@
-#ifndef BOOST_THREAD_CONCURRENT_QUEUES_DETAIL_SYNC_QUEUE_BASE_HPP
-#define BOOST_THREAD_CONCURRENT_QUEUES_DETAIL_SYNC_QUEUE_BASE_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 2013-2017. 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.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include <boost/bind.hpp>
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-
-#include <boost/chrono/time_point.hpp>
-#include <boost/throw_exception.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-namespace detail
-{
-
-  template <class ValueType, class Queue>
-  class sync_queue_base
-  {
-  public:
-    typedef ValueType value_type;
-    typedef Queue underlying_queue_type;
-    typedef typename Queue::size_type size_type;
-    typedef queue_op_status op_status;
-
-    // Constructors/Assignment/Destructors
-    BOOST_THREAD_NO_COPYABLE(sync_queue_base)
-    inline sync_queue_base();
-    //template <typename Range>
-    //inline explicit sync_queue(Range range);
-    inline ~sync_queue_base();
-
-    // Observers
-    inline bool empty() const;
-    inline bool full() const;
-    inline size_type size() const;
-    inline bool closed() const;
-
-    // Modifiers
-    inline void close();
-
-    inline underlying_queue_type underlying_queue() {
-      lock_guard<mutex> lk(mtx_);
-      return boost::move(data_);
-    }
-
-  protected:
-    mutable mutex mtx_;
-    condition_variable not_empty_;
-    underlying_queue_type data_;
-    bool closed_;
-
-    inline bool empty(unique_lock<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return data_.empty();
-    }
-    inline bool empty(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return data_.empty();
-    }
-
-    inline size_type size(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return data_.size();
-    }
-    inline bool closed(unique_lock<mutex>& lk) const;
-    inline bool closed(lock_guard<mutex>& lk) const;
-
-    inline void throw_if_closed(unique_lock<mutex>&);
-    inline void throw_if_closed(lock_guard<mutex>&);
-
-    inline bool not_empty_or_closed(unique_lock<mutex>& ) const;
-
-    inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);
-
-    inline void notify_not_empty_if_needed(unique_lock<mutex>& )
-    {
-      not_empty_.notify_one();
-    }
-    inline void notify_not_empty_if_needed(lock_guard<mutex>& )
-    {
-      not_empty_.notify_one();
-    }
-
-  };
-
-  template <class ValueType, class Queue>
-  sync_queue_base<ValueType, Queue>::sync_queue_base() :
-    data_(), closed_(false)
-  {
-    BOOST_ASSERT(data_.empty());
-  }
-
-  template <class ValueType, class Queue>
-  sync_queue_base<ValueType, Queue>::~sync_queue_base()
-  {
-  }
-
-  template <class ValueType, class Queue>
-  void sync_queue_base<ValueType, Queue>::close()
-  {
-    {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;
-    }
-    not_empty_.notify_all();
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::closed() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return closed(lk);
-  }
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::closed(unique_lock<mutex>&) const
-  {
-    return closed_;
-  }
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::closed(lock_guard<mutex>&) const
-  {
-    return closed_;
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::empty() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return empty(lk);
-  }
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::full() const
-  {
-    return false;
-  }
-
-  template <class ValueType, class Queue>
-  typename sync_queue_base<ValueType, Queue>::size_type sync_queue_base<ValueType, Queue>::size() const
-  {
-    lock_guard<mutex> lk(mtx_);
-    return size(lk);
-  }
-
-  template <class ValueType, class Queue>
-  void sync_queue_base<ValueType, Queue>::throw_if_closed(unique_lock<mutex>& lk)
-  {
-    if (closed(lk))
-    {
-      BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-    }
-  }
-  template <class ValueType, class Queue>
-  void sync_queue_base<ValueType, Queue>::throw_if_closed(lock_guard<mutex>& lk)
-  {
-    if (closed(lk))
-    {
-      BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-    }
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::not_empty_or_closed(unique_lock<mutex>& ) const
-  {
-    return ! data_.empty() || closed_;
-  }
-
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::wait_until_not_empty_or_closed(unique_lock<mutex>& lk)
-  {
-    not_empty_.wait(lk, boost::bind(&sync_queue_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk)));
-    if (! empty(lk)) return false; // success
-    return true; // closed
-  }
-
-  template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_queue_base<ValueType, Queue>::wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
-  {
-    if (! not_empty_.wait_until(lk, tp, boost::bind(&sync_queue_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk))))
-      return queue_op_status::timeout;
-    if (! empty(lk)) return queue_op_status::success;
-    return queue_op_status::closed;
-  }
-
-  template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_queue_base<ValueType, Queue>::wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
-  {
-    bool (sync_queue_base<ValueType, Queue>::*closed_function_ptr)(unique_lock<mutex>&) const = &sync_queue_base<ValueType, Queue>::closed;
-    if (! not_empty_.wait_until(lk, tp, boost::bind(closed_function_ptr, boost::ref(*this), boost::ref(lk))))
-      return queue_op_status::timeout;
-    return queue_op_status::closed;
-  }
-
-} // detail
-} // concurrent
-} // boost
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif

contrib/restricted/boost/boost/thread/concurrent_queues/queue_adaptor.hpp

@@ -1,209 +0,0 @@
-#ifndef BOOST_THREAD_QUEUE_ADAPTOR_HPP
-#define BOOST_THREAD_QUEUE_ADAPTOR_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 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)
-//
-// See http://www.boost.org/libs/thread for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-#include <boost/thread/concurrent_queues/queue_base.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-namespace detail
-{
-
-  template <typename Queue>
-  class queue_adaptor_copyable_only :
-    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
-  {
-      Queue queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-    queue_adaptor_copyable_only()  {}
-
-    // Observers
-    bool empty() const  { return queue.empty(); }
-    bool full() const { return queue.full(); }
-    size_type size() const { return queue.size(); }
-    bool closed() const { return queue.closed(); }
-
-    // Modifiers
-    void close() { queue.close(); }
-
-    void push(const value_type& x) { queue.push(x); }
-
-    void pull(value_type& x) { queue.pull(x); };
-    value_type pull() { return queue.pull(); }
-
-    queue_op_status try_push(const value_type& x) { return queue.try_push(x); }
-    queue_op_status try_pull(value_type& x)  { return queue.try_pull(x); }
-
-    queue_op_status nonblocking_push(const value_type& x) { return queue.nonblocking_push(x); }
-    queue_op_status nonblocking_pull(value_type& x)  { return queue.nonblocking_pull(x); }
-
-    queue_op_status wait_push(const value_type& x) { return queue.wait_push(x); }
-    queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); }
-
-  };
-  template <typename Queue>
-  class queue_adaptor_movable_only :
-    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
-  {
-      Queue queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-
-    queue_adaptor_movable_only()  {}
-
-    // Observers
-    bool empty() const  { return queue.empty(); }
-    bool full() const { return queue.full(); }
-    size_type size() const { return queue.size(); }
-    bool closed() const { return queue.closed(); }
-
-    // Modifiers
-    void close() { queue.close(); }
-
-
-    void pull(value_type& x) { queue.pull(x); };
-    // enable_if is_nothrow_copy_movable<value_type>
-    value_type pull() { return queue.pull(); }
-
-    queue_op_status try_pull(value_type& x)  { return queue.try_pull(x); }
-
-    queue_op_status nonblocking_pull(value_type& x)  { return queue.nonblocking_pull(x); }
-
-    queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); }
-
-    void push(BOOST_THREAD_RV_REF(value_type) x) { queue.push(boost::move(x)); }
-    queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.try_push(boost::move(x)); }
-    queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.nonblocking_push(boost::move(x)); }
-    queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.wait_push(boost::move(x)); }
-  };
-
-  template <typename Queue>
-  class queue_adaptor_copyable_and_movable :
-    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
-  {
-      Queue queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-
-    queue_adaptor_copyable_and_movable()  {}
-
-    // Observers
-    bool empty() const  { return queue.empty(); }
-    bool full() const { return queue.full(); }
-    size_type size() const { return queue.size(); }
-    bool closed() const { return queue.closed(); }
-
-    // Modifiers
-    void close() { queue.close(); }
-
-
-    void push(const value_type& x) { queue.push(x); }
-
-    void pull(value_type& x) { queue.pull(x); };
-    // enable_if is_nothrow_copy_movable<value_type>
-    value_type pull() { return queue.pull(); }
-
-    queue_op_status try_push(const value_type& x) { return queue.try_push(x); }
-    queue_op_status try_pull(value_type& x)  { return queue.try_pull(x); }
-
-    queue_op_status nonblocking_push(const value_type& x) { return queue.nonblocking_push(x); }
-    queue_op_status nonblocking_pull(value_type& x)  { return queue.nonblocking_pull(x); }
-
-    queue_op_status wait_push(const value_type& x) { return queue.wait_push(x); }
-    queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); }
-
-    void push(BOOST_THREAD_RV_REF(value_type) x) { queue.push(boost::move(x)); }
-    queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.try_push(boost::move(x)); }
-    queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.nonblocking_push(boost::move(x)); }
-    queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.wait_push(boost::move(x)); }
-  };
-
-
-  template <class Q, class T,
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-#if defined __GNUC__ && ! defined __clang__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = true
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif // __GNUC__
-#elif defined _MSC_VER
-#if _MSC_VER < 1700
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = true
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif // _MSC_VER
-#else
-          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
-          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
-#endif
-#else
-          bool Copyable = is_copy_constructible<T>::value,
-          bool Movable = has_move_emulation_enabled<T>::value
-#endif
-      >
-  struct queue_adaptor;
-
-  template <class Q, class T>
-  struct queue_adaptor<Q, T, true, true> {
-    typedef queue_adaptor_copyable_and_movable<Q> type;
-  };
-  template <class Q, class T>
-  struct queue_adaptor<Q, T, true, false> {
-    typedef queue_adaptor_copyable_only<Q> type;
-  };
-  template <class Q, class T>
-  struct queue_adaptor<Q, T, false, true> {
-    typedef queue_adaptor_movable_only<Q> type;
-  };
-
-}
-
-  template <typename Queue>
-  class queue_adaptor :
-    public detail::queue_adaptor<Queue, typename Queue::value_type>::type
-  {
-  public:
-      typedef typename Queue::value_type value_type;
-      typedef typename Queue::size_type size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~queue_adaptor() {};
-  };
-}
-using concurrent::queue_adaptor;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif