Release 1.53.0

[SVN r82734]
2026-02-03 09:42:16 +00:00 · 2013-02-04 18:11:49 +00:00
428 changed files with 5139 additions and 49648 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,40 +0,0 @@
-#mac
-.DS_Store
-
-#projects
-.project
-
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-bin/*
-test/bin/*
-*.exe
-*.out
-*.app
-
-#doc
-
-doc/html
--- a/README.md
+++ b/README.md
@@ -1,10 +0,0 @@
-thread
-======
-
-Portable C++ multi-threading. C++11, C++14.
-
-### License
-
-Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
-
-
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -36,7 +36,6 @@ import os ;
 import feature ;
 import indirect ;
 import path ;
-import configure ; 

 project boost/thread
    : source-location ../src
@@ -50,8 +49,8 @@ project boost/thread
      <toolset>gcc:<cxxflags>-Wno-long-long
      #<define>BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
      #<define>BOOST_SYSTEM_NO_DEPRECATED
-      #<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
-
+      #<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS 
+      
      <library>/boost/system//boost_system
       #-pedantic -ansi -std=gnu++0x -Wextra -fpermissive
        <warnings>all
@@ -60,44 +59,29 @@ project boost/thread
        <toolset>gcc:<cxxflags>-Wno-long-long
        #<toolset>gcc:<cxxflags>-ansi
        #<toolset>gcc:<cxxflags>-fpermissive
-        <toolset>gcc-4:<cxxflags>-Wno-variadic-macros
-        <toolset>gcc-5:<cxxflags>-Wno-variadic-macros
-        #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
-        <toolset>gcc:<cxxflags>-Wunused-function
-        <toolset>gcc:<cxxflags>-Wno-unused-parameter

        <toolset>darwin:<cxxflags>-Wextra
        <toolset>darwin:<cxxflags>-pedantic
        #<toolset>darwin:<cxxflags>-ansi
        <toolset>darwin:<cxxflags>-fpermissive
        <toolset>darwin:<cxxflags>-Wno-long-long
-        #<toolset>darwin:<cxxflags>-Wno-variadic-macros
-        <toolset>darwin-4:<cxxflags>-Wno-variadic-macros
-        <toolset>darwin-5:<cxxflags>-Wno-variadic-macros
-        #<toolset>darwin:<cxxflags>-Wunused-local-typedefs
-        <toolset>darwin:<cxxflags>-Wunused-function
-        <toolset>darwin:<cxxflags>-Wno-unused-parameter

        #<toolset>pathscale:<cxxflags>-Wextra
        <toolset>pathscale:<cxxflags>-Wno-long-long
        <toolset>pathscale:<cxxflags>-pedantic

-        <toolset>clang:<warnings>on
        <toolset>clang:<cxxflags>-Wextra
+        <toolset>clang:<cxxflags>-pedantic
        #<toolset>clang:<cxxflags>-ansi
        #<toolset>clang:<cxxflags>-fpermissive
        <toolset>clang:<cxxflags>-Wno-long-long
-        <toolset>clang:<cxxflags>-Wunused-function
-        <toolset>clang:<cxxflags>-Wno-variadic-macros
-        <toolset>clang:<cxxflags>-Wno-unused-parameter

-        #<toolset>gcc-mingw-4.4.0:<cxxflags>-fdiagnostics-show-option
-        #<toolset>gcc-mingw-4.5.0:<cxxflags>-fdiagnostics-show-option
-        #<toolset>gcc-mingw-4.6.0:<cxxflags>-fdiagnostics-show-option
-        #<toolset>gcc-mingw-4.6.3:<cxxflags>-fdiagnostics-show-option
-        #<toolset>gcc-mingw-4.7.0:<cxxflags>-fdiagnostics-show-option
-        #<toolset>gcc-mingw-4.8.0:<cxxflags>-fdiagnostics-show-option
-        #<toolset>gcc:<cxxflags>-Wno-missing-field-initializers
+        <toolset>gcc-mingw-4.4.0:<cxxflags>-fdiagnostics-show-option
+        <toolset>gcc-mingw-4.5.0:<cxxflags>-fdiagnostics-show-option
+        <toolset>gcc-mingw-4.6.0:<cxxflags>-fdiagnostics-show-option
+        <toolset>gcc-mingw-4.6.3:<cxxflags>-fdiagnostics-show-option
+        <toolset>gcc-mingw-4.7.0:<cxxflags>-fdiagnostics-show-option
+        <toolset>gcc-mingw-4.8.0:<cxxflags>-fdiagnostics-show-option

        <toolset>darwin-4.6.2:<cxxflags>-Wno-delete-non-virtual-dtor
        <toolset>darwin-4.7.0:<cxxflags>-Wno-delete-non-virtual-dtor
@@ -109,7 +93,7 @@ project boost/thread
        <toolset>clang-3.0:<cxxflags>-Wno-delete-non-virtual-dtor
        #<toolset>clang-3.0:<cxxflags>-Wno-unused-function
        #<toolset>clang-3.0:<cxxflags>-Wno-unused-variable
-
+        
 # Note: Some of the remarks from the Intel compiler are disabled
 # remark #193: zero used for undefined preprocessing identifier "XXX"
 # remark #304: access control not specified ("public" by default)
@@ -120,14 +104,8 @@ project boost/thread
        <toolset>intel:<cxxflags>-wd193,304,383,444
        <toolset>intel:<cxxflags>-wd593,981
        <toolset>intel:<cxxflags>-wd1418
-        <toolset>intel:<cxxflags>-wd2415
+        <toolset>intel:<cxxflags>-wd2415 

-        <toolset>msvc:<cxxflags>/wd4100
-        <toolset>msvc:<cxxflags>/wd4512
-        <toolset>msvc:<cxxflags>/wd6246
-
-        <target-os>windows:<define>WIN32_LEAN_AND_MEAN
-        <target-os>windows:<define>BOOST_USE_WINDOWS_H

    # : default-build <threading>multi
    : usage-requirements  # pass these requirement to dependents (i.e. users)
@@ -137,7 +115,7 @@ project boost/thread
      <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
      #<define>BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
      #<define>BOOST_SYSTEM_NO_DEPRECATED
-      #<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
+      #<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS 
      <library>/boost/system//boost_system
    ;

@@ -151,8 +129,6 @@ local rule default_threadapi ( )
 feature.feature threadapi : pthread win32 : propagated ;
 feature.set-default threadapi : [ default_threadapi ] ;

-exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ; 
-
 rule tag ( name : type ? : property-set )
 {
    local result = $(name) ;
@@ -249,10 +225,10 @@ rule usage-requirements ( properties * )
        }
    }

-    #if ! <toolset>vacpp in $(properties) || <toolset-vacpp:version>11.1 in $(properties) || <toolset-vacpp:version>12.1.0.1 in $(properties)  || <toolset-vacpp:version>12.1 in $(properties)
-    #{
+    if ! <toolset>vacpp in $(properties) || <toolset-vacpp:version>11.1 in $(properties) || <toolset-vacpp:version>12.1.0.1 in $(properties)  
+    {
      result += <library>/boost/chrono//boost_chrono ;
-    #}
+    }

    return $(result) ;
 }
@@ -276,15 +252,8 @@ rule requirements ( properties * )
                result = <build>no ;
            }
        }
-        result += <define>BOOST_THREAD_DONT_USE_CHRONO ;
-        if ! [ configure.builds has_atomic_flag_lockfree 
-            : $(properties) : "lockfree boost::atomic_flag" ]  { 
-           result += <library>/boost/atomic//boost_atomic ; 
-        } 
-    } else {
-        result += <define>BOOST_THREAD_USES_CHRONO ;
-        result += <library>/boost/chrono//boost_chrono ;
    }
+    result += <define>BOOST_THREAD_DONT_USE_CHRONO ;

    return $(result) ;
 }
@@ -294,7 +263,6 @@ alias thread_sources
      win32/thread.cpp
      win32/tss_dll.cpp
      win32/tss_pe.cpp
-      future.cpp
    : ## requirements ##
      <threadapi>win32
    ;
@@ -303,7 +271,6 @@ alias thread_sources
    : ## pthread sources ##
      pthread/thread.cpp
      pthread/once.cpp
-      future.cpp
    : ## requirements ##
      <threadapi>pthread
    ;
@@ -311,12 +278,10 @@ alias thread_sources
 explicit thread_sources ;

 lib boost_thread
-    : thread_sources
+    : thread_sources future.cpp
    : <conditional>@requirements
    :
    : <link>shared:<define>BOOST_THREAD_USE_DLL=1
      <link>static:<define>BOOST_THREAD_USE_LIB=1
      <conditional>@usage-requirements
    ;
-
-boost-install boost_thread ;
--- a/build/has_atomic_flag_lockfree_test.cpp
+++ b/build/has_atomic_flag_lockfree_test.cpp
@@ -1,13 +0,0 @@
-// Copyright (c) 2013, Petr Machata, Red Hat Inc.
-//
-// Use modification and distribution are subject to the boost Software
-// License, Version 1.0.  (See http://www.boost.org/LICENSE_1_0.txt).
-
-#include "../../../boost/atomic.hpp"
-#include "../../../boost/static_assert.hpp"
-
-int main(int argc, char *argv[])
-{
-  BOOST_STATIC_ASSERT(BOOST_ATOMIC_FLAG_LOCK_FREE);
-  return 0;
-}
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -29,12 +29,4 @@ boostbook standalone
        <xsl:param>boost.root=../../../..
    ;

-###############################################################################
-alias boostdoc
-    : thread
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;
+
--- a/doc/acknowledgements.qbk
+++ b/doc/acknowledgements.qbk
@@ -1,6 +1,5 @@
 [/
  (C) Copyright 2007-8 Anthony Williams.
-  (C) Copyright 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).
--- a/doc/async_executors.qbk
+++ b/doc/async_executors.qbk
--- a/doc/barrier.qbk
+++ b/doc/barrier.qbk
@@ -1,12 +1,11 @@
 [/
  (C) Copyright 2007-8 Anthony Williams.
-  (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).
 ]

-[section:barriers Barriers -- EXTENSION]
+[section:barriers Barriers]

 A barrier is a simple concept. Also known as a ['rendezvous], it is a synchronization point between multiple threads. The barrier is
 configured for a particular number of threads (`n`), and as threads reach the barrier they must wait until all `n` threads have
@@ -19,22 +18,15 @@ arrived. Once the `n`-th thread has reached the barrier, all the waiting threads
    class barrier
    {
    public:
-        barrier(barrier const&) = delete;
-        barrier& operator=(barrier const&) = delete;
-
        barrier(unsigned int count);
-        template <typename F>
-        barrier(unsigned int count, F&&);
-
        ~barrier();

        bool wait();
-        void count_down_and_wait();
    };

 Instances of __barrier__ are not copyable or movable.

-[section Constructor `barrier(unsigned int)`]
+[heading Constructor]

    barrier(unsigned int count);

@@ -46,24 +38,7 @@ Instances of __barrier__ are not copyable or movable.

 ]

-[endsect]
-[section Constructor `barrier(unsigned int, F&&)`]
-
-    barrier(unsigned int count, F&& completion);
-
-[variablelist
-
-[[Requires:] [The result type of the completion function call `completion()` is `void` or `unsigned int`.]]
-
-[[Effects:] [Construct a barrier for `count` threads and a completion function `completion`.]]
-
-[[Throws:] [__thread_resource_error__ if an error occurs.]]
-
-]
-
-
-[endsect]
-[section Destructor `~barrier()`]
+[heading Destructor]

    ~barrier();

@@ -77,55 +52,21 @@ Instances of __barrier__ are not copyable or movable.

 ]

-[endsect]
-[section Member Function `wait()`]
+[heading Member function `wait`]

    bool wait();

 [variablelist

-[[Effects:] [Block until `count` threads have called `wait` or `count_down_and_wait` on `*this`. When the `count`-th thread calls `wait`,  the barrier is reset and all waiting threads are unblocked. 
-The reset depends on whether the barrier was constructed with a completion function or not. If there is no completion function or if the completion function result is void, the reset consists in restoring the original count. Otherwise the rest consist in assigning the result of the completion function (which must not be 0).]]
+[[Effects:] [Block until `count` threads have called `wait` on `*this`. When the `count`-th thread calls `wait`, all waiting threads
+are unblocked, and the barrier is reset. ]]

 [[Returns:] [`true` for exactly one thread from each batch of waiting threads, `false` otherwise.]]

-[[Throws:] [
-
- __thread_resource_error__ if an error occurs. 
-
- __thread_interrupted__ if the wait was interrupted by a call to
-__interrupt__ on the __thread__ object associated with the current thread of execution.
-
-]]
-
-[[Notes:] [`wait()` is an ['interruption point].]]
+[[Throws:] [__thread_resource_error__ if an error occurs.]]

 ]

 [endsect]
-[section Member Function `count_down_and_wait()`]
-
-        void count_down_and_wait();
-
-[variablelist
-
-[[Effects:] [Block until `count` threads have called `wait` or `count_down_and_wait` on `*this`. When the `count`-th thread calls `wait`,  the barrier is reset and all waiting threads are unblocked. 
-The reset depends on whether the barrier was constructed with a completion function or not. If there is no completion function or if the completion function result is void, the reset consists in restoring the original count. Otherwise the rest consist in assigning the result of the completion function (which must not be 0).]]
-
-[[Throws:] [
-
- __thread_resource_error__ if an error occurs. 
-
- __thread_interrupted__ if the wait was interrupted by a call to
-__interrupt__ on the __thread__ object associated with the current thread of execution.
-
-]]
-
-[[Notes:] [`count_down_and_wait()` is an ['interruption point].]]
-
-]
-

 [endsect]
-[endsect]
-[endsect]
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -1,6 +1,6 @@
 [/
  (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-16 Vicente J. Botet Escriba.
+  (C) Copyright 2011-12 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).
@@ -8,407 +8,6 @@

 [section:changes History]

-[heading Version 4.7.2 - boost 1.63]
-
-[*Fixed Bugs:]
-
-* fix boost::synchronized_value<>::load() 
-* fix relational operators of boost::synchronized_value<> 
-* fix compile failed with boost::user_scheduler
-* Fix minor possibility of loosing the notify
-
-[heading Version 4.7.1 - boost 1.62]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-
-Please define BOOST_THREAD_PATCH to apply the patch that could unfortunately results is a regression as described in [@http://svn.boost.org/trac/boost/ticket/12049 #12049].
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.
-
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/11097 #11097] 	test_scheduled_tp - ThreadSanitizer: heap-use-after-free
-* [@http://svn.boost.org/trac/boost/ticket/11951 #11951] 	Memory leak in boost::when_all
-* [@http://svn.boost.org/trac/boost/ticket/12102 #12102] condition_variable_fwd.hpp fails to compile when BOOST_THREAD_PROVIDES_INTERRUPTIONS is disabled
-* [@http://svn.boost.org/trac/boost/ticket/12120 #12120] Performance improvement in thread/barrier.hpp
-* [@http://svn.boost.org/trac/boost/ticket/12146 #12146] make_exceptional_future is not mentioned in the docs
-* [@http://svn.boost.org/trac/boost/ticket/12202 #12202] shared_lock should be in shared_mutex header
-* [@http://svn.boost.org/trac/boost/ticket/12220 #12220] 	Memory leak in future::then()
-* [@http://svn.boost.org/trac/boost/ticket/12293 #12293] boost::future::then lambda called before future is ready.
-* [@http://svn.boost.org/trac/boost/ticket/12350 #12350] shared_mutex (pthreads) unlocked too early in unlock_shared()
-* [@http://svn.boost.org/trac/boost/ticket/12371 #12371] boost thread/future.hpp fails to build
-
-
-and several PR
-
-* #88 fix typos in boost::upgrade_lock
-* #89 fix a bug in upgrade_to_unique_lock<>::operator=()
-* #90 fix a bug in try_lock_wrapper<>::operator=()
-* #91 Add shared_lock_guard to the included lock types
-* #92 Fixed compilation with MSVC-8.  
-* #93 Fix variable shadowing warnings (Clang)
-* #94 fix bugs in boost::barrier
-* #95 fix a mistake in boost::completion_latch
-* #96 rename async_func.hpp to invoker.hpp.
-* #97 fix a mistake in sync_timed_queue<>::pull_until()
-
-[heading Version 4.7.0 - boost 1.61]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-
-Please define BOOST_THREAD_PATCH to apply the patch that could unfortunately results is a regression as described in [@http://svn.boost.org/trac/boost/ticket/12049 #12049].
-
-* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
-* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
-* [@http://svn.boost.org/trac/boost/ticket/9118 #9118] Seg fault on thread join when llvm and libc++ are used
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.
-
-[*New Experimental Features:]
-
-* [@http://svn.boost.org/trac/boost/ticket/11772 #11772] Add a launch::sync policy
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/11494 #11494] boost::this_thread::yield() is marked as deprecated in the synopsis
-* [@http://svn.boost.org/trac/boost/ticket/11562 #11562] (condition_variable_any::wait_until + recursive_mutex + steady_clock) timer expires after computer time is set forward on Ubuntu 64-bit
-* [@http://svn.boost.org/trac/boost/ticket/12013 #12013] F_pass and FArgs_pass tests segfault
-* [@http://svn.boost.org/trac/boost/ticket/12036 #12036] boost::physical_concurrency always returns 0 if BOOST_USE_WINAPI_VERSION is not defined
-
-[heading Version 4.6.0 - boost 1.60]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
-* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
-* [@http://svn.boost.org/trac/boost/ticket/9118 #9118] Seg fault on thread join when llvm and libc++ are used
-* [@http://svn.boost.org/trac/boost/ticket/10942 #10942] Boost.Thread fails to build on Cygwin.
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.
-
-[*New Experimental Features:]
-
-
-* [@http://svn.boost.org/trac/boost/ticket/11231 #11231] Allow to set continuation future's destructor behavior to non-blocking
-* [@http://svn.boost.org/trac/boost/ticket/11424 #11424] Provide shared_timed_mutex as an alternative name for shared_mutex and deprecate the use of shared_mutex as a timed mutex
-* [@http://svn.boost.org/trac/boost/ticket/11734 #11734] future::then(Cont) should be able to execute the continuation on undetermined thread
-* [@http://svn.boost.org/trac/boost/ticket/11736 #11736] Allow to use launch::executor on future::then(launch::executor, cont)
-* [@http://svn.boost.org/trac/boost/ticket/11737 #11737] Add a launch::inherit policy that can be used on ::then() to use the policy of the parent future
-
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/6377 #6377] Condition variable blocks when changing time
-* [@http://svn.boost.org/trac/boost/ticket/6787 #6787] boost::thread::sleep() hangs if system time is rolled back
-* [@http://svn.boost.org/trac/boost/ticket/7665 #7665] this_thread::sleep_for no longer uses steady_clock in thread
-* [@http://svn.boost.org/trac/boost/ticket/7720 #7720] exception lock_error while intensive locking/unlocking of mutex
-* [@http://svn.boost.org/trac/boost/ticket/9309 #9309] test_latch fails often on clang-darwin-tot11
-* [@http://svn.boost.org/trac/boost/ticket/10788 #10788] GetLogicalProcessor isn't available for Windows platform less or equals to 0x0502
-* [@http://svn.boost.org/trac/boost/ticket/11090 #11090] ex_future_unwrap- ThreadSanitizer: lock-order-inversion (potential deadlock)
-* [@http://svn.boost.org/trac/boost/ticket/11158 #11158] Pthread thread deadlock when faketime used
-* [@http://svn.boost.org/trac/boost/ticket/11174 #11174] boost::condition_variable::timed_wait with predicate unexpectedly wakes up while should wait infinite
-* [@http://svn.boost.org/trac/boost/ticket/11185 #11185] Incorrect URL redirection
-* [@http://svn.boost.org/trac/boost/ticket/11192 #11192] boost::future<>::then() with an executor doesn't compile when the callback returns a future
-* [@http://svn.boost.org/trac/boost/ticket/11250 #11250] future made from make_exceptional fails on assertion in destructor
-* [@http://svn.boost.org/trac/boost/ticket/11256 #11256] future<>::is_ready() == false in continuation function
-* [@http://svn.boost.org/trac/boost/ticket/11261 #11261] bad use of scoped threads in basic_thread_pool
-* [@http://svn.boost.org/trac/boost/ticket/11262 #11262] bad use of direct pointer in shared_state_nullary_task
-* [@http://svn.boost.org/trac/boost/ticket/11263 #11263] lock already locked lock
-* [@http://svn.boost.org/trac/boost/ticket/11266 #11266] boost::packaged_task has invalid variadic signature
-* [@http://svn.boost.org/trac/boost/ticket/11302 #11302] boost thread doesn't build with BOOST_THREAD_PATCH.
-* [@http://svn.boost.org/trac/boost/ticket/11322 #11322] sleep_for() nanoseconds overload will always return too early on windows
-* [@http://svn.boost.org/trac/boost/ticket/11329 #11329] using declarative for GetProcessHeap, .... fails
-* [@http://svn.boost.org/trac/boost/ticket/11368 #11368] boost thread's usage of CreateWaitableTimer wakes PC from sleep (doh)
-* [@http://svn.boost.org/trac/boost/ticket/11377 #11377] Boost condition variable always waits for system clock deadline
-* [@http://svn.boost.org/trac/boost/ticket/11435 #11435] gcc compiler warning in future.hpp
-* [@http://svn.boost.org/trac/boost/ticket/11555 #11555] devector.hpp assumes allocator_traits_type is always present
-* [@http://svn.boost.org/trac/boost/ticket/11562 #11562] (condition_variable_any::wait_until + recursive_mutex + steady_clock) timer expires after computer time is set forward on Ubuntu 64-bit
-* [@http://svn.boost.org/trac/boost/ticket/11672 #11672] Thread: Should use unique_ptr, not auto_ptr
-* [@http://svn.boost.org/trac/boost/ticket/11688 #11688] thread::try_join_until: Avoid busy wait if system clock changes
-* [@http://svn.boost.org/trac/boost/ticket/11672 #11716] ::then(f) should inherit the parent Executor
-* [@http://svn.boost.org/trac/boost/ticket/11795 #11795] Incorrect version specification for documentation of thread destructor
-* [@http://svn.boost.org/trac/boost/ticket/11796 #11796] Thread move assignment operator, does not detach previous thread data
-* [@http://svn.boost.org/trac/boost/ticket/11817 #11817] 'sync_queue_is_closed' was not declared in boost/thread/executors/thread_executor.hpp
-* [@http://svn.boost.org/trac/boost/ticket/11818 #11818] future.then will be blocked if promise is set after the invocation of then
-
-* [@http://svn.boost.org/trac/boost/ticket/12049 #12049] Assertion failure from detached threads during shutdown
-
-[heading Version 4.5.0 - boost 1.58]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
-* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
-* [@http://svn.boost.org/trac/boost/ticket/9118 #9118] Seg fault on thread join when llvm and libc++ are used
-* [@http://svn.boost.org/trac/boost/ticket/9309 #9309] test_latch fails often on clang-darwin-tot11
-* [@http://svn.boost.org/trac/boost/ticket/9311 #9311] ex_lambda_future fails on msvc-11.0
-* [@http://svn.boost.org/trac/boost/ticket/10942 #10942] Boost.Thread fails to build on Cygwin.
-
-[/
-* [@http://svn.boost.org/trac/boost/ticket/7319 #7319] Take care of c++std-lib-32966 issue
-* [@http://svn.boost.org/trac/boost/ticket/10651 #10651] boost::thread leaks memory when using the MinGW compiler.
-* [@http://svn.boost.org/trac/boost/ticket/10685 #10685] mfc_thread_init.hpp does not compile.
-* [@http://svn.boost.org/trac/boost/ticket/10967 #10967] Timed wait points inconsistently convert relative to absolute waits.
-]
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.
-
-[*Sever limitations:]
-
-There are some severe bugs that prevent the use of the library on concrete contexts, in particular:
-
-* on thread specific storage that prevent the library to be used with dynamic libraries ( [@http://svn.boost.org/trac/boost/ticket/3926 #3926], ),
-
-[*New Experimental Features:]
-
-* [@http://svn.boost.org/trac/boost/ticket/9600 #9600] Async: Add task_region
-* [@http://svn.boost.org/trac/boost/ticket/10611 #10611] Add emplace promise::set_value and emplace make_ready_future
-* [@http://svn.boost.org/trac/boost/ticket/10826 #10826] Add scheduled executor operations
-* [@http://svn.boost.org/trac/boost/ticket/11048 #11048] Add a serial_executor based on continuations
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/6787 #6787] boost::thread::sleep() hangs if system time is rolled back
-* [@http://svn.boost.org/trac/boost/ticket/10734 #10734] Submit method work differently on different executors, some throw exception and some silently ignore error (thread_executor and inline_executor)
-* [@http://svn.boost.org/trac/boost/ticket/10736 #10736] Task exceptions silently ignored. I think std::terminate solution from N3785 and std::thread is better choice and more consistent.
-* [@http://svn.boost.org/trac/boost/ticket/10737 #10737] In serial_executor we have infinite wait if task throw exception.
-* [@http://svn.boost.org/trac/boost/ticket/10822 #10822] Boost.Thread fails to compile on Android
-* [@http://svn.boost.org/trac/boost/ticket/10824 #10824] Boost.Thread 1.57 breaks Windows XP compatibility for SP2 and below.
-* [@http://svn.boost.org/trac/boost/ticket/10963 #10963] future<future<T>>::then Has No Implementation
-* [@http://svn.boost.org/trac/boost/ticket/10964 #10964] future<future<T>>::unwrap().then() Deadlocks
-* [@http://svn.boost.org/trac/boost/ticket/10968 #10968] The futures returned by async() and future::then() are not blocking.
-* [@http://svn.boost.org/trac/boost/ticket/10971 #10971] shared_future::get()/get_or() must be const
-* [@http://svn.boost.org/trac/boost/ticket/10972 #10972] shared_future::then() can be called multiple times.
-* [@http://svn.boost.org/trac/boost/ticket/10979 #10979] Support T& type deduction when the make_ready_future parameter is reference_wrapper<T>
-* [@http://svn.boost.org/trac/boost/ticket/10996 #10996] Thread physical_concurrency() is failing on Windows
-* [@http://svn.boost.org/trac/boost/ticket/11035 #11035] BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE not defined for Android
-* [@http://svn.boost.org/trac/boost/ticket/11053 #11053] The attached code results in a R6025 - pure virtual function call in run_thread_exit_callbacks
-
-
-[heading Version 4.4.0 - boost 1.57]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/2442 #2442] Application statically linked with Boost.Thread crashes when Google Desktop is installed (Windows XP)
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
-* [@http://svn.boost.org/trac/boost/ticket/7319 #7319] Take care of c++std-lib-32966 issue
-* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
-* [@http://svn.boost.org/trac/boost/ticket/9118 #9118] Seg fault on thread join when llvm and libc++ are used
-* [@http://svn.boost.org/trac/boost/ticket/9309 #9309] test_latch fails often on clang-darwin-tot11
-* [@http://svn.boost.org/trac/boost/ticket/9310 #9310] test_4648_lib fails on clang-darwin-asan11
-* [@http://svn.boost.org/trac/boost/ticket/9311 #9311] ex_lambda_future fails on msvc-11.0
-* [@http://svn.boost.org/trac/boost/ticket/10537 #10537] Application crash on throw exception
-* [@http://svn.boost.org/trac/boost/ticket/10651 #10651] boost::thread leaks memory when using the MinGW compiler
-
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last snapshot.
-
-[*Sever limitations:]
-
-There are some severe bugs that prevent the use of the library on concrete contexts, in particular:
-
-* on thread specific storage that prevent the library to be used with dynamic libraries,
-
-[*New Experimental Features:]
-
-* [@http://svn.boost.org/trac/boost/ticket/6227 #6227] Synchro: Use of variadic templates on Generic Locking Algorithms on compilers providing them
-* [@http://svn.boost.org/trac/boost/ticket/10298 #10298] Synchro: Added queue views.
-* [@http://svn.boost.org/trac/boost/ticket/10300 #10300] Async: Added generic_executor_ref.
-* [@http://svn.boost.org/trac/boost/ticket/10552 #10552] Add make_valid_future
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/6782 #6782] call_once uses incorrect barrier intrinsic on Visual Studio
-* [@http://svn.boost.org/trac/boost/ticket/6787 #6787] boost::thread::sleep() hangs if system time is rolled back
-* [@http://svn.boost.org/trac/boost/ticket/7665 #7665] this_thread::sleep_for no longer uses steady_clock in thread
-* [@http://svn.boost.org/trac/boost/ticket/9307 #9307] future::fallback_to assert with ERRORRRRR boost: mutex lock failed in pthread_mutex_lock: Invalid argument
-* [@http://svn.boost.org/trac/boost/ticket/9308 #9308] future::async fails with terminate called throwing an exception when called with a lambda - clang-darwin-asan11
-* [@http://svn.boost.org/trac/boost/ticket/9310 #9310] test_4648_lib fails on clang-darwin-asan11
-* [@http://svn.boost.org/trac/boost/ticket/9425 #9425] Boost promise & future does not use supplied allocator for value storage
-* [@http://svn.boost.org/trac/boost/ticket/9558 #9558] future continuations unit test hangs in get()/pthread_cond_wait() on Mac 10.7/32-bit/x86/darwin-4.2.1
-* [@http://svn.boost.org/trac/boost/ticket/9787 #9787] [windows] Small duration value passed down to basic_timed_mutex::try_lock_until and condition_variable::wait_until can cause infinite or near infinite wait for win32
-* [@http://svn.boost.org/trac/boost/ticket/9880 #9880] [windows] boost::condition_variable.timed_wait() exception if system time < 1970
-* [@http://svn.boost.org/trac/boost/ticket/10159 #10159] GCC 4.4 error sorry, unimplemented
-* [@http://svn.boost.org/trac/boost/ticket/10196 #10196] thread_specific_ptr does not support void*
-* [@http://svn.boost.org/trac/boost/ticket/10296 #10296] Boost.Thread 1.56 rc1 does not compile on Mingw
-* [@http://svn.boost.org/trac/boost/ticket/10297 #10297] Boost.Thread 1.56 rc1 hangs when built with clang on armhf
-* [@http://svn.boost.org/trac/boost/ticket/10340 #10340] No boost::promise<T>::set_value(const T&) overload present in C++03 mode
-* [@http://svn.boost.org/trac/boost/ticket/10425 #10425] Missing documentation for when_all/when_any.
-* [@http://svn.boost.org/trac/boost/ticket/10426 #10426] Take in account the deferred futures in when_all.
-* [@http://svn.boost.org/trac/boost/ticket/10427 #10427] Take in account the deferred and ready futures in when_any.
-* [@http://svn.boost.org/trac/boost/ticket/10428 #10428] Adapt to new unique_ptr interface in Boost.Move
-* [@http://svn.boost.org/trac/boost/ticket/10465 #10465] Missing implementation of when_all/when_any when the result is a tuple.
-* [@http://svn.boost.org/trac/boost/ticket/10476 #10476] classes using BOOST_THREAD_MOVABLE_ONLY<T> dont satisfy is_copy_constructible<T>::value == false
-* [@http://svn.boost.org/trac/boost/ticket/10478 #10478] Data race in boost/thread/future.hpp
-* [@http://svn.boost.org/trac/boost/ticket/10529 #10529] The pthread/condition_variable_any constructor reports incorrect error code for pthread_cond_init
-* [@http://svn.boost.org/trac/boost/ticket/10563 #10563] shared_future<R>::then should be const
-
-
-[heading Version 4.3.0 - boost 1.56]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/2442 #2442] Application statically linked with Boost.Thread crashes when Google Desktop is installed (Windows XP)
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
-* [@http://svn.boost.org/trac/boost/ticket/6782 #6782] call_once uses incorrect barrier intrinsic on Visual Studio
-* [@http://svn.boost.org/trac/boost/ticket/7319 #7319] Take care of c++std-lib-32966 issue
-* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
-* [@http://svn.boost.org/trac/boost/ticket/9307 #9307] future::fallback_to assert with ERRORRRRR boost: mutex lock failed in pthread_mutex_lock: Invalid argument
-* [@http://svn.boost.org/trac/boost/ticket/9308 #9308] future::async fails with terminate called throwing an exception when called with a lambda - clang-darwin-asan11
-* [@http://svn.boost.org/trac/boost/ticket/9310 #9310] test_4648_lib fails on clang-darwin-asan11
-* [@http://svn.boost.org/trac/boost/ticket/9311 #9311] ex_lambda_future fails on msvc-11.0
-
-* [@http://svn.boost.org/trac/boost/ticket/9425 #9425] Boost promise & future does not use supplied allocator for value storage
-* [@http://svn.boost.org/trac/boost/ticket/9558 #9558] future continuations unit test hangs in get()/pthread_cond_wait() on Mac 10.7/32-bit/x86/darwin-4.2.1
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last snapshot.
-
-
-[*Sever limitations:]
-
-There are some severe bugs that prevent the use of the library on concrete contexts, in particular:
-
-* on thread specific storage that prevent the library to be used with dynamic libraries,
-* The experimental features of boost::future have some severe holes that make the program crash unexpectedly.
-
-[*New Experimental Features:]
-
-* [@http://svn.boost.org/trac/boost/ticket/7446 #7446] Async: Add when_any.
-* [@http://svn.boost.org/trac/boost/ticket/7447 #7447] Async: Add when_all.
-* [@http://svn.boost.org/trac/boost/ticket/7448 #7448] Async: Add async taking a scheduler parameter.
-* [@http://svn.boost.org/trac/boost/ticket/8274 #8274] Synchro: Add concurrent queue
-* [@http://svn.boost.org/trac/boost/ticket/8518 #8518] Synchro: Add a latch class.
-* [@http://svn.boost.org/trac/boost/ticket/8513 #8513] Async: Add a basic thread_pool executor.
-* [@http://svn.boost.org/trac/boost/ticket/8516 #8516] Async: Add future/shared_future::then taking a scheduler as parameter.
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/8070 #8070] prefer GetTickCount64 over GetTickCount
-* [@http://svn.boost.org/trac/boost/ticket/9333 #9333] ex_scoped_thread compile fails on msvc-12.0
-* [@http://svn.boost.org/trac/boost/ticket/9366 #9366] async(Executor, ...) fails to compile with msvc-10,11,12 	
-* [@http://svn.boost.org/trac/boost/ticket/9402 #9402] test_excutor regression on msvc-10,11,12
-* [@http://svn.boost.org/trac/boost/ticket/9404 #9404] ex_make_future regression error
-* [@http://svn.boost.org/trac/boost/ticket/9471 #9471] Synchronization documentation nits
-* [@http://svn.boost.org/trac/boost/ticket/9535 #9535] Missing exception safety might result in crash
-* [@http://svn.boost.org/trac/boost/ticket/9618 #9618] try_join_for problem: program is not terminate.
-* [@http://svn.boost.org/trac/boost/ticket/9673 #9673] thread compilation with MingW/gcc on Windows gives errors
-* [@http://svn.boost.org/trac/boost/ticket/9708 #9708] boost::condition_variable::timed_wait unexpectedly wakes up while should wait infinite
-* [@http://svn.boost.org/trac/boost/ticket/9711 #9711] future continuation called twice
-
-[heading Version 4.2.0 - boost 1.55]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/2442 #2442] Application statically linked with Boost.Thread crashes when Google Desktop is installed (Windows XP)
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
-* [@http://svn.boost.org/trac/boost/ticket/6782 #6782] call_once uses incorrect barrier intrinsic on Visual Studio
-* [@http://svn.boost.org/trac/boost/ticket/7319 #7319] Take care of c++std-lib-32966 issue
-* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
-* [@http://svn.boost.org/trac/boost/ticket/9307 #9307] future::fallback_to assert with ERRORRRRR boost: mutex lock failed in pthread_mutex_lock: Invalid argument
-* [@http://svn.boost.org/trac/boost/ticket/9308 #9308] future::async fails with terminate called throwing an exception when called with a lambda - clang-darwin-asan11
-* [@http://svn.boost.org/trac/boost/ticket/9311 #9311] ex_lambda_future fails on msvc-11.0
-* [@http://svn.boost.org/trac/boost/ticket/9310 #9310] test_4648_lib fails on clang-darwin-asan11
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread trunk regression test] to see the current state.
-
-[*Sever limitations:]
-
-There are some severe bugs that prevent the use of the library on concrete contexts, in particular:
-
-* on thread specific storage that prevent the library to be used with dynamic libraries,
-* The experimental features of boost::future have some severe holes that make the program crash unexpectedly.
-
-[*New Features:]
-
-* [@http://svn.boost.org/trac/boost/ticket/8519 #8519] Synchro: Update class barrier with a completion function.
-
-* [@http://svn.boost.org/trac/boost/ticket/8515 #8515] Async: Add shared_future::then.
-* [@http://svn.boost.org/trac/boost/ticket/8519 #8519] Synchro: Update class barrier with a completion function
-* [@http://svn.boost.org/trac/boost/ticket/8615 #8615] Async: Replace make_future/make_shared_future by make_ready_future.
-* [@http://svn.boost.org/trac/boost/ticket/8627 #8627] Async: Add future<>::unwrap and unwrapping constructor.
-* [@http://svn.boost.org/trac/boost/ticket/8677 #8677] Async: Add future<>::get_or.
-* [@http://svn.boost.org/trac/boost/ticket/8678 #8678] Async: Add future<>::fallback_to.
-* [@http://svn.boost.org/trac/boost/ticket/8891 #8891] upgrade_to_unique_lock: missing mutex() function.
-* [@http://svn.boost.org/trac/boost/ticket/8955 #8955] Request for more efficient way to get exception_ptr from future.
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/7461 #7461] detail::win32::ReleaseSemaphore may be called with count_to_release equal to 0
-* [@http://svn.boost.org/trac/boost/ticket/8070 #8070] prefer GetTickCount64 over GetTickCount
-* [@http://svn.boost.org/trac/boost/ticket/8768 #8768] win32 condition_variable::wait_until infinite wait in rare cases.
-* [@http://svn.boost.org/trac/boost/ticket/8817 #8817] Boost Thread Windows CE _createthreadex handling breaks mingw w64.
-* [@http://svn.boost.org/trac/boost/ticket/8943 #8943] Failed to compile code using boost::call_once with Intel C++ Composer XE 2013 on Windows.
-* [@http://svn.boost.org/trac/boost/ticket/8931 #8931] Typos in external_locking reference.
-* [@http://svn.boost.org/trac/boost/ticket/9029 #9029] Misprint in documentation.
-* [@http://svn.boost.org/trac/boost/ticket/9037 #9037] gcc -Wshadow gives warnings in condition_variable{,_fwd}.hpp.
-* [@http://svn.boost.org/trac/boost/ticket/9041 #9041] Boost.Thread DSO's may need to link with Boost.Atomic.
-* [@http://svn.boost.org/trac/boost/ticket/9048 #9048] boost::scoped_thread useless ctor with variadic template arguments.
-* [@http://svn.boost.org/trac/boost/ticket/9079 #9079] Condition variable will wait forever for some timepoint values (Win).
-
-[heading Version 4.1.0 - boost 1.54]
-
-[*New Features:]
-
-* [@http://svn.boost.org/trac/boost/ticket/7285 #7285] C++11 compliance: Allow to pass movable arguments for call_once.
-* [@http://svn.boost.org/trac/boost/ticket/7445 #7445] Async: Add future<>.then
-* [@http://svn.boost.org/trac/boost/ticket/7449 #7449] Synchro: Add a synchronized value class
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/4878 #4878] MinGW 4.5.0 undefined reference to bool interruptible_wait(detail::win32::handle handle_to_wait_for,detail::t imeout target_time).
-* [@http://svn.boost.org/trac/boost/ticket/4882 #4882] Win32 shared_mutex does not handle timeouts correctly.
-* [@http://svn.boost.org/trac/boost/ticket/5752 #5752] boost::call_once() is unreliable on some platforms
-* [@http://svn.boost.org/trac/boost/ticket/6652 #6652] Boost.Thread shared_mutex.hpp:50:99: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
-* [@http://svn.boost.org/trac/boost/ticket/6843 #6843] [Intel C++] Compile Errors with '#include <atomic>'
-* [@http://svn.boost.org/trac/boost/ticket/6966 #6966] future boost::future_category inconsistent dll linkage
-* [@http://svn.boost.org/trac/boost/ticket/7720 #7720] exception lock_error while intensive locking/unlocking of mutex
-* [@http://svn.boost.org/trac/boost/ticket/7755 #7755] Thread: deadlock with shared_mutex on Windows
-* [@http://svn.boost.org/trac/boost/ticket/7980 #7980] Build error: msvc-11.0 and BOOST_THREAD_DONT_USE_DATETIME
-* [@http://svn.boost.org/trac/boost/ticket/7982 #7982] pthread_delay_np() parm compile error on AIX
-* [@http://svn.boost.org/trac/boost/ticket/8027 #8027] thread library fails to compile with Visual Studio 2003
-* [@http://svn.boost.org/trac/boost/ticket/8070 #8070] prefer GetTickCount64 over GetTickCount
-* [@http://svn.boost.org/trac/boost/ticket/8136 #8136] boost::this_thread::sleep_for() sleeps longer than it should in Windows
-* [@http://svn.boost.org/trac/boost/ticket/8212 #8212] Boost thread compilation error on Solaris 10
-* [@http://svn.boost.org/trac/boost/ticket/8237 #8237] fix documentation for 'thread_group'
-* [@http://svn.boost.org/trac/boost/ticket/8239 #8239] barrier::wait() not marked as interruption_point
-* [@http://svn.boost.org/trac/boost/ticket/8323 #8323] boost::thread::try_join_for/try_join_until may block indefinitely due to a combination of problems in Boost.Thread and Boost.Chrono 	
-* [@http://svn.boost.org/trac/boost/ticket/8337 #8337] The internal representation of "std::string(this->code()->message())" escapes, but is destroyed when it exits scope.
-* [@http://svn.boost.org/trac/boost/ticket/8371 #8371] C++11 once_flag enabled when constexpr is not available
-* [@http://svn.boost.org/trac/boost/ticket/8422 #8422] Assertion in win32::WaitForSingleObject()
-* [@http://svn.boost.org/trac/boost/ticket/8443 #8443] Header file inclusion order may cause crashes
-* [@http://svn.boost.org/trac/boost/ticket/8451 #8451] Missing documented function 'boost::scoped_thread::joinable'
-* [@http://svn.boost.org/trac/boost/ticket/8458 #8458] -DBOOST_THREAD_DONT_USE_CHRONO in thread.obj.rsp but not explicitly set
-* [@http://svn.boost.org/trac/boost/ticket/8530 #8530] [Coverity] Unused variable thread_handle, uninitialized variable cond_mutex in thread/pthread/thread_data.hpp
-* [@http://svn.boost.org/trac/boost/ticket/8550 #8550] static linking of Boost.Thread with an MFC-Dll
-* [@http://svn.boost.org/trac/boost/ticket/8576 #8576] "sur parolle" should be "sur parole".
-* [@http://svn.boost.org/trac/boost/ticket/8596 #8596] With C++0x enabled, boost::packaged_task stores a reference to function objects, instead of a copy.
-* [@http://svn.boost.org/trac/boost/ticket/8626 #8626] Reintroduce BOOST_VERIFY on pthread_mutex_destroy return type
-* [@http://svn.boost.org/trac/boost/ticket/8645 #8645] Typo in Strict lock definition
-* [@http://svn.boost.org/trac/boost/ticket/8671 #8671] promise: set_..._at_thread_exit 	
-* [@http://svn.boost.org/trac/boost/ticket/8672 #8672] future<>::then(void()) doesn't works
-* [@http://svn.boost.org/trac/boost/ticket/8674 #8674] Futures as local named objects can't be returned with implicit move.
-
 [heading Version 4.0.0 - boost 1.53]

 [/
@@ -442,7 +41,6 @@ Provided when BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK is defined (Default
 See BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK and BOOST_THREAD_DONT_PROVIDE_SIGNATURE_PACKAGED_TASK.

 * [@http://svn.boost.org/trac/boost/ticket/7282 #7282] C++11 compliance: Add packaged_task::make_ready_at_thread_exit function
-* [@http://svn.boost.org/trac/boost/ticket/7285 #7285] C++11 compliance: Allow to pass movable arguments for call_once

 * [@http://svn.boost.org/trac/boost/ticket/7412 #7412] C++11 compliance: Add async from movable callable and movable arguments
 Provided when BOOST_THREAD_PROVIDES_VARIADIC_THREAD and BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK are defined (Default value from Boost 1.55):
@@ -465,13 +63,11 @@ See BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK and BOOST_THREAD_DONT_PROVIDE_

 [*Fixed Bugs:]

-* [@http://svn.boost.org/trac/boost/ticket/5752 #5752] boost::call_once() is unreliable on some platforms
 * [@http://svn.boost.org/trac/boost/ticket/7464 #7464] BOOST_TEST(n_alive == 1); fails due to race condition in a regression test tool.
 * [@http://svn.boost.org/trac/boost/ticket/7657 #7657] Serious performance and memory consumption hit if condition_variable methods condition notify_one or notify_all is used repeatedly.
 * [@http://svn.boost.org/trac/boost/ticket/7665 #7665] this_thread::sleep_for no longer uses steady_clock in thread.
 * [@http://svn.boost.org/trac/boost/ticket/7668 #7668] thread_group::join_all() should check whether its threads are joinable.
 * [@http://svn.boost.org/trac/boost/ticket/7669 #7669] thread_group::join_all() should catch resource_deadlock_would_occur.
-* [@http://svn.boost.org/trac/boost/ticket/7671 #7671] Error including boost/thread.hpp header on iOS.
 * [@http://svn.boost.org/trac/boost/ticket/7672 #7672] lockable_traits.hpp syntax error: "defined" token misspelled.
 * [@http://svn.boost.org/trac/boost/ticket/7798 #7798] boost::future set_wait_callback thread safety issues.
 * [@http://svn.boost.org/trac/boost/ticket/7808 #7808] Incorrect description of effects for this_thread::sleep_for and this_thread::sleep_until.
@@ -479,8 +75,6 @@ See BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK and BOOST_THREAD_DONT_PROVIDE_
 * [@http://svn.boost.org/trac/boost/ticket/7874 #7874] compile warning: thread.hpp:342: warning: type attributes are honored only at type definition.
 * [@http://svn.boost.org/trac/boost/ticket/7875 #7875] BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED should not be enabled by default.
 * [@http://svn.boost.org/trac/boost/ticket/7882 #7882] wrong exception text from condition_variable::wait(unique_lock<mutex>&).
-* [@http://svn.boost.org/trac/boost/ticket/7890 #7890] thread::do_try_join_until() is missing a return type.
-


 [heading Version 3.1.0 - boost 1.52]
@@ -749,16 +343,19 @@ been moved to __thread_id__.

 The following features will be included in next releases. 

-# Add some minor features, in particular
+# Complete the C++11 missing features, in particular
+  * [@http://svn.boost.org/trac/boost/ticket/7285 #7285] C++11 compliance: Allow to pass movable arguments for call_once. 
+  * [@http://svn.boost.org/trac/boost/ticket/6227 #6227] C++11 compliance: Use of variadic templates on Generic Locking Algorithms on compilers providing them. 
+
+
+# Add some of the extension proposed in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3428.pdf A Standardized Representation of Asynchronous Operations], in particular
+
  * [@http://svn.boost.org/trac/boost/ticket/7589 #7589] Synchro: Add polymorphic lockables.
-
-# Add some features based on C++ proposals, in particular
-  * [@http://svn.boost.org/trac/boost/ticket/8273 #8273] Synchro: Add externally locked streams.
-  * [@http://svn.boost.org/trac/boost/ticket/8514 #8514] Async: Add a thread_pool executor with work stealing.
-
-# And some additional extensions related to futures as:
-
-  * [@http://svn.boost.org/trac/boost/ticket/8517 #8517] Async: Add a variadic shared_future::then.
+  * [@http://svn.boost.org/trac/boost/ticket/7449 #7449] Synchro: Add a synchronized value class.
+  * [@http://svn.boost.org/trac/boost/ticket/7445 #7445] Async: Add future<>.then.
+  * [@http://svn.boost.org/trac/boost/ticket/7446 #7446] Async: Add when_any.
+  * [@http://svn.boost.org/trac/boost/ticket/7447 #7447] Async: Add when_all.
+  * [@http://svn.boost.org/trac/boost/ticket/7448 #7448] Async: Add async taking a scheduler parameter.


 [endsect]
--- a/doc/compliance.qbk
+++ b/doc/compliance.qbk
@@ -1,22 +1,18 @@
 [/
-  (C) Copyright 2011-2015 Vicente J. Botet Escriba.
+  (C) Copyright 2011-12 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).
 ]

 [section:compliance Conformance and Extension]
-[////////////////////////////////////////////]

 [section:cpp11 C++11 standard Thread library]
-[///////////////////////////////////////////]
-
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3376.html C++11 - Standard for Programming Language C++]]]


 [table C++11 standard Conformance
    [[Section]        [Description]  [Status] [Comments] [Ticket]]
-    [[30]        [Thread support library]  [Yes] [-] [-]]
+    [[30]        [Thread support library]  [Partial] [-] [-]]
    [[30.1]        [General]  [-] [-] [-]]
    [[30.2]        [Requirements]  [-] [-] [-]]
    [[30.2.1]        [Template parameter names]  [-] [-] [-]]
@@ -55,18 +51,18 @@
    [[30.4.2.2.1]        [unique_lock constructors, destructor, and assignment] [Yes]  [-]  [-]]
    [[30.4.2.2.2]        [unique_lock locking]  [Yes] [-] [-]]
    [[30.4.2.2.3]        [unique_lock modifiers]  [Yes] [-] [-]]
-    [[30.4.2.2.4]        [unique_lock observers]  [Yes] [ - ] [-]]
+    [[30.4.2.2.4]        [unique_lock observers]  [Yes] [] [-]]
    [[30.4.3]        [Generic locking algorithms]  [Partial] [variadic] [#6227]]
-    [[30.4.4]        [Call once]  [Yes] [-] [-]]
+    [[30.4.4]        [Call once]  [Partial] [call_once] [#7285]]
    [[30.4.4.1]        [Struct once_flag] [Yes] [-] [-]]
-    [[30.4.4.2]        [Function call_once] [Yes] [-] [-]]
+    [[30.4.4.2]        [Function call_once] [Partial] [interface] [#7285]]
    [[30.5]        [Condition variables]  [Yes] [-] [-]]
    [[30.5.1]        [Class condition_variable]  [Yes] [-] [-]]
    [[30.5.2]        [Class condition_variable_any]  [Yes] [-] [-]]
-    [[30.6]        [Futures]  [Yes] [-] [-]]
+    [[30.6]        [Futures]  [Partial] [noexcept] [#7279]]
    [[30.6.1]        [Overview]  [Partial] [-] [-]]
    [[30.6.2]        [Error handling]  [Yes] [-] [-]]
-    [[30.6.3]        [Class future_error]  [-] [-] [-]]
+    [[30.6.3]        [Class future_error]  [Partial] [noexcept] [#7279]]
    [[30.6.4]        [Shared state]  [-] [-] [-]]
    [[30.6.5]        [Class template promise]  [Yes] [-] [-]]
    [[30.6.6]        [Class template future]  [Yes] [-] [-]]
@@ -75,204 +71,39 @@
    [[30.6.9]        [Class template packaged_task]  [Yes] [-] [-]]
 ]

-
+[/
 [table Extension
    [[Section]     [Description]   [Comments]]
    [[30.3.1.5.x]        [interrupt]   [-]]
    [[30.3.2.x]        [Interruption]  [-]]
    [[30.3.2.y]        [at_thread_exit]  [-]]
    [[30.4.3.x]        [Generic locking algorithms begin/end]  [-]]
+    [[30.x]        [Barriers]  [-]]
+    [[30.y]        [Thread Local Storage]  [-]]
+    [[30.z]        [Class thread_group]  [-]]
 ]
-
-[/
-    [[30.x]        [Thread Local Storage]  [-]]
-    [[30.y]        [Class thread_group]  [-]]
 ]
 [endsect]
-[section:cxx14 C++14 standard Thread library - accepted changes]
-[//////////////////////////////////////////////////////////////]
-
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.html Working Draft, Standard for Programming Language C++]]


-[table [@http://isocpp.org/files/papers/N3659.html N3659 Shared locking in C++ revision 2] Conformance
+[section:shared Shared Locking extensions]
+
+[table Howard's Shared Locking Proposal Conformance
    [[Section]  [Description]  [Status] [Comments]]
-    [[30.4.1.4]      [Shared Lockables Types]  [Yes] [ - ]]
-    [[30.4.1.4.1]      [shared_mutex class]  [Yes] [ - ]]
-    [[30.4.2.3]      [Class template shared_lock]  [Yes] [-]]
+    [[X]        [Shared Locking]  [Yes] [Needs `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION]]
+    [[X.1]      [Shared Lockables Concepts]  [Yes] [ - ]]
+    [[X.1.1]      [SharedLockable concept]  [Yes] [ - ]]
+    [[X.1.2]      [UpgradeLockable concept]  [Yes] [ - ]]
+    [[X.2]      [Shared Mutex Types]  [Yes] [ - ]]
+    [[X.2.1]      [shared_mutex class]  [Yes] [ - ]]
+    [[X.2.2]      [upgrade_mutex class]  [Yes] [ - ]]
+    [[X.3]      [Locks]  [Yes] [-]]
+    [[X.3.1]      [unique_lock class adaptations]  [Yes] [-]]
+    [[X.3.2]      [shared_lock class]  [Yes] [ - ]]
+    [[X.3.3]      [upgrade_lock class]  [Yes] [-]]
 ]

 [endsect]


-[section:cxx1y C++14 TS Extensions for Concurrency V1 ]
-[/////////////////////////////////////////////////////]
-
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4107.html N4107-Extensions for Concurrency]]
-
-
-[table Improvements to std::future<T> and related APIs]
-    [[Section]  [Description]  [Status] [Comments]]
-    [[2.1]      [ - ]  [ - ] [ - ]]
-    [[2.2]      [Class template future]  [Partial] [ - ]]
-    [[2.2]      [then]  [ Partial ] [ without implicit unwrapping #10550 and blocking #10551 ]]
-    [[2.2]      [is_ready]  [ Yes ] [ - ]]
-    [[2.3]      [Class template shared_future]  [Partial] [ - ]]
-    [[2.3]      [then]  [ Partial ] [ Without implicit unwrapping #10550 and blocking #10551 ]]
-    [[2.3]      [is_ready]  [ Yes ] [ - ]]
-    [[2.4]      [Function template when_all]  [Partial] [ interface not complete #10426 and blocking #10551 ]]
-    [[2.5]      [Function template when_any]  [Partial] [ interface not complete #10427 and blocking #10551 ]]
-    [[2.6]      [Function template when_any_back]  [No] [ #XXXX  ]]
-    [[2.7]      [Function template make_ready_future]  [Yes] [ - ]]
-]
-
-
-[endsect]
-
-[section:cxx1y C++1z TS Concurrency - On going proposals]
-[///////////////////////////////////////////////////////]
-
-[section:latch C++ Latches and Barriers]
-[//////////////////////////////////////]
-
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3600.html N3600 C++ Latches and Barriers]]
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3817.html N3817 C++ Latches and Barriers]]
-
-[table C++ Latches and Barriers Conformance
-    [[Section]  [Description]  [Status] [Comments]]
-    [[X.1]      [Class latch]  [Partial] [ A new class latch has been added. The interface is a super set of the one of the proposal, taking some of the functions of the class barrier.]]
-    [[X.2]      [Class barrier]  [No] [ Even if Boost.Thread has a class boost:barrier it doesn't provides the same kind of services. There is an experimental completion_latch that could be used instead. ]]
-]
-
-[endsect]
-[section:queue C++ Concurrent Queues]
-[///////////////////////////////////]
-
-[note [@ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3533.html N3533 C++ Concurrent Queues]]
-
-[table C++ Concurrent Queues Conformance
-    [[Section]  [Description]  [Status] [Comments]]
-    [[X.1]      [Conceptual interface]  [Partial] [ The interface provided has some differences respect to this proposal. All the functions having a queue_op_status are not provided. No lock-free concrete classes ]]
-    [[X.1.1]      [Basic Operations]  [Partial] [ - ]]
-    [[X.1.1.1]      [push]  [yes] [ renamed push_back. ]]
-    [[X.1.1.2]      [value_pop]  [no] [ renamed pull_front with two flavors. ]]
-    [[X.1.2]      [Non-waiting operations]  [ - ] [ - ]]
-    [[X.1.2.1]      [try_push]  [yes] [ renamed try_push_back ]]
-    [[X.1.2.2]      [try_pop]  [yes] [ renamed try_pull_back ]]
-    [[X.1.3]      [Non-blocking operations]  [ - ] [ - ]]
-    [[X.1.3.1]      [nonblocking_push]  [Yes] [ renamed nonblocking_push_back  ]]
-    [[X.1.3.2]      [nonblocking_pop]  [Yes] [ renamed nonblocking_pull_front  ]]
-    [[X.1.4]      [Push-front operations]  [No] [ - ]]
-    [[X.1.5]      [Closed queues]  [Partial] [ - ]]
-    [[X.1.5.1]      [close]  [Yes] [ - ]]
-    [[X.1.5.2]      [is_closed]  [Yes] [ renamed closed ]]
-    [[X.1.5.3]      [wait_push]  [Yes] [ renamed wait_push_back ]]
-    [[X.1.5.4]      [wait_pop]  [Yes] [ renamed wait_pull_front ]]
-    [[X.1.5.5]      [wait_push_front]  [no] [ - ]]
-    [[X.1.5.6]      [wait_pop_back]  [no] [ - ]]
-    [[X.1.5.6]      [open]  [no] [ - ]]
-    [[X.1.6]      [Empty and Full Queues]  [Yes] [ - ]]
-    [[X.1.6.1]      [is_empty]  [Yes] [ - ]]
-    [[X.1.6.2]      [is_full]  [Yes] [ Added capacity ]]
-    [[X.1.7]      [Queue Names]  [No] [ Not considered a must for the time been. ]]
-    [[X.1.8]      [Element Type Requirements]  [Yes?] [ - ]]
-    [[X.1.9]      [Exception Handling]  [Yes?] [ - ]]
-    [[X.1.10]      [Queue Ordering]  [Yes?] [ - ]]
-    [[X.1.11]      [Lock-Free Implementations]  [No] [ waiting to stabilize the lock-based interface. Will use Boost.LockFree once it is Boost.Move aware. ]]
-    [[X.2]      [Concrete queues]  [Partial] [ - ]]
-    [[X.2.1]      [Locking Buffer Queue]  [Partial] [ classes sync_queue and a sync_bounded_queue. ]]
-    [[X.2.1]      [Lock-Free Buffer Queue]  [No] [ waiting to stabilize the lock-based interface. Will use Boost.LockFree once it is Boost.Move aware. ]]
-    [[X.3]      [Additional Conceptual Tools]  [No] [ - ]]
-    [[X.3.1]      [Fronts and Backs]  [No] [ - ]]
-    [[X.3.2]      [Streaming Iterators] [No] [ - ]]
-    [[X.3.3]      [Storage Iterators]  [No] [ - ]]
-    [[X.3.4]      [Binary Interfaces]  [No] [ - ]]
-    [[X.3.4]      [Managed Indirection]  [No] [ - ]]
-]
-[endsect]
-[section:executors Executors and Schedulers]
-[//////////////////////////////////////////]
-
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3785.pdf N3785 Executors and Schedulers]]
-
-[table Executors and Schedulers 
-    [[Section]  [Description]  [Status] [Comments]]
-    [[V.1.1]      [Class `executor`]  [Yes] [ - ]]
-    [[V.1.1]      [`add`]  [Yes] [ renamed with a function template `submit` ]]
-    [[V.1.1]      [`num_of_pendin_closures`]  [No] [    ]]
-    [[V.1.2]      [Class sceduled_executor]  [No] [ - ]]
-    [[V.1.2]      [`add_at`]  [No] [ renamed with a function template `scheduler::submit_at`   ]]
-    [[V.1.2]      [`add_after`]  [No] [ renamed with a function template `scheduler::submit_after`   ]]
-    [[V.2]      [Concrete executor classes]  [No] [ - ]]
-    [[V.2.1]      [`thread_pool`]  [Yes] [ static version `basic_thread_pool`, dynamic one `execduler_adaptor<basic_thread_pool>` ]]
-    [[V.2.2]      [`serial_executor`]  [yes] [ - ]]
-    [[V.2.3]      [`loop_executor`]  [Yes] [ static version loop_scheduler, dynamic one `execduler_adaptor<loop_scheduler>` ]]
-    [[V.2.4]      [`inline_executor`]  [Yes] [ static version `inline_executor`, dynamic one `execduler_adaptor<inline_executor>` ]]
-    [[V.2.5]      [`thread_executor`]  [Yes] [ static version `thread_executor`, dynamic one `execduler_adaptor<thread_executor>` ]]
-]
-
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3784.pdf N3784-Improvements to `std::future<T> and Related APIs]]
-
-[table `async, future/shared_future::then`and Executors
-    [[Section]  [Description]  [Status] [Comments]]
-    [[30.6.6]      [`future<T>::then`]  [Yes] [  ]]
-    [[30.6.7]      [`shared_future<T>::then`]  [Yes] [    ]]
-    [[30.6.8]      [`async`]  [Yes] [ - ]]
-]
-
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4143.pdf N4143-Executors and schedulers, revision 4]]
-
-[table Executors and Schedulers - revision 4
-    [[Section]  [Description]  [Status] [Comments]]
-    [[VI.A]      [Executor Concept]  [Yes] [ `wrapper_type` renamed by `work` and `spawn by `submit` ]]
-    [[VI.A.1]      [`thread_per_task_executor]  [Yes] [ renamed `thread_executor`]]
-    [[VI.A.2]      [`thread_pool_executor`]  [Yes] [ renamed `basic_thread_pool`]]
-    [[VI.A.3]      [`system_executor`]  [No] [ - ]]
-    [[VI.A.4]      [`loop_executor`]  [Yes] [ - ]]
-    [[VI.A.5]      [`serial_executor`]  [yes] [ - ]]
-    [[VI.B]      [`executor_ref`]  [yes] [ - ]]
-    [[VI.C]      [`executor`]  [yes] [ renamed `gen_executor_ref` ]]
-    [[VI.D]      [Free Functions and Helper Objects]  [partial] [ - ]]
-    [[VI.D]      [`make_package`]  [No] [ - ]]
-    [[VI.D]      [`spawn_future`]  [No] [ `async(Ex&, ...)` is similar but returns a blocking future. ]]
-    [[VI.D]      [`spawn`]  [No] [ - ]]
-    [[VI.D]      [`task_wrapper`]  [No] [ renamed `resubmitter` ]]
-    [[VI.D]      [`set_executor`]  [No] [ renamed `resubmit` ]]
-    [[VI.D]      [`function_wrapper`]  [Partial] [ renamed `work` ]]
-]
-
-[endsect]
-[//////////////////////////////////////////////////////////////
-[section:stream_mutex	C++ Stream Mutexes - C++ Stream Guards]
-[/////////////////////////////////////////////////////////////]
-
-While Boost.Thread implementation of stream mutexes differ in the approach, it is worth comparing with the current trend on the standard.
-
-[note These functions are based on [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3535.html [*N3535 - C++ Stream Mutexes]] by Lawrence Crowl.]
-
-[note This proposal has been replaced already by [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3678.html N3678 - C++ Stream Guards], which has been replaced by [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3678.html N3665 - Uninterleaved String Output Streaming] and [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3678.html N3750 - C++ Ostream Buffers]]
-
-[table C++ Stream Mutexes Conformance
-    [[Section]  [Description]  [Status] [Comments]]
-    [[X.1]      [Class template stream_mutex]  [Partial] [ Renamed externally_locked_stream<> ]]
-    [[X.2.1]      [constructor]  [Partial] [ externally_locked_stream needs a mutex in addition as argument. ]]
-    [[X.2.2]      [lock]  [yes] [ - ]]
-    [[X.2.3]      [unlock]  [yes] [ - ]]
-    [[X.2.4]      [try_lock]  [yes] [ - ]]
-    [[X.2.5]      [hold]  [Yes] [ - ]]
-    [[X.2.6]      [bypass]  [Yes] [ - ]]
-    [[X.2]      [Class template stream_guard]  [Yes] [ - ]]
-    [[X.2.1]      [stream_guard]  [Yes] [ - ]]
-    [[X.2.2]      [~stream_guard]  [Yes] [ - ]]
-    [[X.2.3]      [bypass]  [Yes] [ - ]]
-    [[X.3]      [Stream Operators]  [Yes] [-]]
-    [[X.4]      [Predefined Objects]  [No] [-]]
-]
-
-
-[endsect]
-
-///////////////////////////////]
-[endsect]
-
 [endsect]
--- a/doc/configuration.qbk
+++ b/doc/configuration.qbk
@@ -1,5 +1,5 @@
 [/
-  (C) Copyright 2012-2015 Vicente J. Botet Escriba.
+  (C) Copyright 20012 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).
@@ -11,7 +11,7 @@

 [table Default Values for Configurable Features
    [[Feature]                  [Anti-Feature]               [V2]  [V3]  [V4]  ]
-    [[USES_CHRONO]              [DONT_USE_CHRONO]            [YES/NO] [YES/NO] [YES/NO] ]
+    [[USES_CHRONO]              [DONT_USE_CHRONO]            [YES] [YES] [YES] ]
    [[PROVIDES_INTERRUPTIONS]   [DONT_PROVIDE_INTERRUPTIONS] [YES] [YES] [YES]  ]
    [[THROW_IF_PRECONDITION_NOT_SATISFIED]   [-] [NO] [NO] [NO]  ]

@@ -23,7 +23,6 @@
    [[PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN] [DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN]   [NO]  [YES] [YES] ]

    [[PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION]    [DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSION]  [NO] [YES] [YES]  ]
-    [[PROVIDES_EXECUTORS]    [-]  [NO] [NO] [NO]  ]
    [[PROVIDES_EXPLICIT_LOCK_CONVERSION]    [DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION]  [NO] [YES] [YES]  ]
    [[PROVIDES_FUTURE]    [DONT_PROVIDE_FUTURE]  [NO] [YES] [YES]  ]
    [[PROVIDES_FUTURE_CTOR_ALLOCATORS]    [DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS]  [NO] [YES] [YES]  ]
@@ -32,7 +31,7 @@
    [[PROVIDES_ONCE_CXX11]    [DONT_PROVIDE_ONCE_CXX11]  [NO] [YES] [YES]  ]
    [[USES_MOVE]                [DONT_USE_MOVE]              [NO] [YES] [YES] ]

-    [[USES_DATETIME]            [DONT_USE_DATETIME]          [YES/NO] [YES/NO] [YES/NO]  ]
+    [[USES_DATETIME]            [DONT_USE_DATETIME]          [YES] [YES] [NO]  ]
    [[PROVIDES_THREAD_EQ]       [DONT_PROVIDE_THREAD_EQ]     [YES] [YES] [NO]  ]
    [[PROVIDES_CONDITION]       [DONT_PROVIDE_CONDITION]     [YES] [YES] [NO]  ]
    [[PROVIDES_NESTED_LOCKS]    [DONT_PROVIDE_NESTED_LOCKS]  [YES] [YES] [NO]  ]
@@ -48,8 +47,6 @@

 Boost.Thread uses by default Boost.Chrono for the time related functions and define `BOOST_THREAD_USES_CHRONO` if `BOOST_THREAD_DONT_USE_CHRONO` is not defined. The user should define `BOOST_THREAD_DONT_USE_CHRONO` for compilers that don't work well with Boost.Chrono.

-[warning When defined BOOST_THREAD_PLATFORM_WIN32 BOOST_THREAD_USES_CHRONO is defined independently of user settings.]
-
 [endsect]


@@ -72,35 +69,25 @@ The Boost.DateTime time related functions introduced in Boost 1.35.0, using the
 * __timed_lock_ref__


-When `BOOST_THREAD_VERSION<=3` && defined BOOST_THREAD_PLATFORM_PTHREAD define `BOOST_THREAD_DONT_USE_DATETIME` if you don't want to use Boost.DateTime related interfaces.
-When `BOOST_THREAD_VERSION>3`  && defined BOOST_THREAD_PLATFORM_PTHREAD define `BOOST_THREAD_USES_DATETIME` if you want to use Boost.DateTime related interfaces.
-
-[warning When defined BOOST_THREAD_PLATFORM_WIN32 BOOST_THREAD_USES_DATETIME is defined independently of user settings.]
+When `BOOST_THREAD_VERSION<=3` define `BOOST_THREAD_DONT_USE_DATETIME ` if you don't want to use Boost.DateTime related interfaces.
+When `BOOST_THREAD_VERSION>3` define `BOOST_THREAD_USES_DATETIME ` if you want to use Boost.DateTime related interfaces.

 [endsect]

-[section:move  Boost.Atomic]

-Boost.Thread uses by default Boost.Atomic in POSIX platforms to implement call_once..
+[section:thread_eq `boost::thread::oprator==` deprecated]

-Define `BOOST_THREAD_USES_ATOMIC ` if you want to use Boost.Atomic.
-Define `BOOST_THREAD_DONT_USE_ATOMIC ` if you don't want to use Boost.Atomic or if it is not supported in your platform.
+The following nested typedefs are deprecated: 

-[endsect]
- 
-[section:thread_eq `boost::thread::operator==` deprecated]
-
-The following operators are deprecated: 
-
-* `boost::thread::operator==`
-* `boost::thread::operator!=`
+* `boost::thread::oprator==`
+* `boost::thread::oprator!=`

 When `BOOST_THREAD_PROVIDES_THREAD_EQ` is defined Boost.Thread provides these deprecated feature. 

 Use instead 

-* `boost::thread::id::operator==`
-* `boost::thread::id::operator!=`
+* `boost::thread::id::oprator==`
+* `boost::thread::id::oprator!=`

 [warning This is a breaking change respect to version 1.x.]

@@ -305,12 +292,8 @@ When `BOOST_THREAD_VERSION>=4` define `BOOST_THREAD_DONT_PROVIDE_SIGNATURE_PACKA

 C++11 thread constructor accep a variable number of rvalue argumentshas. When `BOOST_THREAD_PROVIDES_VARIADIC_THREAD ` is defined Boost.Thread provides this C++ feature if the following are not defined 

-* BOOST_NO_SFINAE_EXPR
 * BOOST_NO_CXX11_VARIADIC_TEMPLATES
 * BOOST_NO_CXX11_DECLTYPE
-* BOOST_NO_CXX11_DECLTYPE_N3276
-* BOOST_NO_CXX11_RVALUE_REFERENCES
-* BOOST_NO_CXX11_TRAILING_RESULT_TYPES
 * BOOST_NO_CXX11_RVALUE_REFERENCES
 * BOOST_NO_CXX11_HDR_TUPLE

@@ -360,7 +343,7 @@ The user can request the version 3 by defining `BOOST_THREAD_VERSION` to 3. In t

 * Breaking change `BOOST_THREAD_DONT_PROVIDE_PROMISE_LAZY`

-[/The default value for `BOOST_THREAD_VERSION` will be changed to 3 since Boost 1.54.]
+The default value for `BOOST_THREAD_VERSION` will be changed to 3 since Boost 1.54.

 The user can request the version 4 by defining `BOOST_THREAD_VERSION` to 4. In this case the following breaking or extending macros are defined if the opposite is not requested: 

@@ -371,7 +354,7 @@ The user can request the version 4 by defining `BOOST_THREAD_VERSION` to 4. In t
 * Breaking change `BOOST_THREAD_DONT_USE_DATETIME`


-[/The default value for `BOOST_THREAD_VERSION` will be changed to 4 since Boost 1.58.]
+The default value for `BOOST_THREAD_VERSION` will be changed to 4 since Boost 1.56.

 [endsect]

--- a/doc/emulations.qbk
+++ b/doc/emulations.qbk
@@ -260,14 +260,14 @@ Locks provide an explicit bool conversion operator when the compiler provides th

 The library provides un implicit conversion to an undefined type that can be used as a conditional expression. 

-    #if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+    #if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
        operator ``['unspecified-bool-type]``() const;
        bool operator!() const;
    #else
        explicit operator bool() const;
    #endif

-The user should use the lock.owns_lock() when an explicit conversion is required. 
+The user should use the lock.owns_lock() when a explicit conversion is required. 

 [section:bool_conversion `operator `['unspecified-bool-type]`() const`]

@@ -324,7 +324,7 @@ the library declare these types as
  }
  BOOST_SCOPED_ENUM_DECLARE_END(future_errc)

-These macros allows to use 'future_errc' in almost all the cases as a scoped enum.
+These macros allows to use 'future_errc' in almost all the cases as an scoped enum.

 There are however some limitations:

@@ -346,14 +346,14 @@ use

 And instead of

-    #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+    #ifdef BOOST_NO_SCOPED_ENUMS
    template <>
    struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc> : public true_type { };
    #endif

 use

-    #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+    #ifdef BOOST_NO_SCOPED_ENUMS
    template <>
    struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc::enum_type> : public true_type { };
    #endif
--- a/doc/external_locking.qbk
+++ b/doc/external_locking.qbk
@@ -1,5 +1,5 @@
 [/
- / Copyright (c) 2008,2012,2014 Vicente J. Botet Escriba
+ / Copyright (c) 2008,2012 Vicente J. Botet Escriba
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -8,7 +8,7 @@
 [section  External Locking -- `strict_lock` and `externally_locked` classes]


-[note This tutorial is an adaptation of the paper by Andrei Alexandrescu "Multithreading and the C++ Type System"
+[note This tutorial is an adaptation of the paper of Andrei Alexandrescu "Multithreading and the C++ Type System"
 to the Boost library.]

 [/
@@ -98,7 +98,7 @@ or inheriting from a class which add these lockable functions.
 The `basic_lockable_adapter` class helps to define the `BankAccount` class as

  class BankAccount
-  : public basic_lockable_adapter<boost::mutex>
+  : public basic_lockable_adapter<thread_mutex>
  {
      int balance_;
  public:
@@ -138,7 +138,7 @@ Notice that now acct is being locked by Withdraw after it has already been locke
 As `boost::mutex` is not recursive, we need to use its recursive version `boost::recursive_mutex`.

  class BankAccount
-  : public basic_lockable_adapter<boost::recursive_mutex>
+  : public basic_lockable_adapter<recursive_mutex>
  {
  
      // ...
@@ -147,7 +147,7 @@ As `boost::mutex` is not recursive, we need to use its recursive version `boost:
 The caller-ensured locking approach is more flexible and the most efficient, but very dangerous. In an implementation using caller-ensured locking, BankAccount still holds a mutex, but its member functions don't manipulate it at all. Deposit and Withdraw are not thread-safe anymore. Instead, the client code is responsible for locking BankAccount properly.

    class BankAccount
-        : public basic_lockable_adapter<boost::mutex> {
+        : public basic_lockable_adapter<boost:mutex> {
        int balance_;
    public:
        void Deposit(int amount) {
@@ -163,7 +163,7 @@ Obviously, the caller-ensured locking approach has a safety problem. BankAccount
 To conclude, if in designing a multi-threaded class you settle on internal locking, you expose yourself to inefficiency or deadlocks. On the other hand, if you rely on caller-provided locking, you make your class error-prone and difficult to use. Finally, external locking completely avoids the issue by leaving it all to the client code.
 [endsect]
 ]
-[section  Locks as permits]
+[section  Locks as Permits]

 So what to do? Ideally, the BankAccount class should do the following:

@@ -182,12 +182,10 @@ For now, let's make a couple of enhancements to the `lock_guard` class template
 We'll call the enhanced version `strict_lock`. Essentially, a `strict_lock`'s role is only to live on the stack as an automatic variable. 
 `strict_lock` must adhere to a non-copy and non-alias policy. 
 `strict_lock` disables copying by making the copy constructor and the assignment operator private. 
-[/
-While we're at it, let's disable operator new and operator delete. 
-
+While we're at it, let's disable operator new and operator delete; 
 `strict_lock` are not intended to be allocated on the heap. 
 `strict_lock` avoids aliasing by using a slightly less orthodox and less well-known technique: disable address taking.
-]
+

    template <typename Lockable>
    class strict_lock  {
@@ -217,7 +215,7 @@ Silence can be sometimes louder than words-what's forbidden to do with a `strict
 * You can create a `strict_lock<T>` only starting from a valid T object. Notice that there is no other way you can create a `strict_lock<T>`.

    BankAccount myAccount("John Doe", "123-45-6789");
-    strict_lock<BankAccount> myLock(myAccount); // ok
+    strict_locerk<BankAccount> myLock(myAccount); // ok

 * You cannot copy `strict_lock`s to one another. In particular, you cannot pass `strict_lock`s by value to functions or have them returned by functions:

@@ -231,7 +229,6 @@ Silence can be sometimes louder than words-what's forbidden to do with a `strict
    // ok, Bar takes a reference to strict_lock<BankAccount>
    extern void Bar(strict_lock<BankAccount>&);

-[/
 * You cannot allocate a `strict_lock` on the heap. However, you still can put `strict_lock`s on the heap if they're members of a class.

    strict_lock<BankAccount>* pL =
@@ -253,9 +250,8 @@ Silence can be sometimes louder than words-what's forbidden to do with a `strict
    strict_lock<BankAccount>& rAlias = myLock; // ok

 Fortunately, references don't engender as bad aliasing as pointers because they're much less versatile (references cannot be copied or reseated).
-]
-[/* You can even make `strict_lock` final; that is, impossible to derive from. This task is left in the form of an exercise to the reader.
-]
+
+* You can even make `strict_lock` final; that is, impossible to derive from. This task is left in the form of an exercise to the reader.

 All these rules were put in place with one purpose-enforcing that owning a `strict_lock<T>` is a reasonably strong guarantee that

@@ -271,7 +267,7 @@ Now that we have such a strict `strict_lock`, how do we harness its power in def
 A little code is worth 1,000 words, a (hacked into) saying goes, so here's the new BankAccount class:

    class BankAccount
-    : public basic_lockable_adapter<boost::mutex>
+    : public basic_lockable_adapter<boost:recursive_mutex>
    {
        int balance_;
    public:
@@ -280,7 +276,7 @@ A little code is worth 1,000 words, a (hacked into) saying goes, so here's the n
            balance_ += amount;
        }
        void Deposit(int amount) {
-            strict_lock<BankAccount> guard(*this); // Internally locked
+            strict_lock<boost:mutex> guard(*this); // Internally locked
            Deposit(amount, guard);
        }
        void Withdraw(int amount, strict_lock<BankAccount>&) {
@@ -288,12 +284,12 @@ A little code is worth 1,000 words, a (hacked into) saying goes, so here's the n
            balance_ -= amount;
        }
        void Withdraw(int amount) {
-            strict_lock<BankAccount> guard(*this); // Internally locked
+            strict_lock<boost:mutex> guard(*this); // Internally locked
            Withdraw(amount, guard);
        }
    };

-Now, if you want the benefit of internal locking, you simply call `Deposit(int)` and `Withdraw(int)`. If you want to use external locking, you lock the object by constructing a `strict_lock<BankAccount>` and then you call `Deposit(int, strict_lock<BankAccount>&)` and `Withdraw(int, strict_lock<BankAccount>&)`. For example, here's the `ATMWithdrawal` function implemented correctly:
+Now, if you want the benefit of internal locking, you simply call Deposit(int) and Withdraw(int). If you want to use external locking, you lock the object by constructing a `strict_lock<BankAccount>` and then you call `Deposit(int, strict_lock<BankAccount>&)` and `Withdraw(int, strict_lock<BankAccount>&)`. For example, here's the `ATMWithdrawal` function implemented correctly:

    void ATMWithdrawal(BankAccount& acct, int sum) {
        strict_lock<BankAccount> guard(acct);
@@ -327,7 +323,7 @@ The scheme is useful because the likelihood of a programmer forgetting about any
 Using `strict_lock` permits compile-time checking of the most common source of errors, and runtime checking of the less frequent problem.

 Let's see how to enforce that the appropriate BankAccount object is locked. First, we need to add a member function to the `strict_lock` class template. 
-The `bool strict_lock<T>::owns_lock(Lockable*)` function returns a reference to the locked object.
+The `bool strict_lock<T>::owns_lock(Loclable*)` function returns a reference to the locked object.

    template <class Lockable> class strict_lock {
        ... as before ...
@@ -338,7 +334,7 @@ The `bool strict_lock<T>::owns_lock(Lockable*)` function returns a reference to
 Second, BankAccount needs to use this function compare the locked object against this:

    class BankAccount {
-    : public basic_lockable_adapter<boost::mutex>
+    : public basic_lockable_adapter<boost::recursive_mutex>
        int balance_;
    public:
        void Deposit(int amount, strict_lock<BankAccount>& guard) {
@@ -402,8 +398,8 @@ The solution is to use a little bridge template `externally_locked` that control
  
      T& get(strict_lock<Lockable>& lock) {
  
-  #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
-          if (!lock.owns_lock(&lockable_)) throw lock_error(); //run time check throw if not locks the same
+  #ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME  // define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME if you don't want to check locker check the same lockable
+          if (!lock.is_locking(&lockable_)) throw lock_error(); run time check throw if not locks the same
  #endif
          return obj_;
      }
@@ -421,10 +417,10 @@ The solution is to use a little bridge template `externally_locked` that control
 Instead of making `checkingAcct_` and `savingsAcct_` of type `BankAccount`, `AccountManager` holds objects of type `externally_locked<BankAccount, AccountManager>`:

  class AccountManager
-      : public basic_lockable_adapter<boost::mutex>
+      : public basic_lockable_adapter<thread_mutex>
  {
  public:
-      typedef basic_lockable_adapter<boost::mutex> lockable_base_type;
+      typedef basic_lockable_adapter<thread_mutex> lockable_base_type;
      AccountManager()
          : checkingAcct_(*this)
          , savingsAcct_(*this)
@@ -453,7 +449,7 @@ We achieved two important goals. First, the declaration of `checkingAcct_` and `

 [section  Allowing other strict locks]

-Now imagine that the AccountManager function needs to take a `unique_lock` in order to reduce the critical regions. And at some time it needs to access to the `checkingAcct_`. As `unique_lock` is not a strict lock the following code doesn't compile:
+Now imagine that the AccountManager function needs to take a `unique_lock` in order to reduce the critical regions. And at some time it needs to access to the `checkingAcct_`. As `unique_lock` is not a strict lock the following code doesn't compiles:

  void AccountManager::AMoreComplicatedChecking2Savings(int amount) {
      unique_lock<AccountManager> guard(*this, defer_lock);
@@ -465,10 +461,10 @@ Now imagine that the AccountManager function needs to take a `unique_lock` in or
      do_something_else();
  }

-We need a way to transfer the ownership from the `unique_lock` to a `strict_lock` during the time we are working with `savingsAcct_` and then restore the ownership on `unique_lock`.
+We need a way to transfer the ownership from the `unique_lock` to a `strict_lock` the time we are working with `savingsAcct_` and then restore the ownership on `unique_lock`.

  void AccountManager::AMoreComplicatedChecking2Savings(int amount) {
-      unique_lock<AccountManager> guard1(*this, defer_lock);
+      unique_lock<AccountManager> guard(*this, defer_lock);
      if (some_condition()) {
          guard1.lock();
      }
@@ -480,9 +476,9 @@ We need a way to transfer the ownership from the `unique_lock` to a `strict_lock
      guard1.unlock();
  }

-In order to make this code compilable we need to store either a Lockable or a `unique_lock<Lockable>` reference depending on the constructor. We also need to store which kind of reference we have stored, and in the destructor call either to the Lockable `unlock` or restore the ownership.
+In order to make this code compilable we need to store either a Lockable or a `unique_lock<Lockable>` reference depending on the constructor. Store which kind of reference we have stored,and in the destructor call either to the Lockable `unlock` or restore the ownership.

-This seems too complicated to me. Another possibility is to define a nested strict lock class. The drawback is that instead of having only one strict lock we have two and we need either to duplicate every function taking a `strict_lock` or make these function templates. The problem with template functions is that we don't profit anymore of the C++ type system. We must add some static metafunction that checks that the Locker parameter is a strict lock. The problem is that we can not really check this or can we?. The `is_strict_lock` metafunction must be specialized by the strict lock developer. We need to believe it "sur parole". The advantage is that now we can manage with more than two strict locks without changing our code. This is really nice.
+This seams too complicated to me. Another possibility is to define a nested strict lock class. The drawback is that instead of having only one strict lock we have two and we need either to duplicate every function taking a `strict\_lock` or make these function templates functions. The problem with template functions is that we don't profit anymore of the C++ type system. We must add some static metafunction that check that the Locker parameter is a strict lock. The problem is that we can not really check this or can we?. The `is_strict_lock` metafunction must be specialized by the strict lock developer. We need to belive it "sur parolle". The advantage is that now we can manage with more than two strict locks without changing our code. Ths is really nice.

 Now we need to state that both classes are `strict_lock`s.

@@ -496,9 +492,9 @@ Now we need to state that both classes are `strict_lock`s.
    struct is_strict_lock<nested_strict_lock<Locker> > : mpl::true_ {}


-Well let me show what this `nested_strict_lock` class looks like and the impacts on the `externally_locked` class and the `AccountManager::AMoreComplicatedFunction` function.
+Well let me show how this `nested_strict_lock` class looks like and the impacts on the `externally_locked` class and the `AccountManager::AMoreComplicatedFunction` function.

-First `nested_strict_lock` class will store on a temporary lock the `Locker`, and transfer the lock ownership on the constructor. On destruction it will restore the ownership. Note the use of `lock_traits` and that the `Locker` needs to have a reference to the mutex otherwise an exception is thrown.
+First `nested_strict_lock` class will store on a temporary lock the `Locker`, and transfer the lock ownership on the constructor. On destruction he will restore the ownership. Note also that the Locker needs to have already a reference to the mutex otherwise an exception is thrown and the use of the `lock_traits`.

  template <typename Locker >
  class nested_strict_lock
@@ -510,9 +506,9 @@ First `nested_strict_lock` class will store on a temporary lock the `Locker`, an
  
      nested_strict_lock(Locker& lock)
          : lock_(lock)  // Store reference to locker
-          , tmp_lock_(lock.move()) // Move ownership to temporary locker 
+          , tmp_lock_(lock.move()) // Move ownership to temporaty locker 
      {
-          #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
+          #ifndef BOOST_THREAD_STRCIT_LOCKER_DONT_CHECK_OWNERSHIP  // Define BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_OWNERSHIP if you don't want to check locker ownership
          if (tmp_lock_.mutex()==0) {
              lock_=tmp_lock_.move(); // Rollback for coherency purposes 
              throw lock_error();
@@ -523,29 +519,24 @@ First `nested_strict_lock` class will store on a temporary lock the `Locker`, an
      ~nested_strict_lock() {
          lock_=tmp_lock_.move(); // Move ownership to nesting locker 
      }
+      typedef bool (nested_strict_lock::*bool_type)() const;
+      operator bool_type() const { return &nested_strict_lock::owns_lock; }
+      bool operator!() const { return false; }
      bool owns_lock() const { return true; }
-      lockable_type* mutex() const { return tmp_lock_.mutex(); }
-      bool owns_lock(lockable_type* l) const { return l==mutex(); }
+      const lockable_type* mutex() const { return tmp_lock_.mutex(); }
+      bool is_locking(lockable_type* l) const { return l==mutex(); }
  
+      BOOST_ADRESS_OF_DELETE(nested_strict_lock)
+      BOOST_HEAP_ALLOCATEION_DELETE(nested_strict_lock)
+      BOOST_DEFAULT_CONSTRUCTOR_DELETE(nested_strict_lock) 8
+      BOOST_COPY_CONSTRUCTOR_DELETE(nested_strict_lock) 9
+      BOOST_COPY_ASSIGNEMENT_DELETE(nested_strict_lock) 10
  
  private:
      Locker& lock_;
      Locker tmp_lock_;
  };

-[/
-      typedef bool (nested_strict_lock::*bool_type)() const;
-      operator bool_type() const { return &nested_strict_lock::owns_lock; }
-      bool operator!() const { return false; }
-      
-      BOOST_ADRESS_OF_DELETE(nested_strict_lock)
-      BOOST_HEAP_ALLOCATEION_DELETE(nested_strict_lock)
-      BOOST_DEFAULT_CONSTRUCTOR_DELETE(nested_strict_lock)
-      BOOST_COPY_CONSTRUCTOR_DELETE(nested_strict_lock)
-      BOOST_COPY_ASSIGNEMENT_DELETE(nested_strict_lock)
-      
-]
-
 The `externally_locked` get function is now a template function taking a Locker as parameters instead of a `strict_lock`. 
 We can add test in debug mode that ensure that the Lockable object is locked.

@@ -557,14 +548,14 @@ We can add test in debug mode that ensure that the Lockable object is locked.
      T& get(Locker& lock) {
          BOOST_CONCEPT_ASSERT((StrictLockerConcept<Locker>));
  
-          BOOST_STATIC_ASSERT((is_strict_lock<Locker>::value)); // locker is a strict locker "sur parole" 
+          BOOST_STATIC_ASSERT((is_strict_lock<Locker>::value)); // locker is a strict locker "sur parolle" 
          BOOST_STATIC_ASSERT((is_same<Lockable,
                  typename lockable_type<Locker>::type>::value)); // that locks the same type 
  #ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_OWNERSHIP  // define BOOST_THREAD_EXTERNALLY_LOCKED_NO_CHECK_OWNERSHIP if you don't want to check locker ownership
          if (! lock ) throw lock_error(); // run time check throw if no locked 
  #endif
-  #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
-          if (!lock.owns_lock(&lockable_)) throw lock_error();
+  #ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME
+          if (!lock.is_locking(&lockable_)) throw lock_error();
  #endif
          return obj_;
      }
--- a/doc/future_ref.qbk
+++ b/doc/future_ref.qbk
--- a/doc/futures.qbk
+++ b/doc/futures.qbk
@@ -1,6 +1,5 @@
 [/
  (C) Copyright 2008-11 Anthony Williams.
-  (C) Copyright 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).
@@ -94,7 +93,7 @@ the result is ready, it is returned from __unique_future_get__ by rvalue-referen
 appropriate for the type.

 On the other hand, many instances of __shared_future__ may reference the same result. Instances can be freely copied and assigned,
-and __shared_future_get__ returns a `const` reference so that multiple calls to __shared_future_get__ are safe. You can move an
+and __shared_future_get__ returns a non `const` reference so that multiple calls to __shared_future_get__ are safe. You can move an
 instance of __unique_future__ into an instance of __shared_future__, thus transferring ownership of the associated asynchronous
 result, but not vice-versa.

@@ -294,7 +293,7 @@ that is to allow multiple concurrent get operations.

 [heading Multiple get]

-The second `get()` call in the following example is undefined.  
+The second `get()` call in the following example future  

  void bad_second_use( type arg ) {
      
@@ -309,7 +308,7 @@ The second `get()` call in the following example is undefined.
      use3( ftr.get() ); // second use is undefined
  }
    
-Using a `shared_future` solves the issue
+Using a `shared_mutex` solves the issue

  void good_second_use( type arg ) {
      
@@ -326,7 +325,7 @@ Using a `shared_future` solves the issue

 [heading share()]
  
-Naming the return type when declaring the `shared_future` is needed; auto is not available within template argument lists. 
+Namming the return type when declaring the `shared_future` is needed; auto is not available within template argument lists. 
 Here `share()` could be used to simplify the code

  void better_second_use( type arg ) {
@@ -342,9 +341,9 @@ Here `share()` could be used to simplify the code
      use3( ftr.get() ); // second use is defined
  }
 
-[heading Writing on get()]
+[heading Writting on get()]

-The user can either read or write the future variable. 
+The user can either read or write the future avariable. 

  void write_to_get( type arg ) {
      
@@ -365,22 +364,22 @@ The user can either read or write the future variable.
 This works because the `shared_future<>::get()` function returns a non-const reference to the appropriate storage.
 Of course the access to this storage must be ensured by the user. The library doesn't ensure the access to the internal storage is thread safe.

-There has been some work by the C++ standard committee on an `atomic_future` that behaves as an `atomic` variable, that is thread_safe, 
+There has been some work by the C++ standard committe on an `atomic_future` that behaves as an `atomic` variable, that is is thread_safe, 
 and a `shared_future` that can be shared between several threads, but there were not enough consensus and time to get it ready for C++11.       

 [endsect]

-[section:make_ready_future Making immediate futures easier]
+[section:make_future Making immediate futures easier]

 Some functions may know the value at the point of construction. In these cases the value is immediately available, 
-but needs to be returned as a future or shared_future. By using make_ready_future a future  
+but needs to be returned as a future or shared_future. By using make_future (make_shared_future) a future (shared_future) 
 can be created which holds a pre-computed result in its shared state.
 
 Without these features it is non-trivial to create a future directly from a value. 
 First a promise must be created, then the promise is set, and lastly the future is retrieved from the promise. 
 This can now be done with one operation.

-[heading make_ready_future]
+[heading make_future / make_shared_future]

 This function creates a future for a given value. If no value is given then a future<void> is returned. 
 This function is primarily useful in cases where sometimes, the return value is immediately available, but sometimes 
@@ -390,14 +389,16 @@ the function must return an eventual value represented as a future.

  boost::future<int> compute(int x)
  {
-    if (x == 0) return boost::make_ready_future(0);
-    if (x < 0) return boost::make_ready_future<int>(std::logic_error("Error"));
+    if (x == 0) return boost::make_future(0);
+    if (x < 0) return boost::make_future(-1);
    boost::future<int> f1 = boost::async([]() { return x+1; });
    return f1;
  }
  
 There are two variations of this function. The first takes a value of any type, and returns a future of that type. 
-The input value is passed to the shared state of the returned future. The second version takes no input and returns a future<void>. 
+The input value is passed to the shared state of the returned future. The second version takes no input and returns a future<void>.
+make_shared_future has the same functionality as make_future, except has a return type of shared_future.
+  

 [endsect]

@@ -405,16 +406,16 @@ The input value is passed to the shared state of the returned future. The second

 In asynchronous programming, it is very common for one asynchronous operation, on completion, to invoke a second 
 operation and pass data to it. The current C++ standard does not allow one to register a continuation to a future. 
-With `.then`, instead of waiting for the result, a continuation is "attached" to the asynchronous operation, which is 
-invoked when the result is ready. Continuations registered using the `.then` function will help to avoid blocking waits 
+With .then, instead of waiting for the result, a continuation is "attached" to the asynchronous operation, which is 
+invoked when the result is ready. Continuations registered using the .then function will help to avoid blocking waits 
 or wasting threads on polling, greatly improving the responsiveness and scalability of an application.

-`future.then()` provides the ability to sequentially compose two futures by declaring one to be the continuation of another. 
-With `.then()` the antecedent future is ready (has a value or exception stored in the shared state) before the continuation 
+future.then provides the ability to sequentially compose two futures by declaring one to be the continuation of another. 
+With .then the antecedent future is ready (has a value or exception stored in the shared state) before the continuation 
 starts as instructed by the lambda function.

-In the example below the `future<string>` `f2` is registered to be a continuation of `future<int>` `f1` using the `.then()` member 
-function. This operation takes a lambda function which describes how `f2` should proceed after `f1` is ready.
+In the example below the future<int> f2 is registered to be a continuation of future<int> f1 using the .then member 
+function. This operation takes a lambda function which describes how f2 should proceed after f1 is ready.


  #include <boost/thread/future.hpp>
@@ -427,7 +428,7 @@ function. This operation takes a lambda function which describes how `f2` should

 One key feature of this function is the ability to chain multiple asynchronous operations. In asynchronous programming, 
 it's common to define a sequence of operations, in which each continuation executes only when the previous one completes. 
-In some cases, the antecedent future produces a value that the continuation accepts as input. By using `future.then()`, 
+In some cases, the antecedent future produces a value that the continuation accepts as input. By using future.then, 
 creating a chain of continuations becomes straightforward and intuitive: 

  myFuture.then(...).then(...).then(...). 
@@ -440,20 +441,21 @@ Some points to note are:

 Input Parameters:

-* Lambda function: One option which can be considered is to take two functions, one for 
-success and one for error handling. However this option has not been retained for the moment. 
-The lambda function takes a future as its input which carries the exception 
+* Lambda function2: One option which was considered was to follow JavaScript's approach and take two functions, one for 
+success and one for error handling. However this option is not viable in C++ as there is no single base type for 
+exceptions as there is in JavaScript. The lambda function takes a future as its input which carries the exception 
 through. This makes propagating exceptions straightforward. This approach also simplifies the chaining of continuations.
-* Executor: Providing an overload to `.then`, to take an executor reference places great flexibility over the execution 
+* Scheduler: Providing an overload to .then, to take a scheduler reference places great flexibility over the execution 
 of the future in the programmer's hand. As described above, often taking a launch policy is not sufficient for powerful 
-asynchronous operations. The lifetime of the executor must outlive the continuation.
-* Launch policy: if the additional flexibility that the executor provides is not required.
+asynchronous operations. The lifetime of the scheduler must outlive the continuation.
+* Launch policy: if the additional flexibility that the scheduler provides is not required.
+

 Return values: The decision to return a future was based primarily on the ability to chain multiple continuations using
-`.then()`. This benefit of composability gives the programmer incredible control and flexibility over their code. Returning 
-a `future` object rather than a `shared_future` is also a much cheaper operation thereby improving performance. A 
-`shared_future` object is not necessary to take advantage of the chaining feature. It is also easy to go from a `future` 
-to a `shared_future` when needed using future::share().
+.then. This benefit of composability gives the programmer incredible control and flexibility over their code. Returning 
+a future object rather than a shared_future is also a much cheaper operation thereby improving performance. A 
+shared_future object is not necessary to take advantage of the chaining feature. It is also easy to go from a future 
+to a shared_future when needed using future::share().


 [endsect]
--- a/doc/internal_locking.qbk
+++ b/doc/internal_locking.qbk
@@ -1,5 +1,5 @@
 [/
- / Copyright (c) 2008,2014 Vicente J. Botet Escriba
+ / Copyright (c) 2008 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)
@@ -14,7 +14,7 @@ Consider, for example, modeling a bank account class that supports simultaneous

 From here a component is a model of the `Callable` concept.

-I C++11 (Boost) concurrent execution of a component is obtained by means of the `std::thread`(`boost::thread`):
+On C++11 (Boost) concurrent execution of a component is obtained by means of the `std::thread`(`boost::thread`):

    boost::thread thread1(S);

@@ -53,12 +53,9 @@ The following example includes a bank account of a person (Joe) and two componen
      return 0;
  }

-From time to time, the `bankAgent` will deposit $500 in `JoesAccount`. `Joe` will similarly withdraw $100 from his account. These sentences describe that the `bankAgent` and `Joe` are executed concurrently.
+From time to time, the `bankAgent` will deposit $500 in `JoesAccount`. Joe will similarly withdraw $100 from his account. These sentences describe that the bankAgent and Joe are executed concurrently.

-[endsect]
-[section  Internal locking]
-
-The above example works well as long as the components `bankAgent` and `Joe` doesn't access `JoesAccount` at the same time. There is, however, no guarantee that this will not happen. We may use a mutex to guarantee exclusive access to each bank.
+The above example works well as long as the bankAgent and Joe doesn't access JoesAccount at the same time. There is, however, no guarantee that this will not happen. We may use a mutex to guarantee exclusive access to each bank.

  class BankAccount {
      boost::mutex mtx_;
@@ -78,15 +75,15 @@ The above example works well as long as the components `bankAgent` and `Joe` doe
          mtx_.lock();
          int b = balance_;
          mtx_.unlock();
-          return b;
+          return balance_;
      }
  };

-Execution of the `Deposit` and `Withdraw` operations will no longer be able to make simultaneous access to balance.
+Execution of the Deposit and Withdraw operations will no longer be able to make simultaneous access to balance.

-A mutex is a simple and basic mechanism for obtaining synchronization. In the above example it is relatively easy to be convinced that the synchronization works correctly (in the absence of exception). In a system with several concurrent objects and several shared objects, it may be difficult to describe synchronization by means of mutexes. Programs that make heavy use of mutexes may be difficult to read and write. Instead, we shall introduce a number of generic classes for handling more complicated forms of synchronization and communication.
+Mutex is a simple and basic mechanism for obtaining synchronization. In the above example it is relatively easy to be convinced that the synchronization works correctly (in the absence of exception). In a system with several concurrent objects and several shared objects, it may be difficult to describe synchronization by means of mutexes. Programs that make heavy use of mutexes may be difficult to read and write. Instead, we shall introduce a number of generic classes for handling more complicated forms of synchronization and communication.

-With the RAII idiom we can simplify a lot this using the scoped locks. In the code below, guard's constructor locks the passed-in object `mtx_`, and guard's destructor unlocks `mtx_`.
+With the RAII idiom we can simplify a lot this using the scoped locks. In the code below, guard's constructor locks the passed-in object this, and guard's destructor unlocks this.

  class BankAccount {
      boost::mutex mtx_; // explicit mutex declaration 
@@ -108,9 +105,6 @@ With the RAII idiom we can simplify a lot this using the scoped locks. In the co

 The object-level locking idiom doesn't cover the entire richness of a threading model. For example, the model above is quite deadlock-prone when you try to coordinate multi-object transactions. Nonetheless, object-level locking is useful in many cases, and in combination with other mechanisms can provide a satisfactory solution to many threaded access problems in object-oriented programs.

-[endsect]
-[section  Internal and external locking]
-
 The BankAccount class above uses internal locking. Basically, a class that uses internal locking guarantees that any concurrent calls to its public member functions don't corrupt an instance of that class. This is typically ensured by having each public member function acquire a lock on the object upon entry. This way, for any given object of that class, there can be only one member function call active at any moment, so the operations are nicely serialized.

 This approach is reasonably easy to implement and has an attractive simplicity. Unfortunately, "simple" might sometimes morph into "simplistic."
@@ -135,10 +129,10 @@ In an attempt to solve this problem, let's lock the account from the outside dur
      acct.Withdraw(2);
  }

-Notice that the code above doesn't compile, the `mtx_` field is private.
+Notice that the code above doesn't compiles, the `mtx_` field is private.
 We have two possibilities:

-* make `mtx_` public which seems odd
+* make `mtx_` public which seams odd
 * make the `BankAccount` lockable by adding the lock/unlock functions

 We can add these functions explicitly
@@ -209,24 +203,6 @@ As `boost::mutex` is not recursive, we need to use its recursive version `boost:
      // ...
  };

-The caller-ensured locking approach is more flexible and the most efficient, but very dangerous. In an implementation using caller-ensured locking, BankAccount still holds a mutex, but its member functions don't manipulate it at all. Deposit and Withdraw are not thread-safe anymore. Instead, the client code is responsible for locking BankAccount properly.
-
-    class BankAccount
-        : public basic_lockable_adapter<boost:mutex> {
-        int balance_;
-    public:
-        void Deposit(int amount) {
-            balance_ += amount;
-        }
-        void Withdraw(int amount) {
-            balance_ -= amount;
-        }
-    };
-
-Obviously, the caller-ensured locking approach has a safety problem. BankAccount's implementation code is finite, and easy to reach and maintain, but there's an unbounded amount of client code that manipulates BankAccount objects. In designing applications, it's important to differentiate between requirements imposed on bounded code and unbounded code. If your class makes undue requirements on unbounded code, that's usually a sign that encapsulation is out the window.
-
-To conclude, if in designing a multi-threaded class you settle on internal locking, you expose yourself to inefficiency or deadlocks. On the other hand, if you rely on caller-provided locking, you make your class error-prone and difficult to use. Finally, external locking completely avoids the issue by leaving it all to the client code.
-

 [endsect]

@@ -240,9 +216,9 @@ The following class describes a so-called monitor pattern.
  template <
      typename Lockable=mutex
  >
-  class basic_monitor : protected basic_lockable_adapter<Lockable> { // behaves like a BasicLockable for the derived classes 
+  class basic_monitor : protected basic_lockable_adapter<Lockable> { // behaves like an BasicLockable for the derived classes 
  protected:
-      typedef unspecified synchronizer; // is a strict lock guard 
+      typedef unspecified synchronizer; // is an strict lock guard 
  };

 [/shared_monitor]
@@ -464,6 +440,11 @@ Monitors and conditions are useful for describing simple cases of shared objects
 [endsect] [/Monitors]
 ]

+[section Synchronized variables]
+[/include synchronized_value.qbk]
+[endsect] [/Synchronized variables]
+
+
 [endsect] [/Internal Locking]


--- a/doc/latch.qbk
+++ b/doc/latch.qbk
@@ -1,419 +0,0 @@
-[/
-  (C) Copyright 2013 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).
-]
-
-[section:latches Latches -- EXPERIMENTAL]
-
-[////////////////////]
-[section Introdcution]
-
-Latches are a thread co-ordination mechanism that allow one or more threads to block until one or more threads have reached a point. 
-
-[/
-An individual latch is a reusable object; once the operation has been completed, the threads can re-use the same barrier. It is thus useful for managing repeated tasks handled by multiple threads.
-
-A completion latch is like a latch that allows to associate a completion function which will be called once the internal counter reaches the value 0 and all the consumer threads have taken care of the notification. 
-]
-
-[endsect]
-[////////////////]
-[section Examples]
-
-Sample use cases for the latch include:
-
-* Setting multiple threads to perform a task, and then waiting until all threads have reached a common point.
-* Creating multiple threads, which wait for a signal before advancing beyond a common point.
-
-An example of the first use case would be as follows:
-
-  void DoWork(thread_pool* pool) {
-    latch completion_latch(NTASKS);
-    for (int i = 0; i < NTASKS; ++i) {
-      pool->submit([&] {
-        // perform work
-        ...
-        completion_latch.count_down();
-      }));
-    }
-    // Block until work is done
-    completion_latch.wait();
-  }
-
-An example of the second use case is shown below. We need to load data and then process it using a number of threads. Loading the data is I/O bound, whereas starting threads and creating data structures is CPU bound. By running these in parallel, throughput can be increased.
-
-  void DoWork() {
-    latch start_latch(1);
-    vector<thread*> workers;
-    for (int i = 0; i < NTHREADS; ++i) {
-      workers.push_back(new thread([&] {
-        // Initialize data structures. This is CPU bound.
-        ...
-        start_latch.wait();
-        // perform work
-        ...
-      }));
-    }
-    // Load input data. This is I/O bound.
-    ...
-    // Threads can now start processing
-    start_latch.count_down();
-    }
-
-[/
-The completion latches can be used to co-ordinate also a set of threads carrying out a repeated task. The number of threads can be adjusted dynamically to respond to changing requirements.
-
-In the example below, a number of threads are performing a multi-stage task. Some tasks may require fewer steps than others, meaning that some threads may finish before others. We reduce the number of threads waiting on the latch when this happens.
-
-  void DoWork() {
-    Tasks& tasks;
-    size_t initial_threads;
-    atomic<size_t> current_threads(initial_threads)
-    vector<thread*> workers;
-
-    // Create a barrier, and set a lambda that will be invoked every time the
-    // barrier counts down. If one or more active threads have completed,
-    // reduce the number of threads.
-    completion_latch task_barrier(n_threads);
-    task_barrier.then([&] {
-      task_barrier.reset(current_threads);
-    });
-
-    for (int i = 0; i < n_threads; ++i) {
-        workers.push_back(new thread([&] {
-        bool active = true;
-        while(active) {
-          Task task = tasks.get();
-          // perform task
-          ...
-          if (finished(task)) {
-            current_threads--;
-            active = false;
-          }
-          task_barrier.count_down_and_wait();
-         }
-       });
-    }
-
-    // Read each stage of the task until all stages are complete.
-    while (!finished()) {
-      GetNextStage(tasks);
-    }
-  }
-]
-
-[endsect]
-[///////////////////////////]
-[section:latch Class `latch`]
-
-    #include <boost/thread/latch.hpp>
-
-    class latch
-    {
-    public:
-        latch(latch const&) = delete;
-        latch& operator=(latch const&) = delete;
-
-        latch(std::size_t count);
-        ~latch();
-
-        void wait();
-        bool try_wait();
-        template <class Rep, class Period>
-        cv_status wait_for(const chrono::duration<Rep, Period>& rel_time);
-        template <class lock_type, class Clock, class Duration>
-        cv_status wait_until(const chrono::time_point<Clock, Duration>& abs_time);
-        void count_down();
-        void count_down_and_wait();
-
-    };
-
-
-[/
-        void reset(std::size_t count);
-]
-
-A latch maintains an internal counter that is initialized when the latch is created. One or more threads may block waiting until the counter is decremented to 0. 
-
-Instances of __latch__ are not copyable or movable.
-
-[///////////////////]
-[section Constructor `latch(std::size_t)`]
-
-    latch(std::size_t count);
-
-[variablelist
-
-[[Effects:] [Construct a latch with is initial value for the internal counter.]]
-
-[[Note:] [The counter could be zero.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[//////////////////]
-[section Destructor `~latch()`]
-
-    ~latch();
-
-[variablelist
-
-[[Precondition:] [No threads are waiting or invoking  count_down on `*this`.]]
-
-[[Effects:] [Destroys `*this` latch.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[/////////////////////////////////////]
-[section:wait Member Function `wait()`]
-
-    void wait();
-
-[variablelist
-
-[[Effects:] [Block the calling thread until the internal count reaches the value zero. Then all waiting threads
-are unblocked. ]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-
- - __thread_interrupted__ if the wait was interrupted by a call to __interrupt__ on the __thread__ object associated with the current thread of execution.
-]]
-
-[[Notes:] [`wait()` is an ['interruption point].]]
-
-]
-
-[endsect]
-[/////////////////////////////////////////////]
-[section:try_wait Member Function `try_wait()`]
-
-        bool try_wait();
-
-[variablelist
-
-[[Returns:] [Returns true if the internal count is 0, and false otherwise. Does not block the calling thread. ]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-]]
-
-]
-
-[endsect]
-[//////////////////////////////////////////////]
-[section:wait_for Member Function `wait_for() `]
-
-        template <class Rep, class Period>
-        cv_status wait_for(const chrono::duration<Rep, Period>& rel_time);
-
-[variablelist
-
-[[Effects:] [Block the calling thread until the internal count reaches the value zero or the duration has been elapsed. If no timeout, all waiting threads are unblocked. ]]
-[[Returns:] [cv_status::no_timeout  if the internal count is 0, and cv_status::timeout if duration has been elapsed. ]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-
- - __thread_interrupted__ if the wait was interrupted by a call to __interrupt__ on the __thread__ object associated with the current thread of execution.
-]]
-
-[[Notes:] [`wait_for()` is an ['interruption point].]]
-
-]
-
-[endsect]
-[/////////////////////////////////////////////////]
-[section:wait_until Member Function `wait_until()`]
-
-        template <class lock_type, class Clock, class Duration>
-        cv_status wait_until(const chrono::time_point<Clock, Duration>& abs_time);
-
-[variablelist
-
-[[Effects:] [Block the calling thread until the internal count reaches the value zero or the time_point has been reached. If no timeout, all waiting threads are unblocked. ]]
-[[Returns:] [cv_status::no_timeout  if the internal count is 0, and cv_status::timeout if time_point has been reached.]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-
- - __thread_interrupted__ if the wait was interrupted by a call to __interrupt__ on the __thread__ object associated with the current thread of execution.
-]]
-
-[[Notes:] [`wait_until()` is an ['interruption point].]]
-
-]
-
-[endsect]
-[/////////////////////////////////////////////////]
-[section:count_down Member Function `count_down()`]
-
-        void count_down();
-
-[variablelist
-
-[[Requires:] [The internal counter is non zero.]]
-[[Effects:] [Decrements the internal count by 1, and returns. If the count reaches 0, any threads blocked in wait() will be released. ]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-
- - __thread_interrupted__ if the wait was interrupted by a call to __interrupt__ on the __thread__ object associated with the current thread of execution.
-]]
-[[Notes:] [`count_down()` is an ['interruption point].]]
-
-]
-
-[endsect]
-[///////////////////////////////////////////////////////////////////]
-[section:count_down_and_wait Member Function `count_down_and_wait()`]
-
-        void count_down_and_wait();
-
-[variablelist
-
-[[Requires:] [The internal counter is non zero.]]
-[[Effects:] [Decrements the internal count by 1. If the resulting count is not 0, blocks the calling thread until the internal count is decremented to 0 by one or more other threads calling count_down() or count_down_and_wait(). ]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-
- - __thread_interrupted__ if the wait was interrupted by a call to __interrupt__ on the __thread__ object associated with the current thread of execution.
-]]
-[[Notes:] [`count_down_and_wait()` is an ['interruption point].]]
-
-]
-
-[endsect]
-[///////////////////////////////////////]
-[
-[section:reset Member Function `reset()`]
-
-    reset( size_t );
-
-[variablelist
-
-[[Requires:] [This function may only be invoked when there are no other threads currently inside the waiting functions.]]
-
-[[Returns:] [Resets the latch with a new value for the initial thread count.  ]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-]]
-
-]
-
-[endsect]
-]
-[endsect] [/ latch]
-
-[/
-[//////////////////////////////////////////////////]
-[section:completion_latch Class `completion_latch `]
-
-    #include <boost/thread/completion_latch.hpp>
-
-    class completion_latch
-    {
-    public:
-        typedef 'implementation defined' completion_function;
-
-        completion_latch(completion_latch const&) = delete;
-        completion_latch& operator=(completion_latch const&) = delete;
-
-        completion_latch(std::size_t count);
-        template <typename F>
-        completion_latch(std::size_t count, F&& funct);
-        ~completion_latch();
-
-        void wait();
-        bool try_wait();
-        template <class Rep, class Period>
-        cv_status wait_for(const chrono::duration<Rep, Period>& rel_time);
-        template <class lock_type, class Clock, class Duration>
-        cv_status wait_until(const chrono::time_point<Clock, Duration>& abs_time);
-        void count_down();
-        void count_down_and_wait();
-        void reset(std::size_t count);
-        template <typename F>
-        completion_function then(F&& funct);
-    };
-
-
-A completion latch is like a latch that allows to associate a completion function which will be called once the internal counter reaches the value 0 and all the consumer threads have taken care of the notification. 
-
-Instances of completion_latch are not copyable or movable.
-
-Only the additional functions are documented.
-
-[/////////////////////]
-[section:c Constructor]
-
-    completion_latch(std::size_t count);
-
-[variablelist
-
-[[Effects:] [Construct a completion_latch with is initial value for the internal counter and a noop completion function.]]
-
-[[Note:] [The counter could be zero and rest later.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[///////////////////////////////////////////////]
-[section:cf Constructor with completion function]
-
-        template <typename F>
-        completion_latch(std::size_t count, F&& funct);
-
-[variablelist
-
-[[Effects:] [Construct a completion_latch with is initial value for the internal counter and the completion function `funct`.]]
-
-[[Note:] [The counter could be zero and reset later.]]
-
-[[Throws:] [
-
- - Any exception thrown by the copy/move construction of funct. 
-
-]]
-
-]
-
-[endsect]
-[///////////////////////////////////]
-[section:then Member Function `then`]
-
-        template <typename F>
-        completion_function then(F&& funct);
-
-[variablelist
-
-[[Requires:] [This function may only be invoked when there are no other threads currently inside the waiting functions. It may also be invoked from within the registered completion function. ]]
-
-[[Effects:] [Associates the parameter `funct` as completion function of the latch. The next time the internal count reaches 0, this function will be invoked.]]
-[[Returns:] [The old completion function.]]
-
-[[Throws:] [
- - __thread_resource_error__ if an error occurs. 
-
- - Any exception thrown by the copy/move construction of completion functions. 
-]]
-
-]
-
-[endsect]
-
-[endsect] [/ completion_latch]
-]
-
-[endsect] [/ Latches]
--- a/doc/lockable_adapter.qbk
+++ b/doc/lockable_adapter.qbk
@@ -1,117 +0,0 @@
-[/
-  (C) Copyright 2008-2013 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).
-]
-
-[/==========================================================================================]
-[section:lockable_adapter_hpp Header `<boost/thread/lockable_adapter.hpp>`]
-[/==========================================================================================]
-
-    namespace boost {
-        template <typename Lockable> class basic_lockable_adapter;
-        template <typename Lockable> class lockable_adapter;
-        template <typename TimedLock> class timed_lockable_adapter;
-        template <typename SharableLock> class shared_lockable_adapter;
-        template <typename UpgradableLock> class upgrade_lockable_adapter;
-    }
-
-[section Template Class `basic_lockable_adapter<>`]
-
-    template <typename Lockable>
-    class basic_lockable_adapter {
-    public:
-        basic_lockable_adapter(basic_lockable_adapter const&) = delete
-        basic_lockable_adapter& opearator=(basic_lockable_adapter const&) = delete
-
-        typedef Lockable mutex_type;
-
-        basic_lockable_adapter() {}
-        void lock();
-        void unlock();
-        bool try_lock();
-    };
-
-[endsect]
-[section Template Class `lockable_adapter<>`]
-
-    template <typename Lockable>
-    class lockable_adapter : : public basic_lockable_adapter<Lockable> {
-    public:
-        lockable_adapter() {}
-
-        bool try_lock();
-    };
-
-[endsect]
-
-[section Template Class `timed_lockable_adapter<>`]
-
-    template <typename TimedLock>
-    class timed_lockable_adapter : public lockable_adapter<TimedLock> {
-    public:
-        timed_lockable_adapter() {}
-
-        bool try_lock_until(system_time const & abs_time);
-        template<typename TimeDuration>
-        bool try_lock_for(TimeDuration const & relative_time);
-        
-        void lock_until(system_time const & abs_time);
-        template<typename TimeDuration>
-        void lock_for(TimeDuration const & relative_time);
-    };
-
-[endsect]
-[section Template Class `shared_lockable_adapter<>`]
-
-    template <typename SharableLock>
-    class shared_lockable_adapter : public timed_lockable_adapter<SharableLock>     {
-    public:
-        shared_lockable_adapter() {}
-        void lock_shared();
-        bool try_lock_shared();
-        void unlock_shared();
-
-        bool try_lock_shared_until(system_time const& t);
-        template<typename TimeDuration>   
-        bool try_lock_shared_for(TimeDuration const& t);
-        
-        template<typename TimeDuration>   
-        void lock_shared_for(TimeDuration const& t);
-        void lock_shared_until(system_time const& t);
-    };
-
-
-[endsect]
-[section Template Class `upgrade_lockable_adapter<>`]
-
-    template <typename UpgradableLock>
-    class upgrade_lockable_adapter : public shared_lockable_adapter<UpgradableLock>{
-    public:
-        upgrade_lockable_adapter();
-
-        void lock_upgrade();
-        bool try_lock_upgrade();
-        void unlock_upgrade();
-
-        void unlock_upgrade_and_lock();
-        void unlock_and_lock_upgrade();
-        void unlock_and_lock_shared();
-        void unlock_upgrade_and_lock_shared();
-        
-        bool try_lock_upgrade_until(system_time const&t);
-        template<typename TimeDuration>   
-        bool try_lock_upgrade_for(TimeDuration const&t);
-        void lock_upgrade_until(system_time const&t);
-        template<typename TimeDuration>   
-        void lock_upgrade_for(TimeDuration const&t);
-    };
-
-
-
-[endsect]
-[endsect]
-
-
-
--- a/doc/mutex_concepts.qbk
+++ b/doc/mutex_concepts.qbk
@@ -42,8 +42,6 @@ Lock ownership acquired through a call to __lock_ref__ must be released through

 [variablelist

-[[Requires:] [The calling thread doesn't owns the mutex if the mutex is not recursive.]]
-
 [[Effects:] [The current thread blocks until ownership can be obtained for the current thread.]]

 [[Synchronization:] [Prior `unlock()` operations on the same object synchronizes with this operation. ]]
@@ -99,12 +97,7 @@ Lock ownership acquired through a call to __lock_ref__ must be released through
    }
  }

-
-Some of the algorithms on mutexes use this trait via SFINAE. 
-
-This trait is true_type if the parameter L meets the __Lockable requirements.
-
-[warning If BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES is defined you will need to specialize this traits for the models of BasicLockable you could build.] 
+Some of the algorithms on mutexes use this trait via SFINAE. If BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES is defined you will need to specialize this traits for the models of BasicLockable you could build. 

 [endsect]
 [endsect]
@@ -128,9 +121,6 @@ Lock ownership acquired through a call to __try_lock_ref__ must be released thro

 [variablelist

-
-[[Requires:] [The calling thread doesn't owns the mutex if the mutex is not recursive.]]
-
 [[Effects:] [Attempt to obtain ownership for the current thread without blocking.]]

 [[Synchronization:] [If `try_lock()` returns true, prior `unlock()` operations on the same object synchronize with this operation.]]
@@ -162,11 +152,7 @@ failure, even in the absence of spurious failures.]]
    }
  }

-Some of the algorithms on mutexes use this trait via SFINAE. 
-
-This trait is true_type if the parameter L meets the __Lockable requirements.
-
-[warning If BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES is defined you will need to specialize this traits for the models of Lockable you could build.] 
+Some of the algorithms on mutexes use this trait via SFINAE. If BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES is defined you will need to specialize this traits for the models of Lockable you could build. 

 [endsect]
 [endsect]
@@ -176,7 +162,7 @@ This trait is true_type if the parameter L meets the __Lockable requirements.
 The user could require that the mutex passed to an algorithm is a recursive one. Whether a lockable is recursive or not can not be checked using template meta-programming. This is the motivation for the following trait.


-[section:is_recursive_mutex_sur_parole `is_recursive_mutex_sur_parole` trait -- EXTENSION]
+[section:is_recursive_mutex_sur_parolle `is_recursive_mutex_sur_parolle` trait -- EXTENSION]

  // #include <boost/thread/lockable_traits.hpp> 

@@ -185,51 +171,20 @@ The user could require that the mutex passed to an algorithm is a recursive one.
    namespace sync 
    {
      template<typename L>
-      class is_recursive_mutex_sur_parole: false_type; // EXTENSION
+      class is_recursive_mutex_sur_parolle: false_type; // EXTENSION
      template<>
-      class is_recursive_mutex_sur_parole<recursive_mutex>: true_type; // EXTENSION
+      class is_recursive_mutex_sur_parolle<recursive_mutex>: true_type; // EXTENSION
      template<>
-      class is_recursive_mutex_sur_parole<timed_recursive_mutex>: true_type; // EXTENSION
+      class is_recursive_mutex_sur_parolle<timed_recursive_mutex>: true_type; // EXTENSION
    }
  }

-The trait `is_recursive_mutex_sur_parole` is `false_type` by default and is specialized for the provide `recursive_mutex` and `timed_recursive_mutex`. 
+The trait `is_recursive_mutex_sur_parolle` is `false_type` by default and is specialized for the provide `recursive_mutex` and `timed_recursive_mutex`. 

 It should be specialized by the user providing other model of recursive lockable.

 [endsect]

-[section:is_recursive_basic_lockable `is_recursive_basic_lockable` trait -- EXTENSION]
-
-  // #include <boost/thread/lockable_traits.hpp> 
-  namespace boost 
-  {
-    namespace sync 
-    {
-      template<typename L>
-      class is_recursive_basic_lockable;// EXTENSION
-    }
-  }
-
-This traits is true_type if is_basic_lockable and is_recursive_mutex_sur_parole.
-
-[endsect]
-[section:is_recursive_lockable `is_recursive_lockable` trait -- EXTENSION]
-
-  // #include <boost/thread/lockable_traits.hpp> 
-  namespace boost 
-  {
-    namespace sync 
-    {
-      template<typename L>
-      class is_recursive_lockable;// EXTENSION
-    }
-  }
-
-This traits is true_type if is_lockable and is_recursive_mutex_sur_parole.
-
-[endsect]
-
 [endsect]


@@ -265,8 +220,6 @@ Lock ownership acquired through a call to __try_lock_for or __try_lock_until mus

 [variablelist

-[[Requires:] [The calling thread doesn't owns the mutex if the mutex is not recursive.]]
-
 [[Effects:] [Attempt to obtain ownership for the current thread. Blocks until ownership can be obtained, or the specified time is
 reached. If the specified time has already passed, behaves as __try_lock_ref__.]]

@@ -286,8 +239,6 @@ reached. If the specified time has already passed, behaves as __try_lock_ref__.]

 [variablelist

-[[Requires:] [The calling thread doesn't owns the mutex if the mutex is not recursive.]]
-
 [[Effects:] [As-if `__try_lock_until(chrono::steady_clock::now() + rel_time)`.]]

 [[Synchronization:] [If `try_lock_for()` returns true, prior `unlock()` operations on the same object synchronize with this operation.]]
@@ -298,6 +249,8 @@ reached. If the specified time has already passed, behaves as __try_lock_ref__.]
 [warning
 DEPRECATED since 4.00. The following expressions were required on version 2, but are now deprecated.
 
+Available only up to Boost 1.58. 
+
 Use instead __try_lock_for, __try_lock_until.  
 ]

@@ -342,14 +295,14 @@ reached. If the specified time has already passed, behaves as __try_lock_ref__.]

 [endsect]

-[section:shared_lockable `SharedLockable` Concept -- C++14]
+[section:shared_lockable `SharedLockable` Concept -- EXTENSION]

  // #include <boost/thread/lockable_concepts.hpp> 

  namespace boost 
  {
    template<typename L>
-    class SharedLockable;  // C++14
+    class SharedLockable;  // EXTENSION
  }


@@ -458,6 +411,8 @@ ownership of `m`.]]
 [warning
 DEPRECATED since 3.00. The following expressions were required on version 2, but are now deprecated.
 
+Available only up to Boost 1.56. 
+
 Use instead __try_lock_shared_for, __try_lock_shared_until.  
 ]

@@ -869,7 +824,7 @@ any other threads have shared ownership, blocks until exclusive ownership can be

 [variablelist

-[[Precondition:] [The calling thread shall hold an upgrade lock on the mutex.]]
+[[Precondition:] [The calling thread shall hold a upgrade lock on the mutex.]]

 [[Effects:] [The function attempts to atomically convert the ownership from upgrade to exclusive for the calling thread without blocking. 
 For this conversion to be successful, this thread must be the only thread holding any ownership of the lock. 
@@ -893,7 +848,7 @@ If the conversion is not successful, the upgrade ownership of m is retained.]]

 [variablelist

-[[Precondition:] [The calling thread shall hold an upgrade lock on the mutex.]]
+[[Precondition:] [The calling thread shall hold a upgrade lock on the mutex.]]

 [[Effects:] [If the tick period of `rel_time` is not exactly convertible to the native tick period, the duration shall be rounded up to the nearest native tick period. 
 The function attempts to atomically convert the ownership from upgrade to exclusive for the calling thread within the relative timeout specified by `rel_time`. 
@@ -919,7 +874,7 @@ If the conversion is not successful, the upgrade ownership of m is retained.]]

 [variablelist

-[[Precondition:] [The calling thread shall hold an upgrade lock on the mutex.]]
+[[Precondition:] [The calling thread shall hold a upgrade lock on the mutex.]]

 [[Effects:] [The function attempts to atomically convert the ownership from upgrade to exclusive for the calling thread within the absolute timeout specified by `abs_time`. 
 If `abs_time` has already passed, the function attempts to obtain exclusive ownership without blocking (as if by calling `__try_unlock_upgrade_and_lock()`). 
@@ -1115,44 +1070,6 @@ object passed to the constructor.]]
 ]


-[endsect]
-[endsect]
-
-
-[section:with_lock_guard With Lock Guard]
-
-  // #include <boost/thread/with_lock_guard.hpp>
-
-  namespace boost 
-  {
-    template <class Lockable, class Function, class... Args>
-    auto with_lock_guard(Lockable& m, Function&& func, Args&&... args) -> decltype(func(boost::forward<Args>(args)...));
-  }
-
-[section:with_lock_guard Non Member Function `with_lock_guard`]
-
-  template <class Lockable, class Function, class... Args>
-  auto with_lock_guard(
-      Lockable& m,
-      Function&& func,
-      Args&&... args
-  ) -> decltype(func(boost::forward<Args>(args)...));
-
-[variablelist
-
-[[Precondition:] [`m` must be in unlocked state]]
-[[Effects:] [call `func` in scope locked by `m`]]
-[[Returns:] [Result of `func(args...)` call]]
-[[Throws:] [Any exception thrown by the call to `m.lock` and `func(args...)`]]
-[[Postcondition:] [`m` is in unlocked state]]
-
-[[Limitations:] [Without c++11 variadic templates support number of arguments is limited to `4`]]
-[[] [Without rvalue references support calling class method with `boost::bind` must be const]]
-[[] [For correct work with lambda macro `BOOST_RESULT_OF_USE_DECLTYPE` may be needed to define]]
-
-
-]
-
 [endsect]
 [endsect]

@@ -1169,7 +1086,7 @@ object passed to the constructor.]]
  }

  
-A StrictLock is a lock that ensures that the associated mutex is locked during the lifetime of the lock.
+A StrictLock is a lock that ensures that the associated mutex is locked during the lifetime if the lock.

 A type `L` meets the StrictLock requirements if the following expressions are well-formed and have the specified semantics 

@@ -1190,13 +1107,13 @@ The type L::mutex_type denotes the mutex that is locked by this lock.

 [endsect] [/ mutex_type]

-[section:is_strict_lock_sur_parole `is_strict_lock_sur_parole<L>`]
+[section:is_strict_lock_sur_parolle `is_strict_lock_sur_parolle<L>`]

-As the semantic "ensures that the associated mutex is locked during the lifetime of the lock. " can not be described by syntactic requirements a `is_strict_lock_sur_parole` trait must be specialized by the user defining the lock so that the following assertion is true:
+As the semantic "ensures that the associated mutex is locked during the lifetime if the lock. " can not be described by syntactic requirements a `is_strict_lock_sur_parolle` trait must be specialized by the user defining the lock so that the following assertion is true:

-  is_strict_lock_sur_parole<L>::value == true
+  is_strict_lock_sur_parolle<L>::value == true

-[endsect] [/ is_strict_lock_sur_parole]
+[endsect] [/ is_strict_lock_sur_parolle]

 [section:owns_lock `cl.owns_lock(m);`]

@@ -1217,8 +1134,8 @@ As the semantic "ensures that the associated mutex is locked during the lifetime
 The following classes are models of `StrictLock`:

 * strict_lock: ensured by construction,
-* nested_strict_lock: "sur parole" as the user could use adopt_lock_t on unique_lock constructor overload without having locked the mutex,
-* __lock_guard__: "sur parole" as the user could use adopt_lock_t constructor overload without having locked the mutex.
+* nested_strict_lock: ensured by construction,
+* __lock_guard__: "sur parolle" as the user could use adopt_lock_t constructor overload without having locked the mutex.

 [endsect] [/ Models]

@@ -1239,9 +1156,9 @@ The following classes are models of `StrictLock`:
    template<typename Mutex>
    void swap(unique_lock <Mutex>& lhs, unique_lock <Mutex>& rhs);
    template<typename Lockable>
-    class shared_lock; // C++14
+    class shared_lock; // EXTENSION
    template<typename Mutex>
-    void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs); // C++14
+    void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs); // EXTENSION
    template<typename Lockable>
    class upgrade_lock; // EXTENSION
    template<typename Mutex>
@@ -1269,13 +1186,13 @@ The following classes are models of `StrictLock`:
        unique_lock(Lockable& m_,try_to_lock_t);

    #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
-        unique_lock(shared_lock<mutex_type>&& sl, try_to_lock_t); // C++14 
+        unique_lock(shared_lock<mutex_type>&& sl, try_to_lock_t)
        template <class Clock, class Duration>
        unique_lock(shared_lock<mutex_type>&& sl,
-                    const chrono::time_point<Clock, Duration>& abs_time); // C++14
+                    const chrono::time_point<Clock, Duration>& abs_time);
        template <class Rep, class Period>
        unique_lock(shared_lock<mutex_type>&& sl,
-                    const chrono::duration<Rep, Period>& rel_time); // C++14
+                    const chrono::duration<Rep, Period>& rel_time)
    #endif

        template <class Clock, class Duration>
@@ -1287,7 +1204,7 @@ The following classes are models of `StrictLock`:
        unique_lock(unique_lock const&) = delete;
        unique_lock& operator=(unique_lock const&) = delete;
        unique_lock(unique_lock<Lockable>&& other) noexcept;
-        explicit unique_lock(upgrade_lock<Lockable>&& other) noexcept; // EXTENSION
+        explicit unique_lock(upgrade_lock<Lockable>&& other) noexcept;

        unique_lock& operator=(unique_lock<Lockable>&& other) noexcept;

@@ -1307,7 +1224,7 @@ The following classes are models of `StrictLock`:
        explicit operator bool() const noexcept;
        bool owns_lock() const noexcept;

-        mutex_type* mutex() const noexcept;
+        Lockable* mutex() const noexcept;

    #if defined BOOST_THREAD_USE_DATE_TIME || defined BOOST_THREAD_DONT_USE_CHRONO
        unique_lock(Lockable& m_,system_time const& target_time);
@@ -1569,7 +1486,7 @@ object associated with `*this`.]]

 [endsect]

-[section:mutex `Lockable* mutex() const noexcept`]
+[section:mutex `Lockable* mutex() const`]

 [variablelist

@@ -1617,7 +1534,7 @@ __owns_lock_ref__ returns `false`.]]

 [endsect]

-[section:shared_lock Class template `shared_lock` - C++14]
+[section:shared_lock Class template `shared_lock` - EXTENSION]

    // #include <boost/thread/locks.hpp>
    // #include <boost/thread/lock_types.hpp> 
@@ -1655,7 +1572,7 @@ __owns_lock_ref__ returns `false`.]]
        void unlock();

        // Conversion from upgrade locking
-        explicit shared_lock(upgrade_lock<Lockable> && other); // EXTENSION
+        explicit shared_lock(upgrade_lock<Lockable> && other);

        // Conversion from exclusive locking
        explicit shared_lock(unique_lock<Lockable> && other);
@@ -1941,7 +1858,7 @@ state (including the destructor) must be called by the same thread that acquired

 [endsect]

-[section:upgrade_to_unique_lock Class template `upgrade_to_unique_lock` -- EXTENSION]
+[section:upgrade_to_unique_lock Class template `upgrade_to_unique_lock`]

    // #include <boost/thread/locks.hpp>
    // #include <boost/thread/lock_types.hpp> 
@@ -1964,8 +1881,6 @@ state (including the destructor) must be called by the same thread that acquired

        explicit operator bool() const;
        bool owns_lock() const;
-        mutex_type* mutex() const;
-
    };

 __upgrade_to_unique_lock__ allows for a temporary upgrade of an __upgrade_lock__ to exclusive ownership. When constructed with a
@@ -1975,7 +1890,7 @@ __lockable_concept_type__ is downgraded back to ['upgrade ownership].

 [endsect]

-[section:scoped_try_lock Mutex-specific class `scoped_try_lock` -- DEPRECATED]
+[section:scoped_try_lock Mutex-specific class `scoped_try_lock`]

    class MutexType::scoped_try_lock
    {
@@ -2062,9 +1977,9 @@ __reverse_mutex reverse the operations of a __BasicLockable, that unlocks the lo
    template <typename Lock>
    class nested_strict_lock;
    template <typename Lockable>
-    struct is_strict_lock_sur_parole<strict_lock<Lockable> >;
+    struct is_strict_lock_sur_parolle<strict_lock<Lockable> >;
    template <typename Lock>
-    struct is_strict_lock_sur_parole<nested_strict_lock<Lock> >;
+    struct is_strict_lock_sur_parolle<nested_strict_lock<Lock> >;

  #if ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK
    template <typename Lockable>
@@ -2087,8 +2002,6 @@ __reverse_mutex reverse the operations of a __BasicLockable, that unlocks the lo
    {
    public:
        typedef BasicLockable mutex_type;
-        strict_lock(strict_lock const& m_) = delete;
-        strict_lock& operator=(strict_lock const& m_) = delete;
        explicit strict_lock(mutex_type& m_);
        ~strict_lock();

@@ -2139,8 +2052,6 @@ object passed to the constructor.]]
    {
    public:
        typedef BasicLockable mutex_type;
-        nested_strict_lock(nested_strict_lock const& m_) = delete;
-        nested_strict_lock& operator=(nested_strict_lock const& m_) = delete;
        explicit nested_strict_lock(Lock& lk),
        ~nested_strict_lock() noexcept;

@@ -2150,7 +2061,7 @@ object passed to the constructor.]]
 __nested_strict_lock is a model of __StrictLock.

 A nested strict lock is a scoped lock guard ensuring a mutex is locked on its
-scope, by taking ownership of a nesting lock, locking the mutex on construction if not already locked
+scope, by taking ownership of an nesting lock, locking the mutex on construction if not already locked
 and restoring the ownership to the nesting lock on destruction.
 

@@ -2243,247 +2154,15 @@ If the lock doesn't owns the mutex lock it.
  
 [endsect]

-[section:lock_ptrs Locking pointers]
-
-  // #include <boost/thread/synchroniezd_value.hpp> 
-  // #include <boost/thread/strict_lock_ptr.hpp> 
-
-  namespace boost 
-  {
-
-    template<typename T, typename Lockable = mutex>
-    class strict_lock_ptr;
-    template<typename T, typename Lockable = mutex>
-    class const_strict_lock_ptr;
-  }
-  
-
-[/
-    template<typename T, typename Lockable = mutex>
-    class unique_lock_ptr;
-    template<typename T, typename Lockable = mutex>
-    class const_unique_lock_ptr;
-
-]
-
-[section:const_strict_lock_ptr Class template `const_strict_lock_ptr `]
-
-  // #include <boost/thread/synchroniezd_value.hpp> 
-  // #include <boost/thread/strict_lock_ptr.hpp> 
-
-
-  template <typename T, typename Lockable = mutex>
-  class const_strict_lock_ptr
-  {
-  public:
-    typedef T value_type;
-    typedef Lockable mutex_type;
-
-    const_strict_lock_ptr(const_strict_lock_ptr const& m_) = delete;
-    const_strict_lock_ptr& operator=(const_strict_lock_ptr const& m_) = delete;
-
-    const_strict_lock_ptr(T const& val, Lockable & mtx);
-    const_strict_lock_ptr(T const& val, Lockable & mtx, adopt_lock_t tag);
-
-    ~const_strict_lock_ptr();
-
-    const T* operator->() const;
-    const T& operator*() const;
-
-  };
-
-
-[section:constructor `const_strict_lock_ptr(T const&,Lockable&)`]
-
-
-    const_strict_lock_ptr(T const& val, Lockable & m);
-
-[variablelist
-
-[[Effects:] [Invokes [lock_ref_link `m.lock()`], stores a reference to it and to the value type `val`.]]
-
-[[Throws:] [Any exception thrown by the call to [lock_ref_link `m.lock()`].]]
-
-]
-
-[endsect]
-[section:constructor_adopt `const_strict_lock_ptr(T const&,Lockable&,adopt_lock_t)`]
-
-    const_strict_lock_ptr(T const& val, Lockable & m, adopt_lock_t tag);
-
-[variablelist
-
-[[Effects:] [Stores a reference to it and to the value type `val`.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-
-[section:destructor `~const_strict_lock_ptr()`]
-
-    ~const_strict_lock_ptr();
-
-[variablelist
-
-[[Effects:] [Invokes [unlock_ref_link `m.unlock()`] on the __lockable_concept_type__
-object passed to the constructor.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-[section:indir `operator->() const`]
-
-    const T* operator->() const;
-
-
-[variablelist
-
-[[Return:] [return a constant pointer to the protected value.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-[section:deref `operator*() const`]
-
-    const T& operator*() const;
-
-
-[variablelist
-
-[[Return:] [return a constant reference to the protected value.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-
-[endsect] [/ const_strict_lock_ptr ]
-
-[section:strict_lock_ptr Class template `strict_lock_ptr`]
-
-  // #include <boost/thread/synchroniezd_value.hpp> 
-  // #include <boost/thread/strict_lock_ptr.hpp> 
-
-  template <typename T, typename Lockable = mutex>
-  class strict_lock_ptr : public const_strict_lock_ptr<T,Lockable>
-  {
-  public:
-    strict_lock_ptr(strict_lock_ptr const& m_) = delete;
-    strict_lock_ptr& operator=(strict_lock_ptr const& m_) = delete;
-
-    strict_lock_ptr(T & val, Lockable & mtx);
-    strict_lock_ptr(T & val, Lockable & mtx, adopt_lock_t tag);
-    ~strict_lock_ptr();
-
-    T* operator->();
-    T& operator*();
-
-  };
-
-
-[section:constructor `strict_lock_ptr(T const&,Lockable&)`]
-
-
-    strict_lock_ptr(T const& val, Lockable & m);
-
-[variablelist
-
-[[Effects:] [Invokes [lock_ref_link `m.lock()`], stores a reference to it and to the value type `val`.]]
-
-[[Throws:] [Any exception thrown by the call to [lock_ref_link `m.lock()`].]]
-
-]
-
-[endsect]
-[section:constructor_adopt `strict_lock_ptr(T const&,Lockable&,adopt_lock_t)`]
-
-    strict_lock_ptr(T const& val, Lockable & m, adopt_lock_t tag);
-
-[variablelist
-
-[[Effects:] [Stores a reference to it and to the value type `val`.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-
-[section:destructor `~strict_lock_ptr()`]
-
-    ~ strict_lock_ptr();
-
-[variablelist
-
-[[Effects:] [Invokes [unlock_ref_link `m.unlock()`] on the __lockable_concept_type__
-object passed to the constructor.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-[section:indir `operator->()`]
-
-    T* operator->();
-
-
-[variablelist
-
-[[Return:] [return a pointer to the protected value.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-[section:deref `operator*()`]
-
-    T& operator*();
-
-
-[variablelist
-
-[[Return:] [return a reference to the protected value.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-
-[endsect] [/ strict_lock_ptr ]
-
-[endsect] [/ lock_ptrs ]
-
-
 [section Externally Locked]

  // #include <boost/thread/externally_locked.hpp>
  template <class T, typename MutexType = boost::mutex>
  class externally_locked;
-  template <class T, typename MutexType>
-  class externally_locked<T&, MutexType>;
-
  template <typename T, typename MutexType>
  void swap(externally_locked<T, MutexType> & lhs, externally_locked<T, MutexType> & rhs);

-[section:externally_locked Template Class `externally_locked`]
+[section Template Class `externally_locked`]

  // #include <boost/thread/externally_locked.hpp>

@@ -2499,11 +2178,8 @@ object passed to the constructor.]]
    externally_locked(mutex_type& mtx, const T& obj);
    externally_locked(mutex_type& mtx,T&& obj);
    explicit externally_locked(mutex_type& mtx);
-    externally_locked(externally_locked const& rhs);
    externally_locked(externally_locked&& rhs);
-    externally_locked& operator=(externally_locked const& rhs);
-    externally_locked& operator=(externally_locked&& rhs);
- 
+
    // observers
    T& get(strict_lock<mutex_type>& lk);
    const T& get(strict_lock<mutex_type>& lk) const;
@@ -2518,7 +2194,7 @@ object passed to the constructor.]]
    template <class Lock>
    T const& get(Lock& lk) const;

-   mutex_type* mutex() const noexcept;
+    mutex_type* mutex();

    // modifiers
    void lock();
@@ -2582,7 +2258,7 @@ Only the specificities respect to __Lockable are described here.

 [endsect]
 [///////////////////////////////]
-[section:constructor4 `externally_locked(externally_locked&&)`]
+[section:constructor4 `externally_locked(externally_locked&)`]

    externally_locked(externally_locked&& rhs);

@@ -2590,62 +2266,13 @@ Only the specificities respect to __Lockable are described here.

 [[Requires:] [T is a model of Movable.]]

-[[Effects:] [Move constructs an externally locked object by moving the cloaked type and copying the mutex reference ]]
+[[Effects:] [Moves an externally locked object by moving the the cloaked type and copying the mutex reference ]]

 [[Throws:] [Any exception thrown by the call to `T(T&&)`.]]

 ]

 [endsect]
-[///////////////////////////////]
-[section:constructor5 `externally_locked(externally_locked&)`]
-
-    externally_locked(externally_locked& rhs);
-
-[variablelist
-
-[[Requires:] [T is a model of Copyable.]]
-
-[[Effects:] [Copy constructs an externally locked object by copying the cloaked type and copying the mutex reference ]]
-
-[[Throws:] [Any exception thrown by the call to `T(T&)`.]]
-
-]
-
-[endsect]
-[///////////////////////////////]
-[section:assign4 `externally_locked(externally_locked&&)`]
-
-    externally_locked& operator=(externally_locked&& rhs);
-
-[variablelist
-
-[[Requires:] [T is a model of Movable.]]
-
-[[Effects:] [Move assigns an externally locked object by moving the cloaked type and copying the mutex reference ]]
-
-[[Throws:] [Any exception thrown by the call to `T::operator=(T&&)`.]]
-
-]
-
-[endsect]
-[///////////////////////////////]
-[section:assign5 `externally_locked(externally_locked&)`]
-
-    externally_locked& operator=(externally_locked const& rhs);
-
-[variablelist
-
-[[Requires:] [T is a model of Copyable.]]
-
-[[Effects:] [Copy assigns an externally locked object by copying the cloaked type and copying the mutex reference ]]
-
-[[Throws:] [Any exception thrown by the call to `T::operator=(T&)`.]]
-
-]
-
-[endsect]
-
 [///////////////////////////////]
 [section:get1 `get(strict_lock<mutex_type>&)`]

@@ -2664,7 +2291,7 @@ Only the specificities respect to __Lockable are described here.

 [endsect]
 [///////////////////////////////]
-[section:get2 `get(nested_strict_lock<Lock>&)`]
+[section:get2 `get(strict_lock<nested_strict_lock<Lock>>&)`]

    template <class Lock>
    T& get(nested_strict_lock<Lock>& lk);
@@ -2684,7 +2311,7 @@ Only the specificities respect to __Lockable are described here.
 [endsect]

 [///////////////////////////////]
-[section:get3 `get(Lock&)`]
+[section:get3 `get(strict_lock<nested_strict_lock<Lock>>&)`]

    template <class Lock>
    T& get(Lock& lk);
@@ -2704,172 +2331,8 @@ Only the specificities respect to __Lockable are described here.
 [endsect]

 [endsect]
-[section:externally_locked_ref Template Class `externally_locked<T&>`]
-
-  // #include <boost/thread/externally_locked.hpp>
-
-  template <class T, typename MutexType>
-  class externally_locked<T&, MutexType> 
-  {
-    //BOOST_CONCEPT_ASSERT(( CopyConstructible<T> ));
-    BOOST_CONCEPT_ASSERT(( BasicLockable<MutexType> ));
-
-  public:
-    typedef MutexType mutex_type;
-
-    externally_locked(mutex_type& mtx, T& obj);
-    explicit externally_locked(mutex_type& mtx);
-    externally_locked(externally_locked const& rhs) noexcept;
-    externally_locked(externally_locked&& rhs) noexcept;
-    externally_locked& operator=(externally_locked const& rhs) noexcept;
-    externally_locked& operator=(externally_locked&& rhs) noexcept;
-
-    // observers
-    T& get(strict_lock<mutex_type>& lk);
-    const T& get(strict_lock<mutex_type>& lk) const;
-
-    template <class Lock>
-    T& get(nested_strict_lock<Lock>& lk);
-    template <class Lock>
-    const T& get(nested_strict_lock<Lock>& lk) const;
-
-    template <class Lock>
-    T& get(Lock& lk);
-    template <class Lock>
-    T const& get(Lock& lk) const;
-
-   mutex_type* mutex() const noexcept;
-
-    // modifiers
-    void lock();
-    void unlock();
-    bool try_lock();
-    void swap(externally_locked&) noexcept;
-  };
-
-`externally_locked` is a model of __Lockable, it cloaks an object of type `T`, and actually provides full
-access to that object through the get and set member functions, provided you
-pass a reference to a strict lock object.
-
-Only the specificities respect to __Lockable are described here. 
-
 [///////////////////////////////]
-[section:constructor1 `externally_locked<T&>(mutex_type&, T&)`]
-
-    externally_locked<T&>(mutex_type& mtx, T& obj) noexcept;
-
-[variablelist
-
-
-[[Effects:] [Constructs an externally locked object copying the cloaked reference.]]
-
-]
-
-[endsect]
-[///////////////////////////////]
-[section:constructor4 `externally_locked<T&>(externally_locked&&)`]
-
-    externally_locked(externally_locked&& rhs) noexcept;
-
-[variablelist
-
-[[Effects:] [Moves an externally locked object by moving the cloaked type and copying the mutex reference ]]
-
-
-]
-
-[endsect]
-[///////////////////////////////]
-[section:assign4 `externally_locked(externally_locked&&)`]
-
-    externally_locked& operator=(externally_locked&& rhs);
-
-[variablelist
-
-[[Effects:] [Move assigns an externally locked object by copying the cloaked reference and copying the mutex reference ]]
-
-]
-
-[endsect]
-[///////////////////////////////]
-[section:assign5 `externally_locked(externally_locked&)`]
-
-    externally_locked& operator=(externally_locked const& rhs);
-
-[variablelist
-
-[[Requires:] [T is a model of Copyable.]]
-
-[[Effects:] [Copy assigns an externally locked object by copying the cloaked reference and copying the mutex reference ]]
-
-[[Throws:] [Any exception thrown by the call to `T::operator=(T&)`.]]
-
-]
-
-[endsect]
-
-[///////////////////////////////]
-[section:get1 `get(strict_lock<mutex_type>&)`]
-
-    T& get(strict_lock<mutex_type>& lk);
-    const T& get(strict_lock<mutex_type>& lk) const;
-
-[variablelist
-
-[[Requires:] [The `lk` parameter must be locking the associated mutex.]]
-
-[[Returns:] [A reference to the cloaked object ]]
-
-[[Throws:] [__lock_error__ if `BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED` is defined and the run-time preconditions are not satisfied .]]
-
-]
-
-[endsect]
-[///////////////////////////////]
-[section:get2 `get(nested_strict_lock<Lock>&)`]
-
-    template <class Lock>
-    T& get(nested_strict_lock<Lock>& lk);
-    template <class Lock>
-    const T& get(nested_strict_lock<Lock>& lk) const;
-
-[variablelist
-
-[[Requires:] [`is_same<mutex_type, typename Lock::mutex_type>` and the `lk` parameter must be locking the associated mutex.]]
-
-[[Returns:] [A reference to the cloaked object ]]
-
-[[Throws:] [__lock_error__ if `BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED` is defined and the run-time preconditions are not satisfied .]]
-
-]
-
-[endsect]
-
-[///////////////////////////////]
-[section:get3 `get(Lock&)`]
-
-    template <class Lock>
-    T& get(Lock& lk);
-    template <class Lock>
-    T const& get(Lock& lk) const;
-
-[variablelist
-
-[[Requires:] [`Lock` is a model of __StrictLock, `is_same<mutex_type, typename Lock::mutex_type>` and the `lk` parameter must be locking the associated mutex.]]
-
-[[Returns:] [A reference to the cloaked object ]]
-
-[[Throws:] [__lock_error__ if `BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED` is defined and the run-time preconditions are not satisfied .]]
-
-]
-
-[endsect]
-
-[endsect]
-
-
-[///////////////////////////////]
-[section:swap `swap(externally_locked&, externally_locked&)`]
+[section:swap `swap(externally_locked, externally_locked&)`]

  template <typename T, typename MutexType>
  void swap(externally_locked<T, MutexType> & lhs, externally_locked<T, MutexType> & rhs)
@@ -3034,8 +2497,8 @@ An instance of __reverse_lock doesn't ['own] the lock never.
 [[Effects:] [Locks the __lockable_concept_type__ objects supplied as
 arguments in an unspecified and indeterminate order in a way that
 avoids deadlock. It is safe to call this function concurrently from
-multiple threads for any set of mutexes (or other lockable objects) in
-any order without risk of deadlock. If any of the __lock_ref__
+multiple threads with the same mutexes (or other lockable objects) in
+different orders without risk of deadlock. If any of the __lock_ref__
 or __try_lock_ref__ operations on the supplied
 __lockable_concept_type__ objects throws an exception any locks
 acquired by the function will be released before the function exits.]]
@@ -3062,8 +2525,8 @@ are locked by the calling thread.]]
 [[Effects:] [Locks all the __lockable_concept_type__ objects in the
 supplied range in an unspecified and indeterminate order in a way that
 avoids deadlock. It is safe to call this function concurrently from
-multiple threads for any set of mutexes (or other lockable objects) in
-any order without risk of deadlock. If any of the __lock_ref__
+multiple threads with the same mutexes (or other lockable objects) in
+different orders without risk of deadlock. If any of the __lock_ref__
 or __try_lock_ref__ operations on the __lockable_concept_type__
 objects in the supplied range throws an exception any locks acquired
 by the function will be released before the function exits.]]
--- a/doc/mutexes.qbk
+++ b/doc/mutexes.qbk
@@ -239,6 +239,3 @@ implementation. If no such instance exists, `native_handle()` and `native_handle
 [include shared_mutex_ref.qbk]

 [endsect]
-
-
-
--- a/doc/once.qbk
+++ b/doc/once.qbk
@@ -12,8 +12,8 @@
  namespace boost
  {
    struct once_flag;
-    template<typename Function, class ...ArgTypes>
-    inline void call_once(once_flag& flag, Function&& f, ArgTypes&&... args);
+    template<typename Callable>
+    void call_once(once_flag& flag,Callable func);

  #if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0
    void call_once(void (*func)(),once_flag& flag);
@@ -21,11 +21,6 @@

  }

-[warning the variadic prototype is provided only on C++11 compilers supporting variadic templates, otherwise the interface is limited up to 3 parameters.]
-
-[warning the move semantics is ensured only on C++11 compilers supporting SFINAE expression, decltype N3276 and auto. Waiting for a boost::bind that is move aware.]
-
-
 `boost::call_once` provides a mechanism for ensuring that an initialization routine is run exactly once without data races or deadlocks.

 [section:once_flag Typedef `once_flag`]
@@ -50,22 +45,24 @@ Objects of type `boost::once_flag` shall be initialized with `BOOST_ONCE_INIT` i

 [section:call_once Non-member function `call_once`]

-    template<typename Function, class ...ArgTypes>
-    inline void call_once(once_flag& flag, Function&& f, ArgTypes&&... args);
+    template<typename Callable>
+    void call_once(once_flag& flag,Callable func);

 [variablelist

-[[Requires:] [`Function` and each or the `ArgTypes` are `MoveConstructible` and `invoke(decay_copy(boost::forward<Function>(f)), decay_copy(boost::forward<ArgTypes>(args))...)` shall be well formed. ]]
+[[Requires:] [`Callable` is `CopyConstructible`. Copying `func` shall have no side effects, and the effect of calling the copy shall
+be equivalent to calling the original. ]]

 [[Effects:] [Calls to `call_once` on the same `once_flag` object are serialized. If there has been no prior effective `call_once` on
-the same `once_flag` object, the argument `func` is called as-if by invoking `invoke(decay_copy(boost::forward<Function>(f)), decay_copy(boost::forward<ArgTypes>(args))...)`, and the invocation of
-`call_once` is effective if and only if `invoke(decay_copy(boost::forward<Function>(f)), decay_copy(boost::forward<ArgTypes>(args))...)` returns without exception. If an exception is thrown, the exception is propagated to the caller. If there has been a prior effective `call_once` on the same `once_flag` object, the `call_once` returns
+the same `once_flag` object, the argument `func` (or a copy thereof) is called as-if by invoking `func()`, and the invocation of
+`call_once` is effective if and only if `func()` returns without exception. If an exception is thrown, the exception is
+propagated to the caller. If there has been a prior effective `call_once` on the same `once_flag` object, the `call_once` returns
 without invoking `func`. ]]

 [[Synchronization:] [The completion of an effective `call_once` invocation on a `once_flag` object, synchronizes with
 all subsequent `call_once` invocations on the same `once_flag` object. ]]

-[[Throws:] [`thread_resource_error` when the effects cannot be achieved or any exception propagated from `func`.]]
+[[Throws:] [`thread_resource_error` when the effects cannot be achieved. or any exception propagated from `func`.]]

 [[Note:] [The function passed to `call_once` must not also call
 `call_once` passing the same `once_flag` object. This may cause
@@ -76,14 +73,11 @@ proceed even though the call to `call_once` didn't actually call the
 function, in which case it could also avoid calling `call_once`
 recursively.]]

-
-[[Note:] [On some compilers this function has some restrictions, e.g. if variadic templates are not supported the number of arguments is limited to 3; .]]
-
 ]

    void call_once(void (*func)(),once_flag& flag);
    
-This second overload is provided for backwards compatibility and is deprecated. The effects of `call_once(func,flag)` shall be the same as those of
+This second overload is provided for backwards compatibility. The effects of `call_once(func,flag)` shall be the same as those of
 `call_once(flag,func)`.

 [endsect]
--- a/doc/parallel.qbk
+++ b/doc/parallel.qbk
@@ -1,482 +0,0 @@
-[/
- / Copyright (c) 2014 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)
- /]
-
-[//////////////////////////////////////////////////////////]
-[section:parallel Parallel - Fork-Join -- EXPERIMENTAL]
-
-[section:fork_join Fork-Join]
-
-[warning These features are experimental and subject to change in future versions. There are not too much tests yet, so it is possible that you can find out some trivial bugs :(] 
-
-[note These features are based on the [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4088.pdf [* n4088 - Task Region R3]] C++1y proposal from P. Halpern, A. Robison, A. Laksberg, H. Sutter, et al.  The text that follows has been adapted from this paper to show the differences.]
-
-The major difference respect to the standard proposal is that we are able to use a common executor for several task regions.
-
-[note 
-Up to now, Boost.Thread doesn't implement the parallel algorithms as defined in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4105.pdf [* n4105 - Information technology – Programming languages, their environments and system software interfaces – Technical Specification for C++ Extensions for Parallelism]].
-]
-
-[////////////////////]
-[section Introduction]
-
-
-This module introduces a C++11/c++14 library function template `task_region` and a library class `task_region_handle`
-with member functions `run` and `wait` that together enable developers to write expressive and portable fork-join
-parallel code.
-
-The working draft for the Parallelism TS [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4105.pdf [*N4105]] augments the STL algorithms with the inclusion of parallel execution policies. Programmers use these as a basis to write additional high-level algorithms that can be implemented in terms of the provided parallel algorithms. However, the scope of n4105 does not include lower-level mechanisms to express arbitrary fork-join parallelism
-
-The `task_region`, `run` and the `wait` functions provided by this library are based on the `task_group` concept that is a part of the common subset of the PPL and the TBB libraries.
-
-[endsect] [/ Introduction]
-
-
-[/////////////////////////]
-[section:tutorial Tutorial]
-
-Consider an example of a parallel traversal of a tree, where a user-provided function compute is applied to each node of the tree, returning the sum of the results:
-
-  template<typename Func>
-  int traverse(node *n, Func&& compute)
-  {
-    int left = 0, right = 0;
-    task_region([&](task_region_handle& tr) {
-      if (n->left)
-        tr.run([&] { left = traverse(n->left, compute); });
-      if (n->right)
-        tr.run([&] { right = traverse(n->right, compute); });
-    });
-    return compute(n) + left + right;
-  }
-
-The example above demonstrates the use of two of the functions proposed in this paper, `task_region` and
-`task_region_handle::run`.
-The `task_region` function delineates a region in a program code potentially containing invocations of tasks
-spawned by the `run` member function of the `task_region_handle` class.
-
-The run function spawns a task, a unit of work that is allowed to execute in parallel with respect to the caller.
-Any parallel tasks spawned by `run` within the `task_region` are joined back to a single thread of execution at
-the end of the `task_region`.
-
-`run` takes a user-provided function object `f` and starts it asynchronously - i.e. it may return before the
-execution of `f` completes. The implementation's scheduler may choose to run `f` immediately or delay running
-`f` until compute resources become available.
-
-A `task_region_handle` can be constructed only by `task_region` because it has no public constructors.
-Thus, `run` can be invoked (directly or indirectly) only from a user-provided function passed to `task_region`:
-
-  void g();
-  void f(task_region_handle& tr)
-  {
-    tr.run(g); // OK, invoked from within task_region in h
-  }
-  void h()
-  {
-    task_region(f);
-  }
-
-  int main()
-  {
-    task_region_handle tr; // Error: no public constructor
-    tr.run(g); // No way to call run outside of a task_region
-    return 0;
-  }
-
-[endsect] [/ Tutorial]
-
-[////////////////]
-[section:examples Examples]
-
-[section:fib Parallel Fibonacci]
-
-
-This is surely the worst implementation of the Fibonacci function. Anyway, here it is, as it is simple and shows the fork-join structure clearly. `Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)`, so the task decomposition is trivial.
-
-  int fib_task_region(int n)
-  {
-    using boost::experimental::parallel::task_region;
-    using boost::experimental::parallel::task_region_handle;
-  
-    if (n == 0) return 0;
-    if (n == 1) return 1;
-  
-    int n1;
-    int n2;
-  
-    task_region([&](task_region_handle& trh)
-        {
-          trh.run([&]
-              {
-                n1 = fib_task_region(n - 1);
-              });
-  
-          n2 = fib_task_region(n - 2);
-        });
-  
-    return n1 + n2;
-  }
-
-  int main()
-  {
-    for (int i = 0; i<10; ++i) {
-      std::cout << fib_task_region(i) << " ";
-    }
-    std::cout << std::endl;
-  }
-
-[endsect] [/ Fib]
-[section:fibex Parallel Fibonacci - Specific executor]
-
-The previous example make use of an implementation defined way to spawn the tasks. Often the user wants to master how the task must be spawned. There is an overload of `task_region` that accept an additional `Executor` parameter and a function that takes as parameter a `task_region_handle_gen<Executor>`. `task_region_handle_gen<Executor>` run uses this executor to spawn the tasks. 
-
-  template <class Ex>
-  int fib_task_region_gen( Ex& ex, int n)
-  {
-    using boost::experimental::parallel::task_region;
-    using boost::experimental::parallel::task_region_handle_gen;
-  
-    if (n == 0) return 0;
-    if (n == 1) return 1;
-  
-    int n1;
-    int n2;
-  
-    task_region(ex, [&](task_region_handle_gen<Ex>& trh) // (2)
-        {
-          trh.run([&]
-              {
-                n1 = fib_task_region(n - 1);
-              });
-  
-          n2 = fib_task_region(n - 2);
-        });
-  
-    return n1 + n2;
-  }
-
-  int main()
-  {
-    boost::basic_thread_pool tp; // (1)
-    for (int i = 0; i<10; ++i) {
-      std::cout << fib_task_region_gen(tp,i) << " ";
-    }
-    std::cout << std::endl;
-    return 0;
-  }
-
-
-The specific executor is declared in line (1) and it is used in line (2).
-
-[endsect] [/ Fib ex]
-
-
-
-
-[section:quick_sort Parallel Accumulate]
-
-
-[endsect] [/ Accumulate]
-
-[section:quick_sort Parallel Quick Sort]
-
-
-
-[endsect] [/ QuickSort]
-[endsect] [/ Examples]
-
-
-[////////////////////////]
-[section:rationale Design Rationale]
-
-
-[endsect] [/ Design Rationale]
-[endsect] [/ Fork-Join]
-
-[/////////////////////]
-[section:ref Reference -- EXPERIMENTAL]
-
-[/////////////////////////]
-[section:v1 Parallel V1]
-
-[section:exception_list Header `<experimental/exception_list.hpp>`]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v1
-  {
-  
-    class exception_list;
-
-  } // v1
-  } // parallel
-  } // experimental
-  } // boost
-
-
-[/////////////////////////]
-[section:exception_list Class `exception_list`]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v1
-  {
-  
-    class exception_list: public std::exception
-    {
-    public:
-      typedef 'implementation defined' const_iterator;
-  
-      ~exception_list() noexcept {}
-  
-      void add(exception_ptr const& e);
-      size_t size() const noexcept;
-      const_iterator begin() const noexcept;
-      const_iterator end() const noexcept;
-      const char* what() const noexcept;
-  
-    };
-
-  } // v1
-  } // parallel
-  } // experimental
-  } // boost
-
-
-[endsect] [/ exception_list]
-
-[endsect] [/ exception_list.hpp]
-
-[endsect] [/ Parallel V1]
-
-[////////////////////////////////////////////////////////////////////]
-[section:v2 Parallel V2]
-[////////////////////////////////////////////////////////////////////]
-[section:concepts Concepts]
-[////////////////////////////////////////////////////////////////////]
-[section:regionCallable Concept `Region_Callable`]
-
-[endsect] [/ Region_Callable]
-[////////////////////////////////////////////////////////////////////]
-[section:taskCallable Concept `Task_Callable`]
-
-
-[endsect] [/ Task_Callable]
-[////////////////////////////////////////////////////////////////////]
-[endsect] [/ Concepts]
-[////////////////////////////////////////////////////////////////////]
-[section:task_region Header `<experimental/task_region.hpp>`]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v2
-  {
-
-    class task_canceled_exception;
-  
-    template <class Executor>
-    class task_region_handle_gen;
-  
-    using default_executor = 'implementation defined';
-
-    class task_region_handle;
-  
-    template <typename Executor, typename F>
-      void task_region_final(Executor& ex, F&& f); 
-    template <typename F>
-      void task_region_final(F&& f);
-
-    template <typename Executor, typename F>
-      void task_region(Executor& ex, F&& f);
-    template <typename F>
-      void task_region(F&& f);
-
-  } // v2
-  } // parallel
-  } // experimental
-  } // boost
-
-
-[////////////////////////////////////////////////////////////////////]
-[section:task_canceled_exception Class `task_canceled_exception `]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v2
-  {
-  
-    class task_canceled_exception: public std::exception
-    {
-    public:
-      task_canceled_exception() noexcept;
-      task_canceled_exception(const task_canceled_exception&) noexcept;
-      task_canceled_exception& operator=(const task_canceled_exception&) noexcept;
-      virtual const char* what() const noexcept;
-    };
-
-  } // v2
-  } // parallel
-  } // experimental
-  } // boost
-
-[endsect] [/ task_canceled_exception]
-[////////////////////////////////////////////////////////////////////]
-[section:task_region_handle_gen Template Class `task_region_handle_gen<>`]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v2
-  {
-  
-    template <class Executor>
-    class task_region_handle_gen
-    {
-    protected:
-      task_region_handle_gen(Executor& ex);
-   
-      ~task_region_handle_gen(); 
-  
-    public:
-      task_region_handle_gen(const task_region_handle_gen&) = delete;
-      task_region_handle_gen& operator=(const task_region_handle_gen&) = delete;
-      task_region_handle_gen* operator&() const = delete;
-  
-      template<typename F>
-      void run(F&& f);
-  
-      void wait();
-    };
-
-  } // v2
-  } // parallel
-  } // experimental
-  } // boost
-
-[endsect] [/ task_region_handle_gen]
-[////////////////////////////////////////////////////////////////////]
-[section:default_executor Class `default_executor `]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v2
-  {
-  
-    using default_executor = 'implementation defined';
- 
-  } // v2
-  } // parallel
-  } // experimental
-  } // boost
-
-[endsect] [/ default_executor]
-[////////////////////////////////////////////////////////////////////]
-[section:task_region_handle Class `task_region_handle `]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v2
-  {
-  
-    class task_region_handle :
-      public task_region_handle_gen<default_executor>
-    {
-    protected:
-      task_region_handle();
-      task_region_handle(const task_region_handle&) = delete;
-      task_region_handle& operator=(const task_region_handle&) = delete;
-      task_region_handle* operator&() const = delete;
-  
-    };
-  
-  } // v2
-  } // parallel
-  } // experimental
-  } // boost
-
-[endsect] [/ task_region_handle]
-[////////////////////////////////////////////////////////////////////]
-[section:task_region_final Template Function `task_region_final `]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v2
-  { 
-  
-    template <typename Executor, typename F>
-      void task_region_final(Executor& ex, F&& f); 
-    template <typename F>
-      void task_region_final(F&& f);
-
-  } // v2
-  } // parallel
-  } // experimental
-  } // boost
-
-[endsect] [/ task_region_final]
-[////////////////////////////////////////////////////////////////////]
-[section:task_region Template Function `task_region `]
-
-  namespace boost
-  {
-  namespace experimental
-  {
-  namespace parallel
-  {
-  inline namespace v2
-  { 
-  
-    template <typename Executor, typename F>
-      void task_region(Executor& ex, F&& f);
-    template <typename F>
-      void task_region(F&& f);
-
-  } // v2
-  } // parallel
-  } // experimental
-  } // boost
-
-[endsect] [/ task_region]
-
-
-
-
-[endsect] [/ task_region.hpp]
-[endsect] [/ Parallel V2]
-[endsect] [/ Reference]
-
-[endsect] [/ Parallel]
--- a/doc/scoped_thread.qbk
+++ b/doc/scoped_thread.qbk
@@ -15,30 +15,28 @@
  struct detach;
  struct join_if_joinable;
  struct interrupt_and_join_if_joinable;
-  template <class CallableThread = join_if_joinable, class Thread = thread>
+  template <class CallableThread = join_if_joinable>
  class strict_scoped_thread;
-  template <class CallableThread = join_if_joinable, class Thread = thread>
+  template <class CallableThread = join_if_joinable>
  class scoped_thread;
-  template <class CallableThread, class Thread = thread>
-  void swap(scoped_thread<Callable, Thread>& lhs, scoped_threadCallable, Thread>& rhs) noexcept;
+  void swap(scoped_thread& lhs,scoped_thread& rhs) noexcept;

-[section:motivation Motivation]
+[section:motovation Motivation]
 Based on the scoped_thread class defined in C++ Concurrency in Action Boost.Thread defines a thread wrapper class that instead of calling terminate if the thread is joinable on destruction, call a specific action given as template parameter.

-While the scoped_thread class defined in C++ Concurrency in Action is closer to strict_scoped_thread class that doesn't allows any change in the wrapped thread, Boost.Thread provides a class scoped_thread that provides the same non-deprecated interface as __thread.
+While the scoped_thread class defined in C++ Concurrency in Action is closer to strict_scoped_thread class that doesn't allows any change in the wrapped thread, Boost.Thread provides a class scoped_thread that provides the same non-deprecated interface than __thread.

 [endsect]

 [section:tutorial Tutorial]

-Scoped Threads are wrappers around a thread that allows the user to state what to do at destruction time. One of the common uses is to join the thread at destruction time so this is the default behavior. This is the single difference respect to a thread. While thread call std::terminate() on the destructor if the thread is joinable, strict_scoped_thread<> or scoped_thread<> join the thread if joinable.
+Scoped Threads are wrappers around a thread that allows the user to state what to do at destruction time. One of the common uses is to join the thread at destruction time so this is the default behavior. This is the single difference respect to a thread. While thread call std::terminate() on the destructor is the thread is joinable, strict_scoped_thread<> or scoped_thread<> join the thread if joinable.

-The difference between strict_scoped_thread and scoped_thread is that the strict_scoped_thread hides completely the owned thread and so the user can do nothing with the owned thread other than the specific action given as parameter, while scoped_thread provide the same interface as __thread and forwards all the operations.   
+The difference between strict_scoped_thread and scoped_thread is that the strict_scoped_thread hides completely the owned thread and so the user can do nothing with the owned thread other than the specific action given as parameter, while scoped_thread provide the same interface than __thread and forwards all the operations.   

-  boost::strict_scoped_thread<> t1((boost::thread(f)));
-  //t1.detach(); // compile fails
-  boost::scoped_thread<> t2((boost::thread(f)));
-  t2.detach();
+  boost::strict_scoped_thread<> t1((boost::thread(F)));
+  boost::strict_scoped_thread<> t2((boost::thread(F)));
+  t2.interrupt();

 [endsect]

@@ -55,8 +53,7 @@ The difference between strict_scoped_thread and scoped_thread is that the strict

  struct detach
  {
-    template <class Thread>
-    void operator()(Thread& t)
+    void operator()(thread& t)
    {
      t.detach();
    }
@@ -66,8 +63,7 @@ The difference between strict_scoped_thread and scoped_thread is that the strict

  struct join_if_joinable
  {
-    template <class Thread>
-    void operator()(Thread& t)
+    void operator()(thread& t)
    {
      if (t.joinable())
      {
@@ -82,8 +78,7 @@ The difference between strict_scoped_thread and scoped_thread is that the strict

  struct interrupt_and_join_if_joinable
  {
-    template <class Thread>
-    void operator()(Thread& t)
+    void operator()(thread& t)
    {
      t.interrupt();
      if (t.joinable())
@@ -100,7 +95,7 @@ The difference between strict_scoped_thread and scoped_thread is that the strict

  // #include <boost/thread/scoped_thread.hpp>

-  template <class CallableThread = join_if_joinable, class Thread = ::boost::thread>
+  template <class CallableThread = join_if_joinable>
  class strict_scoped_thread
  {
    thread t_; // for exposition purposes only
@@ -109,32 +104,30 @@ The difference between strict_scoped_thread and scoped_thread is that the strict
    strict_scoped_thread(strict_scoped_thread const&) = delete;
    strict_scoped_thread& operator=(strict_scoped_thread const&) = delete;

-    explicit strict_scoped_thread(Thread&& t) noexcept;
-    template <typename F&&, typename ...Args>
-    explicit strict_scoped_thread(F&&, Args&&...);
+    explicit strict_scoped_thread(thread&& t) noexcept;

    ~strict_scoped_thread();

  };


-RAII __thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.
+RAI __thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.

 CallableThread: A callable `void(thread&)`.

 The default is a `join_if_joinable`.


-Thread destructor terminates the program if the __thread is joinable.
-This wrapper can be used to join the thread before destroying it.
+`std/boost::thread` destructor terminates the program if the __thread is not joinable.
+This wrapper can be used to join the thread before destroying it seems a natural need.

 [heading Example]

  boost::strict_scoped_thread<> t((boost::thread(F)));

-[section:default_constructor Constructor from a __thread]
+[section:default_constructor Default Constructor]

-    explicit strict_scoped_thread(Thread&& t) noexcept;
+    explicit strict_scoped_thread(thread&& t) noexcept;

 [variablelist

@@ -146,24 +139,6 @@ This wrapper can be used to join the thread before destroying it.

 [endsect]

-
-[section:call_constructor Move Constructor from a Callable]
-
-        template <typename F&&, typename ...Args>
-        explicit strict_scoped_thread(F&&, Args&&...);
-
-[variablelist
-
-[[Effects:] [Construct an internal thread in place.]]
-
-[[Postconditions:] [`*this.t_` refers to the newly created thread of execution and `this->get_id()!=thread::id()`.]]
-
-[[Throws:] [Any exception the thread construction can throw.]]
-
-]
-
-[endsect]
-
 [section:destructor Destructor]

    ~strict_scoped_thread();
@@ -174,6 +149,7 @@ This wrapper can be used to join the thread before destroying it.

 [[Throws:] [Nothing: The `CallableThread()(t_)` should not throw when joining the thread as the scoped variable is on a scope outside the thread function.]]

+
 ]

 [endsect]
@@ -184,7 +160,6 @@ This wrapper can be used to join the thread before destroying it.

    #include <boost/thread/scoped_thread.hpp>

-    template <class CallableThread, class Thread = thread>
    class scoped_thread
    {
      thread t_; // for exposition purposes only
@@ -194,8 +169,6 @@ This wrapper can be used to join the thread before destroying it.
        scoped_thread& operator=(const scoped_thread&) = delete;

        explicit scoped_thread(thread&& th) noexcept;
-        template <typename F&&, typename ...Args>
-        explicit scoped_thread(F&&, Args&&...);

        ~scoped_thread();

@@ -221,7 +194,6 @@ This wrapper can be used to join the thread before destroying it.
        void detach();

        static unsigned hardware_concurrency() noexcept;
-        static unsigned physical_concurrency() noexcept;

        typedef thread::native_handle_type native_handle_type;
        native_handle_type native_handle();
@@ -234,17 +206,16 @@ This wrapper can be used to join the thread before destroying it.

    };

-    template <class CallableThread, class Thread = thread>
-    void swap(scoped_thread<CallableThread,Thread>& lhs,scoped_thread<CallableThread,Thread>& rhs) noexcept;
+    void swap(scoped_thread& lhs,scoped_thread& rhs) noexcept;


-RAII __thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.
+RAI __thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.

 CallableThread: A callable void(thread&).
 The default is join_if_joinable.

-Thread destructor terminates the program if the thread is joinable.
-This wrapper can be used to join the thread before destroying it. 
+thread std::thread destructor terminates the program if the thread is not joinable.
+Having a wrapper that can join the thread before destroying it seems a natural need.

 Remark: `scoped_thread` is not a __thread as __thread is not designed to be derived from as a polymorphic type.

@@ -296,14 +267,16 @@ same non-deprecated interface with the exception of the construction.
 [variablelist

 [[Effects:] [Transfers ownership of the scoped_thread managed by `other` (if
-any) to `*this` after having called to `CallableThread()(t_)`. 
+any) to `*this`. 

+- if defined `BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE`: If there was a `scoped_thread` previously associated with `*this` then that `scoped_thread` is detached, DEPRECATED
+
+- if defined `BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE`: If the `scoped_thread` is joinable calls to std::terminate.
 ]]

 [[Postconditions:] [`other->get_id()==thread::id()` and `get_id()` returns the value of `other.get_id()` prior to the assignment.]]

-[[Throws:] [Nothing: The `CallableThread()(t_)` should not throw when joining the thread as the scoped variable is on a scope outside the thread function.]]
-
+[[Throws:] [Nothing]]

 ]

@@ -315,28 +288,11 @@ any) to `*this` after having called to `CallableThread()(t_)`.

 [variablelist

-[[Effects:] [Transfers ownership of the thread managed by `other` (if any) to the newly constructed scoped_thread instance.]]
-
-[[Postconditions:] [other.get_id()==thread::id() and get_id() returns the value of other.get_id() prior to the construction.]]
-
-[[Throws:] [Nothing]]
-
-]
-
-[endsect]
-
-[section:call_constructor Move Constructor from a Callable]
-
-        template <typename F&&, typename ...Args>
-        explicit scoped_thread(F&&, Args&&...);
-
-[variablelist
-
-[[Effects:] [Construct an internal thread in place.]]
+[[Effects:] [move the thread to own `t_`.]]

 [[Postconditions:] [`*this.t_` refers to the newly created thread of execution and `this->get_id()!=thread::id()`.]]

-[[Throws:] [Any exception the thread construction can throw.]]
+[[Throws:] [Nothing]]

 ]

@@ -463,20 +419,6 @@ any) to `*this` after having called to `CallableThread()(t_)`.

 [endsect]

-
-[section:physical_concurrency Static member function `physical_concurrency()`]
-
-    unsigned physical_concurrency() noexecpt;
-
-[variablelist
-
-[[Effects:] [Equivalent to return `thread::physical_concurrency()`.]]
-
-]
-
-[endsect]
-
-
 [section:nativehandle Member function `native_handle()`]

    typedef thread::native_handle_type native_handle_type;
@@ -509,8 +451,7 @@ any) to `*this` after having called to `CallableThread()(t_)`.

    #include <boost/thread/scoped_thread.hpp>

-    template <class CallableThread, class Thread = thread>
-    void swap(scoped_thread<Callable, Thread>& lhs, scoped_threadCallable, Thread>& rhs) noexcept;
+    void swap(scoped_thread& lhs,scoped_thread& rhs) noexcept;

 [variablelist

--- a/doc/shared_mutex_ref.qbk
+++ b/doc/shared_mutex_ref.qbk
@@ -5,7 +5,7 @@
  http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:shared_mutex Class `shared_mutex` -- C++14]
+[section:shared_mutex Class `shared_mutex` -- EXTENSION]

    #include <boost/thread/shared_mutex.hpp>

@@ -36,18 +36,18 @@

    #if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0
        // use upgrade_mutex instead.
-        void lock_upgrade(); // EXTENSION
-        void unlock_upgrade(); // EXTENSION
+        void lock_upgrade();
+        void unlock_upgrade();

-        void unlock_upgrade_and_lock(); // EXTENSION
-        void unlock_and_lock_upgrade(); // EXTENSION
-        void unlock_and_lock_shared(); // EXTENSION
-        void unlock_upgrade_and_lock_shared(); // EXTENSION
+        void unlock_upgrade_and_lock();
+        void unlock_and_lock_upgrade();
+        void unlock_and_lock_shared();
+        void unlock_upgrade_and_lock_shared();
    #endif

    #if defined BOOST_THREAD_USES_DATETIME
-        bool timed_lock_shared(system_time const& timeout); // DEPRECATED
-        bool timed_lock(system_time const& timeout); // DEPRECATED
+        bool timed_lock_shared(system_time const& timeout);
+        bool timed_lock(system_time const& timeout);
    #endif

    };
--- a/doc/sync_queues_ref.qbk
+++ b/doc/sync_queues_ref.qbk
--- a/doc/sync_streams.qbk
+++ b/doc/sync_streams.qbk
@@ -1,193 +0,0 @@
-[/
- / Copyright (c) 2013 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)
- /]
-
-
-[section:ext_locked_streams Externally Locked Streams - EXPERIMENTAL]
-
-[warning These features are experimental and subject to change in future versions. There are not too much tests yet, so it is possible that you can find out some trivial bugs :(] 
-
-[note These features are based on the [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3535.html [*N3535 - C++ Streams Mutex]] C++1y proposal, even if the library proposes al alternative interface.]
-
-[section:tutorial Tutorial]
-
-[endsect] [/tutorial]
-
-[/////////////////////]
-[section:ref Reference]
-
-  #include <boost/thread/externally_locked_stream.hpp>
-  namespace boost
-  {
-    template <typename Stream, typename RecursiveMutex=recursive_mutex>
-    class externally_locked_stream;
-    template <class Stream, typename RecursiveMutex=recursive_mutex>
-    class stream_guard;
-    template <typename Stream, typename RecursiveMutex>
-    struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type  {};
-
-    // Stream-like operators
-    template <typename Stream, typename RecursiveMutex, typename T>
-    const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg);
-    template <typename Stream, typename RecursiveMutex>
-    const stream_guard<Stream, RecursiveMutex>& 
-    operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&));
-    template <typename Stream, typename RecursiveMutex, typename T>
-    const stream_guard<Stream, RecursiveMutex>& 
-    operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg);
-    template <typename Stream, typename RecursiveMutex, typename T>
-    stream_guard<Stream, RecursiveMutex> 
-    operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg);
-    template <typename Stream, typename RecursiveMutex>
-    stream_guard<Stream, RecursiveMutex> 
-    operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&));
-    template <typename Stream, typename RecursiveMutex, typename T>
-    stream_guard<Stream, RecursiveMutex> 
-    operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg);
-  }
-
-[/////////////////////////////////////////]
-[section:stream_guard Class `stream_guard`]
-  
-  #include <boost/thread/externally_locked_stream.hpp>
-  namespace boost
-  { 
-    template <class Stream, typename RecursiveMutex=recursive_mutex>
-    class stream_guard
-    {
-    public:
-      typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
-  
-      // Constructors, Assignment and Destructors
-      stream_guard(stream_guard const&) = delete;
-      stream_guard& operator=(stream_guard const&) = delete;
-      stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx);
-      stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t);
-      stream_guard(stream_guard&& rhs);
-      ~stream_guard();
-
-      // Observers  
-      bool owns_lock(mutex_type const* l) const BOOST_NOEXCEPT;
-      Stream& get() const;
-      Stream& bypass() const;
-
-    };
-  }
-
-`stream_guard` is a model of __StrictLock.
-
-[//////////////////////////////////////////////////]
-[section:constructor `stream_guard(mutex_type & m)`]
-
-[variablelist
-
-[[Effects:] [Stores a reference to `m`. Invokes [lock_ref_link `m.lock()`].]]
-
-[[Throws:] [Any exception thrown by the call to [lock_ref_link `m.lock()`].]]
-
-]
-
-[endsect]
-[////////////////////////////////////////////////////////////////////////////]
-[section:constructor_adopt `stream_guard(mutex_type & m,boost::adopt_lock_t)`]
-
-[variablelist
-
-[[Precondition:] [The current thread owns a lock on `m` equivalent to one
-obtained by a call to [lock_ref_link `m.lock()`].]]
-
-[[Effects:] [Stores a reference to `m`. Takes ownership of the lock state of
-`m`.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[//////////////////////////////////////////////////////////]
-[section:move_constructor `stream_guard(stream_guard && m)`]
-
-
-[variablelist
-
-[[Effects:] [Stores a reference to `m`. Invokes [lock_ref_link `m.lock()`].]]
-
-[[Throws:] [Any exception thrown by the call to [lock_ref_link `m.lock()`].]]
-
-]
-
-[endsect]
-[////////////////////////////////////]
-[section:destructor `~stream_guard()`]
-
-[variablelist
-
-[[Effects:] [Invokes [unlock_ref_link `m.unlock()`] on the __lockable_concept_type__
-object passed to the constructor.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-[endsect]
-[//////////////////////////////////////////////////////////////////]
-[section:externally_locked_stream Class `externally_locked_stream `]
-
-  #include <boost/thread/externally_locked_stream.hpp>
-  namespace boost
-  {
-    template <typename Stream, typename RecursiveMutex>
-    class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
-    {
-    public:
-      // Constructors, Assignment and Destructors
-      externally_locked_stream(externally_locked_stream const&) = delete;
-      externally_locked_stream& operator=(externally_locked_stream const&) = delete;
-      externally_locked_stream(Stream& stream, RecursiveMutex& mtx);
-  
-      // Modifiers  
-      stream_guard<Stream, RecursiveMutex> hold();
-
-    };
-  }
-
-`externally_locked_stream` cloaks a reference to a stream of type `Stream`, and actually
-provides full access to that object through the `get` member functions, provided you
-pass a reference to a strict lock object.
-
-
-[////////////////////////////////////////////////////////////////////////]
-[section:constructor `externally_locked_stream(Stream&, RecursiveMutex&)`]
-
-[variablelist
-
-[[Effects:] [Constructs an externally locked object storing the cloaked reference object and its locking mutex.]]
-
-]
-
-[endsect]
-
-[/////////////////////]
-[section:hold `hold()`]
-
-[variablelist
-
-[[Returns:] [A stream_guard which will hold the mutex during it lifetime .]]
-
-]
-
-[endsect]
-
-
-
-[endsect]
-
-
-[endsect] [/ref]
-
-[endsect] [/Externally Locked Streams]
--- a/doc/sync_tutorial.qbk
+++ b/doc/sync_tutorial.qbk
@@ -7,9 +7,7 @@

 [section:tutorial Tutorial]

-
-[@http://web.archive.org/web/20140531071228/http://home.roadrunner.com/~hinnant/mutexes/locking.html Handling mutexes in C++] is an excellent tutorial. You need just replace std and ting by boost.
-
+[@http://home.roadrunner.com/~hinnant/mutexes/locking.html Handling mutexes in C++] is an excellent tutorial. You need just replace std and ting by boost.

 [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2406.html Mutex, Lock, Condition Variable Rationale] adds rationale for the design decisions made for mutexes, locks and condition variables.

@@ -22,44 +20,24 @@ In addition to the C++11 standard locks, Boost.Thread provides other locks and s

 [section:with Executing Around a Function]

-In particular, the library provides a way to lock around the execution of a function.
+In particular, the library provides some lock factories.

-  template <class Lockable, class Function, class... Args>
-  auto with_lock_guard(
-      Lockable& m,
-      Function&& func,
-      Args&&... args
-  ) -> decltype(func(boost::forward<Args>(args)...)) {
-    boost::lock_guard<Lockable> lock(m);
-    return func(boost::forward<Args>(args)...);
+  template <class Lockable, class Function>
+  auto with_lock_guard(Lockable& m, Function f) -> decltype(fn())
+  {
+    auto&& _ = boost::make_lock_guard(f);
+    f();
  }

-that can be used with regular functions:

-  int func(int, int&);
-  //...
-  boost::mutex m;
-  int a;
-  int result = boost::with_lock_guard(m, func, 1, boost::ref(a));
+that can be used as

-with boost::bind:
+  int i = with_lock_guard(mtx, {}() -> bool 
+  { 
+    // access the protected state 
+    return true;
+  });

-  int result = boost::with_lock_guard(
-      m, boost::bind(func, 2, boost::ref(a))
-  );
-
-or with lambda expression:
-
-  int a;
-  int result = boost::with_lock_guard(
-      m,
-      [&a](int x) {
-        // this scope is protected by mutex m
-        a = 3;
-        return x + 4;
-      },
-      5
-  );

 [endsect] [/ With]

--- a/doc/synchronized_value.qbk
+++ b/doc/synchronized_value.qbk
@@ -1,147 +0,0 @@
-[/
- / Copyright (c) 2013 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)
- /]
-
-
-[section:synchronized_valuesxxx Synchronized Values - EXPERIMENTAL]
-
-[warning These features are experimental and subject to change in future versions. There are not too much tests yet, so it is possible that you can find out some trivial bugs :(] 
-
-[section:tutorial Tutorial]
-
-
-[note This tutorial is an adaptation of the paper of Anthony Williams  "Enforcing Correct Mutex Usage with Synchronized Values" to the Boost library.]
-
-[section The Problem with Mutexes]
-
-The key problem with protecting shared data with a mutex is that there is no easy way to associate the mutex with the data. It is thus relatively easy to accidentally write code that fails to lock the right mutex - or even locks the wrong mutex - and the compiler will not help you.
-
-
-  std::mutex m1;
-  int value1;
-  std::mutex m2;
-  int value2;
- 
-  int readValue1()
-  {
-    boost::lock_guard<boost::mutex> lk(m1);
-    return value1;
-  }
-  int readValue2()
-  {
-    boost::lock_guard<boost::mutex> lk(m1); // oops: wrong mutex
-    return value2;
-  }
-
-Moreover, managing the mutex lock also clutters the source code, making it harder to see what is really going on.
-
-The use of synchronized_value solves both these problems - the mutex is intimately tied to the value, so you cannot access it without a lock, and yet access semantics are still straightforward. For simple accesses, synchronized_value behaves like a pointer-to-T; for example: 
-
-
-  boost::synchronized_value<std::string> value3;
-  std::string readValue3()
-  {
-    return *value3;
-  }
-  void setValue3(std::string const& newVal)
-  {
-    *value3=newVal;
-  }
-  void appendToValue3(std::string const& extra)
-  {
-    value3->append(extra);
-  }
-
-Both forms of pointer dereference return a proxy object rather than a real reference, to ensure that the lock on the mutex is held across the assignment or method call, but this is transparent to the user. 
-
-[endsect] [/The Problem with Mutexes]
-
-[section Beyond Simple Accesses]
-
-The pointer-like semantics work very well for simple accesses such as assignment and calls to member functions. However, sometimes you need to perform an operation that requires multiple accesses under protection of the same lock, and that's what the synchronize() method provides.
-
-By calling synchronize() you obtain a strict_lock_ptr object that holds a lock on the mutex protecting the data, and which can be used to access the protected data. The lock is held until the strict_lock_ptr object is destroyed, so you can safely perform multi-part operations. The strict_lock_ptr object also acts as a pointer-to-T, just like synchronized_value does, but this time the lock is already held. For example, the following function adds a trailing slash to a path held in a synchronized_value. The use of the strict_lock_ptr object ensures that the string hasn't changed in between the query and the update.
-
-  void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
-  {
-    boost::strict_lock_ptr<std::string> u=path.synchronize();
-  
-    if(u->empty() || (*u->rbegin()!='/'))
-    {
-      *u+='/';
-    }
-  }
-
-[endsect] [/Beyond Simple Accesses]
-
-[section Operations Across Multiple Objects]
-
-Though synchronized_value works very well for protecting a single object of type T, nothing that we've seen so far solves the problem of operations that require atomic access to multiple objects unless those objects can be combined within a single structure protected by a single mutex.
-
-One way to protect access to two synchronized_value objects is to construct a strict_lock_ptr for each object and use those to access the respective protected values; for instance: 
-
-  synchronized_value<std::queue<MessageType> > q1,q2;
-  void transferMessage()
-  {
-    strict_lock_ptr<std::queue<MessageType> > u1 = q1.synchronize();
-    strict_lock_ptr<std::queue<MessageType> > u2 = q2.synchronize();
- 
-    if(!u1->empty())
-    {
-      u2->push_back(u1->front());
-      u1->pop_front();
-    }
-  }
-
-This works well in some scenarios, but not all -- if the same two objects are updated together in different sections of code then you need to take care to ensure that the strict_lock_ptr objects are constructed in the same sequence in all cases, otherwise you have the potential for deadlock. This is just the same as when acquiring any two mutexes.
-
-In order to be able to use the dead-lock free lock algorithms we need to use instead unique_lock_ptr, which is Lockable.
-
-  synchronized_value<std::queue<MessageType> > q1,q2;
-  void transferMessage()
-  {
-    unique_lock_ptr<std::queue<MessageType> > u1 = q1.unique_synchronize(boost::defer_lock);
-    unique_lock_ptr<std::queue<MessageType> > u2 = q2.unique_synchronize(boost::defer_lock);
-    boost::lock(u1,u2); // dead-lock free algorithm
-
-    if(!u1->empty())
-    {
-      u2->push_back(u1->front());
-      u1->pop_front();
-    }
-  }
-
-While the preceding takes care of dead-lock, the access to the synchronized_value via unique_lock_ptr requires a lock that is not forced by the interface.
-An alternative on compilers providing a standard library that supports movable std::tuple is to use the free synchronize function, which will lock all the mutexes associated to the synchronized values and return a tuple os strict_lock_ptr.
-
-  synchronized_value<std::queue<MessageType> > q1,q2;
-  void transferMessage()
-  {
-    auto lks = synchronize(u1,u2); // dead-lock free algorithm
-
-    if(!std::get<1>(lks)->empty())
-    {
-      std::get<2>(lks)->push_back(u1->front());
-      std::get<1>(lks)->pop_front();
-    }
-  }
-  
-
-[endsect] [/Operations Across Multiple Objects]
-
-[section Value semantics]
-
-synchronized_value has value semantics even if the syntax lets is close to a pointer (this is just because we are unable to define smart references).
-
-[endsect] [/Value semantics]
-
-
-[endsect] [/tutorial]
-
-[include synchronized_value_ref.qbk]
-
-[endsect] [/Synchronized values]
-
--- a/doc/synchronized_value_ref.qbk
+++ b/doc/synchronized_value_ref.qbk
@@ -1,415 +0,0 @@
-[/
- / Copyright (c) 2013 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)
- /]
-
-[section:synchronized_value_ref Reference ]
-
-
-  #include <boost/thread/synchronized_value.hpp>
-  namespace boost 
-  {
-
-    template<typename T, typename Lockable = mutex>
-    class synchronized_value;
-
-    // Specialized swap algorithm
-    template <typename T, typename L>
-    void swap(synchronized_value<T,L> & lhs, synchronized_value<T,L> & rhs);
-    template <typename T, typename L>
-    void swap(synchronized_value<T,L> & lhs, T & rhs);
-    template <typename T, typename L>
-    void swap(T & lhs, synchronized_value<T,L> & rhs);
-
-    // Hash support
-    template<typename T, typename L>
-    struct hash<synchronized_value<T,L> >;
-
-    // Comparison
-    template <typename T, typename L>
-    bool operator==(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs)
-    template <typename T, typename L>
-    bool operator!=(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs)
-    template <typename T, typename L>
-    bool operator<(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs)
-    template <typename T, typename L>
-    bool operator<=(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs)
-    template <typename T, typename L>
-    bool operator>(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs)
-    template <typename T, typename L>
-    bool operator>=(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs)
-
-    // Comparison with T
-    template <typename T, typename L>
-    bool operator==(T const& lhs, synchronized_value<T,L> const&rhs);
-    template <typename T, typename L>
-    bool operator!=(T const& lhs, synchronized_value<T,L> const&rhs);
-    template <typename T, typename L>
-    bool operator<(T const& lhs, synchronized_value<T,L> const&rhs);
-    template <typename T, typename L>
-    bool operator<=(T const& lhs, synchronized_value<T,L> const&rhs);
-    template <typename T, typename L>
-    bool operator>(T const& lhs, synchronized_value<T,L> const&rhs);
-    template <typename T, typename L>
-    bool operator>=(T const& lhs, synchronized_value<T,L> const&rhs);
-
-    template <typename T, typename L>
-    bool operator==(synchronized_value<T,L> const& lhs, T const& rhs);
-    template <typename T, typename L>
-    bool operator!=(synchronized_value<T,L> const& lhs, T const& rhs);
-    template <typename T, typename L>
-    bool operator<(synchronized_value<T,L> const& lhs, T const& rhs);
-    template <typename T, typename L>
-    bool operator<=(synchronized_value<T,L> const& lhs, T const& rhs);
-    template <typename T, typename L>
-    bool operator>(synchronized_value<T,L> const& lhs, T const& rhs);
-    template <typename T, typename L>
-    bool operator>=(synchronized_value<T,L> const& lhs, T const& rhs);
-
-  #if ! defined(BOOST_THREAD_NO_SYNCHRONIZE)
-    template <typename ...SV>
-    std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> synchronize(SV& ...sv);
-  #endif
-  }
-
-[section:synchronized_value Class `synchronized_value`]
-
-  #include <boost/thread/synchronized_value.hpp>
-
-  namespace boost 
-  {
-
-    template<typename T, typename Lockable = mutex>
-    class synchronized_value
-    {
-    public:
-      typedef T value_type;
-      typedef Lockable mutex_type;
-
-      synchronized_value() noexcept(is_nothrow_default_constructible<T>::value);
-      synchronized_value(T const& other) noexcept(is_nothrow_copy_constructible<T>::value);
-      synchronized_value(T&& other) noexcept(is_nothrow_move_constructible<T>::value);
-      synchronized_value(synchronized_value const& rhs);
-      synchronized_value(synchronized_value&& other);
-
-      // mutation
-      synchronized_value& operator=(synchronized_value const& rhs);
-      synchronized_value& operator=(value_type const& val);
-      void swap(synchronized_value & rhs);
-      void swap(value_type & rhs);
-
-      //observers
-      T get() const;
-    #if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-      explicit operator T() const;
-    #endif
-
-      strict_lock_ptr<T,Lockable> operator->();
-      const_strict_lock_ptr<T,Lockable> operator->() const;
-      strict_lock_ptr<T,Lockable> synchronize();
-      const_strict_lock_ptr<T,Lockable> synchronize() const;
-
-      deref_value operator*();;
-      const_deref_value operator*() const;
-
-    private:
-      T value_; // for exposition only
-      mutable mutex_type mtx_;  // for exposition only
-    };
-  }
-
-[variablelist
-
-[[Requires:] [`Lockable` is `Lockable`.]]
-
-]
-
-
-[section:constructor `synchronized_value()`]
-
-      synchronized_value() noexcept(is_nothrow_default_constructible<T>::value);
-
-[variablelist
-
-[[Requires:] [`T` is `DefaultConstructible`.]]
-[[Effects:] [Default constructs the cloaked value_type]]
-
-[[Throws:] [Any exception thrown by `value_type()`.]]
-
-]
-
-[endsect]
-
-
-[section:constructor_vt `synchronized_value(T const&)`]
-
-      synchronized_value(T const& other) noexcept(is_nothrow_copy_constructible<T>::value);
-
-[variablelist
-
-[[Requires:] [`T` is `CopyConstructible`.]]
-[[Effects:] [Copy constructs the cloaked value_type using the parameter `other`]]
-
-[[Throws:] [Any exception thrown by `value_type(other)`.]]
-
-]
-
-[endsect]
-
-[section:copy_cons `synchronized_value(synchronized_value const&)`]
-
-      synchronized_value(synchronized_value const& rhs);
-
-[variablelist
-
-[[Requires:] [`T` is `DefaultConstructible` and `Assignable`.]]
-[[Effects:] [Assigns the value on a scope protected by the mutex of the rhs. The mutex is not copied.]]
-
-[[Throws:] [Any exception thrown by `value_type()` or `value_type& operator=(value_type&)` or `mtx_.lock()`.]]
-
-]
-
-[endsect]
-
-[section:move_vt `synchronized_value(T&&)`]
-
-      synchronized_value(T&& other) noexcept(is_nothrow_move_constructible<T>::value);
-
-[variablelist
-
-[[Requires:] [`T` is `MoveConstructible `.]]
-[[Effects:] [Move constructs the cloaked value_type]]
-
-[[Throws:] [Any exception thrown by `value_type(value_type&&)`.]]
-
-]
-
-[endsect]
-
-[section:move `synchronized_value(synchronized_value&&)`]
-
-      synchronized_value(synchronized_value&& other);
-
-[variablelist
-
-[[Requires:] [`T` is `MoveConstructible `.]]
-[[Effects:] [Move constructs the cloaked value_type]]
-
-[[Throws:] [Any exception thrown by `value_type(value_type&&)` or `mtx_.lock()`.]]
-
-]
-
-[endsect]
-
-[section:assign `operator=(synchronized_value const&)`]
-
-      synchronized_value& operator=(synchronized_value const& rhs);
-
-[variablelist
-
-[[Requires:] [`T` is `Assignable`.]]
-[[Effects:] [Copies the underlying value on a scope protected by the two mutexes. The mutex is not copied. The locks are acquired avoiding deadlock. For example, there is no problem if one thread assigns `a = b` and the other assigns `b = a`.]]
-[[Return:] [`*this`]]
-
-[[Throws:] [Any exception thrown by `value_type& operator(value_type const&)` or `mtx_.lock()`.]]
-
-]
-
-[endsect]
-[section:assign_vt `operator=(T const&)`]
-
-      synchronized_value& operator=(value_type const& val);
-
-[variablelist
-
-[[Requires:] [`T` is `Assignable`.]]
-[[Effects:] [Copies the value on a scope protected by the mutex.]]
-[[Return:] [`*this`]]
-
-[[Throws:] [Any exception thrown by `value_type& operator(value_type const&)` or `mtx_.lock()`.]]
-
-]
-
-[endsect]
-
-[section:get `get() const`]
-
-      T get() const;
-
-[variablelist
-
-[[Requires:] [`T` is `CopyConstructible`.]]
-[[Return:] [`A copy of the protected value obtained on a scope protected by the mutex.`]]
-
-[[Throws:] [Any exception thrown by `value_type(value_type const&)` or `mtx_.lock()`.]]
-
-]
-
-[endsect]
-
-
-[section:T `operator T() const`]
-
-    #if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-      explicit operator T() const;
-    #endif
-
-[variablelist
-
-[[Requires:] [`T` is `CopyConstructible`.]]
-[[Return:] [`A copy of the protected value obtained on a scope protected by the mutex.`]]
-
-[[Throws:] [Any exception thrown by `value_type(value_type const&)` or `mtx_.lock()`.]]
-
-]
-
-[endsect]
-
-[section:swap `swap(synchronized_value&)`]
-
-      void swap(synchronized_value & rhs);
-
-[variablelist
-
-[[Requires:] [`T` is `Assignable`.]]
-[[Effects:] [Swaps the data on a scope protected by both mutex. Both mutex are acquired to avoid dead-lock. The mutexes are not swapped.]]
-
-[[Throws:] [Any exception thrown by `swap(value_, rhs.value)` or `mtx_.lock()` or `rhs_.mtx_.lock()`.]]
-
-]
-
-[endsect]
-
-[section:swap_vt `swap(synchronized_value&)`]
-
-      void swap(value_type & rhs);
-
-[variablelist
-
-[[Requires:] [`T` is `Swapable`.]]
-[[Effects:] [Swaps the data on a scope protected by both mutex. Both mutex are acquired to avoid dead-lock. The mutexes are not swapped.]]
-
-[[Throws:] [Any exception thrown by `swap(value_, rhs)` or `mtx_.lock()`.]]
-
-]
-
-[endsect]
-[section:indir `operator->()`]
-
-      strict_lock_ptr<T,Lockable> operator->();
-
-
-Essentially calling a method `obj->foo(x, y, z)` calls the method `foo(x, y, z)` inside a critical section as long-lived as the call itself.
-
-[variablelist
-
-[[Return:] [`A strict_lock_ptr<>.`]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[section:indir_const `operator->() const`]
-
-      const_strict_lock_ptr<T,Lockable> operator->() const;
-
-
-If the `synchronized_value` object involved is const-qualified, then you'll only be able to call const methods
-through `operator->`. So, for example, `vec->push_back("xyz")` won't work if `vec` were const-qualified.
-The locking mechanism capitalizes on the assumption that const methods don't modify their underlying data.
-
-[variablelist
-
-[[Return:] [`A const_strict_lock_ptr <>.`]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[section:synchronize `synchronize()`]
-
-    strict_lock_ptr<T,Lockable> synchronize();
-
-The synchronize() factory make easier to lock on a scope. As discussed, `operator->` can only lock over the duration of a call, so it is insufficient for complex operations. With `synchronize()` you get to lock the object in a scoped and to directly access the object inside that scope.
-
-[*Example:]
-
-  void fun(synchronized_value<vector<int>> & vec) {
-    auto vec2=vec.synchronize();
-    vec2.push_back(42);
-    assert(vec2.back() == 42);
-  }
-
-[variablelist
-
-[[Return:] [`A strict_lock_ptr <>.`]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[section:synchronize_const `synchronize() const`]
-
-    const_strict_lock_ptr<T,Lockable> synchronize() const;
-
-[variablelist
-
-[[Return:] [`A const_strict_lock_ptr <>.`]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-[section:deref `operator*()`]
-
-      deref_value operator*();;
-
-[variablelist
-
-[[Return:] [`A an instance of a class that locks the mutex on construction and unlocks it on destruction and provides implicit conversion to a reference to the protected value.`]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-[section:deref_const `operator*() const`]
-
-      const_deref_value operator*() const;
-
-
-[variablelist
-
-[[Return:] [`A an instance of a class that locks the mutex on construction and unlocks it on destruction and provides implicit conversion to a constant reference to the protected value.`]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
-
-
-
-[endsect]
-[section:synchronize Non-Member Function `synchronize`]
-
-  #include <boost/thread/synchronized_value.hpp>
-  namespace boost 
-  {
-  #if ! defined(BOOST_THREAD_NO_SYNCHRONIZE)
-    template <typename ...SV>
-    std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> synchronize(SV& ...sv);
-  #endif
-  }
-
-[endsect]
-[endsect]
-
--- a/doc/thread.qbk
+++ b/doc/thread.qbk
@@ -8,10 +8,10 @@

 [library Thread
    [quickbook 1.5]
-    [version 4.7.2]
+    [version 4.0.0]
    [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
    [copyright 2007-11 Anthony Williams]
-    [copyright 2011-16 Vicente J. Botet Escriba]
+    [copyright 2011-12 Vicente J. Botet Escriba]
    [purpose C++ Library for launching threads and synchronizing data between them]
    [category text]
    [license
@@ -203,7 +203,6 @@
 [def __thread_resource_error__ `boost::thread_resource_error`]
 [def __thread_interrupted__ `boost::thread_interrupted`]
 [def __barrier__ [link thread.synchronization.barriers.barrier `boost::barrier`]]
-[def __latch__   [link thread.synchronization.latches.latch `latch`]]

 [template cond_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.wait [link_text]]]
 [def __cond_wait__ [cond_wait_link `wait()`]]
@@ -239,21 +238,11 @@
 [include condition_variables.qbk]
 [include once.qbk]
 [include barrier.qbk]
-[include latch.qbk]
-[include async_executors.qbk]
 [include futures.qbk]
 [endsect]

 [include tss.qbk]

-[section:sds Synchronized Data Structures]
-[include synchronized_value.qbk]
-[include sync_queues_ref.qbk]
-[/include sync_streams.qbk]
-[endsect]
-
-[include parallel.qbk]
-
 [include time.qbk]

 [include emulations.qbk]
--- a/doc/thread_ref.qbk
+++ b/doc/thread_ref.qbk
@@ -21,18 +21,12 @@
    {
      thread::id get_id() noexcept;
      template<typename TimeDuration>
-      void yield() noexcept;
+      void yield() noexcept; // DEPRECATED
      template <class Clock, class Duration>
      void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
      template <class Rep, class Period>
      void sleep_for(const chrono::duration<Rep, Period>& rel_time);
-      namespace no_interruption_point  // EXTENSION
-      {
-      	template <class Clock, class Duration>
-      	void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
-      	template <class Rep, class Period>
-      	void sleep_for(const chrono::duration<Rep, Period>& rel_time);
-      }
+
      template<typename Callable>
      void at_thread_exit(Callable func); // EXTENSION

@@ -125,7 +119,7 @@ the user to set the platform specific attributes. Boost.Thread stay in the middl
 thread::attributes which allows to set at least in a portable way the stack size as follows:

  boost::thread::attributes attrs;
-  attrs.set_stack_size(4096*10);
+  attrs.set_size(4096*10);
  boost::thread deep_thought_2(attrs, find_the_question, 42);

 Even for this simple attribute there could be portable issues as some platforms could require that the stack size 
@@ -147,7 +141,7 @@ Next follows how the user could set the stack size and the scheduling policy on
        // ... window version
    #elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
        // ... pthread version
-        pthread_attr_setschedpolicy(attr.native_handle(), SCHED_RR);
+        pthread_attr_setschedpolicy(attr.get_native_handle(), SCHED_RR);
    #else
    #error "Boost threads unavailable on this platform"
    #endif
@@ -207,7 +201,7 @@ __thread_interrupted__, `std::terminate()` is called.

 [endsect]

-[section:detach Detaching thread]
+[section:detac Detaching thread]

 A thread can  be detached by explicitly invoking the __detach__ member function on the __thread__
 object. In this case, the __thread__ object ceases to represent the now-detached thread, and instead represents __not_a_thread__.
@@ -255,7 +249,7 @@ does not complete when the specified time has elapsed or reached respectively.

 [endsect]

-[section:destructor1 Destructor V1-2]
+[section:destructor1 Destructor V1]

 When the __thread__ object that represents a thread of execution is destroyed the thread becomes ['detached]. Once a thread is
 detached, it will continue executing until the invocation of the function or callable object supplied on construction has completed,
@@ -264,7 +258,7 @@ object. In this case, the __thread__ object ceases to represent the now-detached

 [endsect]

-[section:destructor2 Destructor V3-X]
+[section:destructor2 Destructor V2]

 When the __thread__ object that represents a thread of execution is destroyed the program terminates if the thread is __joinable__. 

@@ -280,7 +274,7 @@ You can use a thread_joiner to ensure that the thread has been joined at the thr
  {
    boost::thread t(my_func);
    boost::thread_joiner g(t);
-    // do something else
+    // do someting else
  } // here the thread_joiner destructor will join the thread before it is destroyed.

 [endsect]
@@ -289,11 +283,9 @@ You can use a thread_joiner to ensure that the thread has been joined at the thr

 A running thread can be ['interrupted] by invoking the __interrupt__ member function of the corresponding __thread__ object. When the
 interrupted thread next executes one of the specified __interruption_points__ (or if it is currently __blocked__ whilst executing one)
-with interruption enabled, then a __thread_interrupted__ exception will be thrown in the interrupted thread. Unless this exception is
-caught inside the interrupted thread's thread-main function, the stack unwinding process (as with any other exception) causes the
-destructors with automatic storage duration to be executed. Unlike other exceptions, when __thread_interrupted__ is propagated out of
-thread-main function, this does not cause the call to `std::terminate`; the effect is as though the thread-main function has returned
-normally.
+with interruption enabled, then a __thread_interrupted__ exception will be thrown in the interrupted thread. If not caught,
+this will cause the execution of the interrupted thread to terminate. As with any other exception, the stack will be unwound, and
+destructors for objects of automatic storage duration will be executed.

 If a thread wishes to avoid being interrupted, it can create an instance of __disable_interruption__. Objects of this class disable
 interruption for the thread that created them on construction, and restore the interruption state to whatever it was before on
@@ -412,7 +404,7 @@ Of course all the synchronization facilities provided by Boost.Thread are also a

 The `boost::this_thread` interrupt related functions behave in a degraded mode when called from a thread created using the native interface, i.e. `boost::this_thread::interruption_enabled()` returns false. As consequence the use of `boost::this_thread::disable_interruption` and `boost::this_thread::restore_interruption` will do nothing and calls to `boost::this_thread::interruption_point()` will be just ignored.  

-As the single way to interrupt a thread is through a __thread__ instance, `interruption_request()` will return false for the native threads. 
+As the single way to interrupt a thread is through a __thread__ instance, `interruption_request()` wiil returns false for the native threads. 

 [heading `pthread_exit` POSIX limitation]

@@ -434,14 +426,12 @@ This behavior is incompatible with the current Boost.Thread design, so the use o
        class attributes; // EXTENSION

        thread() noexcept;
-        ~thread();
-        
        thread(const thread&) = delete;
        thread& operator=(const thread&) = delete;

-        // move support
        thread(thread&&) noexcept;
        thread& operator=(thread&&) noexcept;
+        ~thread();

        template <class F>
        explicit thread(F f);
@@ -460,6 +450,10 @@ This behavior is incompatible with the current Boost.Thread design, so the use o
        template <class F, class ...Args> 
        explicit thread(attributes& attrs, F&& f, Args&&... args);

+        // move support
+        thread(thread && x) noexcept;
+        thread& operator=(thread && x) noexcept;
+
        void swap(thread& x) noexcept;

        class id;
@@ -476,7 +470,6 @@ This behavior is incompatible with the current Boost.Thread design, so the use o
        void detach();

        static unsigned hardware_concurrency() noexcept;
-        static unsigned physical_concurrency() noexcept;

        typedef platform-specific-type native_handle_type;
        native_handle_type native_handle();
@@ -539,14 +532,24 @@ This behavior is incompatible with the current Boost.Thread design, so the use o

    thread& operator=(thread&& other) noexcept;

+
+[warning
+DEPRECATED since 3.0.0: BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE behavior.  
+ 
+Available only up to Boost 1.56. 
+
+Join the thread before moving.
+]
+
+
 [variablelist

 [[Effects:] [Transfers ownership of the thread managed by `other` (if
 any) to `*this`. 

- if defined BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE: If the thread is joinable call __detach__, DEPRECATED
+- if defined BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE: If there was a thread previously associated with `*this` then that thread is detached, DEPRECATED

- if defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE: If the thread is joinable calls to `std::terminate()`.
+- if defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE: If the thread is joinable calls to std::terminate.
 ]]

 [[Postconditions:] [`other->get_id()==thread::id()` and `get_id()` returns the value of `other.get_id()` prior to the assignment.]]
@@ -565,7 +568,7 @@ any) to `*this`.

 [variablelist

-[[Requires:] [`Callable` must be Copyable and `func()` must be a valid expression.]]
+[[Requires:] [`Callable` must by Copyable and `func()` must be a valid expression.]]

 [[Effects:] [`func` is copied into storage managed internally by the thread library, and that copy is invoked on a newly-created
 thread of execution. If this invocation results in an exception being propagated into the internals of the thread library that is
@@ -592,7 +595,7 @@ not of type __thread_interrupted__, then `std::terminate()` will be called. Any

 [variablelist

-[[Preconditions:] [`Callable` must be copyable.]]
+[[Preconditions:] [`Callable` must by copyable.]]

 [[Effects:] [`func` is copied into storage managed internally by the thread library, and that copy is invoked on a newly-created
 thread of execution with the specified attributes. If this invocation results in an exception being propagated into the internals of the thread library that is
@@ -620,7 +623,7 @@ If the attributes declare the native thread as detached, the boost::thread will

 [variablelist

-[[Preconditions:] [`Callable` must be Movable.]]
+[[Preconditions:] [`Callable` must by Movable.]]

 [[Effects:] [`func` is moved into storage managed internally by the thread library, and that copy is invoked on a newly-created
 thread of execution. If this invocation results in an exception being propagated into the internals of the thread library that is
@@ -647,7 +650,7 @@ not of type __thread_interrupted__, then `std::terminate()` will be called. Any

 [variablelist

-[[Preconditions:] [`Callable` must be copyable.]]
+[[Preconditions:] [`Callable` must by copyable.]]

 [[Effects:] [`func` is copied into storage managed internally by the thread library, and that copy is invoked on a newly-created
 thread of execution with the specified attributes. If this invocation results in an exception being propagated into the internals of the thread library that is
@@ -676,7 +679,7 @@ If the attributes declare the native thread as detached, the boost::thread will

 [variablelist

-[[Preconditions:] [`F` and each `A`n must be copyable or movable.]]
+[[Preconditions:] [`F` and each `A`n must by copyable or movable.]]

 [[Effects:] [As if [link
 thread.thread_management.thread.callable_constructor
@@ -703,17 +706,24 @@ are copied into internal storage for access by the new thread.]]]

    ~thread();

+[warning
+DEPRECATED since 3.0.0: BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE behavior.  
+ 
+Available only up to Boost 1.56. 
+
+Join the thread before destroying or use a scoped thread.
+]

 [variablelist

 [[Effects:] [
- if defined BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE: If the thread is joinable calls __detach__, DEPRECATED
+- if defined BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE: If `*this` has an associated thread of execution, calls __detach__, DEPRECATED

- if defined BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE: If the thread is joinable calls to `std::terminate`. Destroys `*this`.]]
+- BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE: If the thread is joinable calls to std::terminate. Destroys `*this`.]]

 [[Throws:] [Nothing.]]

-[[Note:] [The reason to moving to std::terminate is that either implicitly detaching or joining a `joinable()` thread in its destructor could result in difficult to debug correctness (for `detach`) or performance (for `join`) bugs encountered only when an exception is raised. Thus the programmer must ensure that the destructor is never executed while the thread is still joinable. Join the thread before destroying or use a scoped thread.]]
+[[Note:] [Either implicitly detaching or joining a `joinable()` thread in its destructor could result in difficult to debug correctness (for `detach`) or performance (for `join`) bugs encountered only when an exception is raised. Thus the programmer must ensure that the destructor is never executed while the thread is still joinable.]]

 ]

@@ -758,7 +768,7 @@ corresponding successful `join()` return. ]]

 [*resource_deadlock_would_occur]: if deadlock is detected or `this->get_id() == boost::this_thread::get_id()`.

-[*invalid_argument]: if the thread is not joinable and `BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED` is defined.
+[*invalid_argument]: if the thread is not joinable and `BOOST_THREAD_TRHOW_IF_PRECONDITION_NOT_SATISFIED` is defined.


 [/
@@ -784,6 +794,8 @@ corresponding successful `join()` return. ]]
 [warning
 DEPRECATED since 3.00.
 
+Available only up to Boost 1.56. 
+
 Use instead __try_join_for, __try_join_until.  
 ]

@@ -807,7 +819,7 @@ unchanged.]]

 [*resource_deadlock_would_occur]: if deadlock is detected or this->get_id() == boost::this_thread::get_id().

-[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is defined.
+[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_TRHOW_IF_PRECONDITION_NOT_SATISFIED is defined.


 [/
@@ -847,7 +859,7 @@ unchanged.]]

 [*resource_deadlock_would_occur]: if deadlock is detected or this->get_id() == boost::this_thread::get_id().

-[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is defined.
+[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_TRHOW_IF_PRECONDITION_NOT_SATISFIED is defined.


 [/
@@ -887,7 +899,7 @@ unchanged.]]

 [*resource_deadlock_would_occur]: if deadlock is detected or this->get_id() == boost::this_thread::get_id().

-[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is defined.
+[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_TRHOW_IF_PRECONDITION_NOT_SATISFIED is defined.


 [/
@@ -923,7 +935,7 @@ unchanged.]]

 [*no_such_process]: if the thread is not valid.

-[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is defined.
+[*invalid_argument]: if the thread is not joinable and BOOST_THREAD_TRHOW_IF_PRECONDITION_NOT_SATISFIED is defined.

 ]]

@@ -955,7 +967,7 @@ a default-constructed __thread_id__.]]

 [[Effects:] [If `*this` refers to a thread of execution, request that the thread will be interrupted the next time it enters one of
 the predefined __interruption_points__ with interruption enabled, or if it is currently __blocked__ in a call to one of the
-predefined __interruption_points__ with interruption enabled. Otherwise do noting.]]
+predefined __interruption_points__ with interruption enabled .]]

 [[Throws:] [Nothing]]

@@ -966,7 +978,7 @@ predefined __interruption_points__ with interruption enabled. Otherwise do notin

 [section:hardware_concurrency Static member function `hardware_concurrency()`]

-    unsigned hardware_concurrency() noexcept;
+    unsigned hardware_concurrency() noexecpt;

 [variablelist

@@ -979,21 +991,6 @@ or 0 if this information is not available.]]

 [endsect]

-[section:physical_concurrency Static member function `physical_concurrency()`]
-
-    unsigned physical_concurrency() noexcept;
-
-[variablelist
-
-[[Returns:] [The number of physical cores available on the current system. In contrast to `hardware_concurrency()` it does not return
- the number of virtual cores, but it counts only physical cores.]]
-
-[[Throws:] [Nothing]]
-
-]
-
-[endsect]
-
 [section:nativehandle Member function `native_handle()`]

    typedef platform-specific-type native_handle_type;
@@ -1017,6 +1014,8 @@ implementation. If no such instance exists, `native_handle()` and `native_handle
 [warning
 DEPRECATED since 4.0.0.  
 
+Available only up to Boost 1.58. 
+
 Use `a.__get_id()==b.__get_id()` instead`.
 ]

@@ -1037,6 +1036,8 @@ Use `a.__get_id()==b.__get_id()` instead`.
 [warning
 DEPRECATED since 4.0.0.  
 
+Available only up to Boost 1.58. 
+
 Use `a.__get_id()!=b.__get_id()` instead`.
 ]

@@ -1055,6 +1056,8 @@ Use `a.__get_id()!=b.__get_id()` instead`.
 [warning
 DEPRECATED since 3.0.0.  
 
+Available only up to Boost 1.56. 
+
 Use `this_thread::__sleep_for()` or `this_thread::__sleep_until()`.
 ]

@@ -1078,6 +1081,8 @@ Use `this_thread::__sleep_for()` or `this_thread::__sleep_until()`.
 [warning
 DEPRECATED since 3.0.0.  
 
+Available only up to Boost 1.56. 
+
 Use `this_thread::__yield()`.
 ]

@@ -1292,7 +1297,7 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [variablelist

-[[Effects:] [Constructs a thread attributes instance with its default values.]]
+[[Effects:] [Constructs a thread atrributes instance with its default values.]]

 [[Throws:] [Nothing]]

@@ -1306,7 +1311,7 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [variablelist

-[[Effects:] [Stores the stack size to be used to create a thread. This is a hint that the implementation can choose a better size if to small or too big or not aligned to a page.]]
+[[Effects:] [Stores the stack size to be used to create a thread. This is an hint that the implementation can choose a better size if to small or too big or not aligned to a page.]]

 [[Postconditions:] [`this-> get_stack_size()` returns the chosen stack size.]]

@@ -1469,6 +1474,8 @@ thread attributes implementation. If no such instance exists, `native_handle()`
 [warning
 DEPRECATED since 3.0.0.  
 
+Available only up to Boost 1.56. 
+
 Use `__sleep_for()` and `__sleep_until()` instead.
 ]

@@ -1495,11 +1502,6 @@ specified by `rel_time` has elapsed or the time point specified by
    {
      template <class Clock, class Duration>
      void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
-      namespace no_interruption_point
-      {
-        template <class Clock, class Duration>
-        void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
-      }
    }

 [variablelist
@@ -1511,7 +1513,6 @@ specified by `rel_time` has elapsed or the time point specified by
 do not throw exceptions. __thread_interrupted__ if the current thread of execution is interrupted. ]]

 [[Notes:] [`sleep_until()` is one of the predefined __interruption_points__.]]
-[[Notes:] [`no_interruption_point::sleep_until()` is NOT one of the __interruption_points__.]]

 ]

@@ -1525,22 +1526,16 @@ do not throw exceptions. __thread_interrupted__ if the current thread of executi
    {
      template <class Rep, class Period>
      void sleep_for(const chrono::duration<Rep, Period>& rel_time);
-      namespace no_interruption_point
-      {
-        template <class Rep, class Period>
-        void sleep_for(const chrono::duration<Rep, Period>& rel_time);
-      }
    }

 [variablelist

-[[Effects:] [Suspends the current thread until the duration specified
+[[Effects:] [Suspends the current thread until the duration specified by
 by `rel_time` has elapsed.]]

 [[Throws:] [Nothing if operations of chrono::duration<Rep, Period> do not throw exceptions. __thread_interrupted__ if the current thread of execution is interrupted.]]

 [[Notes:] [`sleep_for()` is one of the predefined __interruption_points__.]]
-[[Notes:] [`no_interruption_point:: sleep_for()` is NOT one of the __interruption_points__.]]

 ]

@@ -1713,6 +1708,7 @@ registered with `at_thread_exit()`]]
 [section:threadgroup Class `thread_group` EXTENSION]

    #include <boost/thread/thread.hpp>
+    #include <boost/thread/thread_group.hpp>

    class thread_group
    {
--- a/example/condition.cpp
+++ b/example/condition.cpp
@@ -8,7 +8,7 @@
 #include <vector>
 #include <boost/utility.hpp>
 #include <boost/thread/condition_variable.hpp>
-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #include "../test/remove_error_code_unused_warning.hpp"

 class bounded_buffer : private boost::noncopyable
@@ -16,7 +16,7 @@ class bounded_buffer : private boost::noncopyable
 public:
    typedef boost::unique_lock<boost::mutex> lock;

-    bounded_buffer(int n) : boost::noncopyable(), begin(0), end(0), buffered(0), circular_buf(n) { }
+    bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }

    void send (int m) {
        lock lk(monitor);
--- a/example/default_executor.cpp
+++ b/example/default_executor.cpp
@@ -1,61 +0,0 @@
-// Copyright (C) 2014 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-
-#include <boost/thread/caller_context.hpp>
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/executors/generic_executor_ref.hpp>
-#include <string>
-#include <iostream>
-
-#include <boost/thread/caller_context.hpp>
-
-
-boost::generic_executor_ref default_executor()
-{
-  static boost::basic_thread_pool tp(4);
-  return boost::generic_executor_ref(tp);
-}
-
-void p2()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-  std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-
-void p1()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-  default_executor().submit(&p2);
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(400));
-  std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-int main()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-
-  default_executor().submit(&p1);
-
-  boost::this_thread::sleep_for(boost::chrono::seconds(5));
-
-  std::cout << BOOST_CONTEXTOF << std::endl;
-
-  return 1;
-
-}
--- a/example/executor.cpp
+++ b/example/executor.cpp
@@ -1,207 +0,0 @@
-// Copyright (C) 2012-2013 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-#include <iostream>
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-
-#include <boost/thread/caller_context.hpp>
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/executors/loop_executor.hpp>
-#include <boost/thread/executors/serial_executor.hpp>
-#include <boost/thread/executors/inline_executor.hpp>
-#include <boost/thread/executors/thread_executor.hpp>
-#include <boost/thread/executors/executor.hpp>
-#include <boost/thread/executors/executor_adaptor.hpp>
-#include <boost/thread/executor.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <string>
-#include <iostream>
-#include <cassert>
-
-boost::future<void> p(boost::future<void> f) {
-    assert(f.is_ready());
-    return boost::make_ready_future();
-}
-
-void p1()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  //boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-}
-
-void p2()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  //boost::this_thread::sleep_for(boost::chrono::seconds(10));
-}
-
-int f1()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(1));
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  return 1;
-}
-int f2(int i)
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(2));
-  return i + 1;
-}
-
-void submit_some(boost::executor& tp)
-{
-  for (int i = 0; i < 3; ++i) {
-    tp.submit(&p2);
-  }
-  for (int i = 0; i < 3; ++i) {
-    tp.submit(&p1);
-  }
-
-}
-
-
-void at_th_entry(boost::basic_thread_pool& )
-{
-
-}
-
-int test_executor_adaptor()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  {
-    try
-    {
-      {
-        boost::executor_adaptor < boost::basic_thread_pool > ea(4);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-        submit_some( ea);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-#if 1
-      // fixme
-      // ERROR= tr1::bad_weak_ptr
-        {
-          boost::future<int> t1 = boost::async(ea, &f1);
-          boost::future<int> t2 = boost::async(ea, &f1);
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
-        }
-        std::cout << BOOST_CONTEXTOF << std::endl;
-        submit_some(ea);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-        {
-          boost::basic_thread_pool ea3(1);
-          std::cout << BOOST_CONTEXTOF << std::endl;
-          boost::future<int> t1 = boost::async(ea3, &f1);
-          std::cout << BOOST_CONTEXTOF << std::endl;
-          boost::future<int> t2 = boost::async(ea3, &f1);
-          std::cout << BOOST_CONTEXTOF << std::endl;
-          //boost::future<int> t2 = boost::async(ea3, f2, 1); // todo this doesn't compiles yet on C++11
-          //boost::future<int> t2 = boost::async(ea3, boost::bind(f2, 1)); // todo this doesn't compiles yet on C++98
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
-        }
-#endif
-        std::cout << BOOST_CONTEXTOF << std::endl;
-        submit_some(ea);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::executor_adaptor < boost::loop_executor > ea2;
-        submit_some( ea2);
-        ea2.underlying_executor().run_queued_closures();
-      }
-#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::executor_adaptor < boost::basic_thread_pool > ea1(4);
-        boost::executor_adaptor < boost::serial_executor > ea2(ea1);
-        submit_some(ea2);
-      }
-#endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::executor_adaptor < boost::inline_executor > ea1;
-        submit_some(ea1);
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::executor_adaptor < boost::thread_executor > ea1;
-        submit_some(ea1);
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-#if 1
-      // fixme
-      // ERROR= tr1::bad_weak_ptr
-      {
-        boost::basic_thread_pool  ea(4, at_th_entry);
-        boost::future<int> t1 = boost::async(ea, &f1);
-        std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-      }
-#endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::async(&f1);
-      }
-#if 1
-      // fixme
-      // ERROR= tr1::bad_weak_ptr
-
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::basic_thread_pool  ea(1);
-        boost::async(ea,&f1);
-      }
-#endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-      std::cout << BOOST_CONTEXTOF << std::endl;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << "ERROR= " << ex.what() << "" << std::endl;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << " ERROR= exception thrown" << std::endl;
-      return 2;
-    }
-  }
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  return 0;
-}
-
-
-int main()
-{
-  return test_executor_adaptor();
-
-#if 0 && defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION \
-  && defined BOOST_THREAD_PROVIDES_EXECUTORS \
-  &&  ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
-
-  boost::basic_thread_pool executor;
-  // compiles
-  boost::make_ready_future().then(&p);
-
-  // ??
-  boost::make_ready_future().then(executor, &p);
-
-  // doesn't compile
-  boost::make_ready_future().then(executor, &p);
-#endif
-}
--- a/example/fib_task_region.cpp
+++ b/example/fib_task_region.cpp
@@ -1,91 +0,0 @@
-// Copyright (C) 2012 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-
-#include <boost/thread/experimental/task_region.hpp>
-#include <iostream>
-
-#if ! defined BOOST_NO_CXX11_RANGE_BASED_FOR &&  ! defined BOOST_NO_CXX11_LAMBDAS
-
-int fib_task_region(int n)
-{
-  using boost::experimental::parallel::task_region;
-  using boost::experimental::parallel::task_region_handle;
-
-  if (n == 0) return 0;
-  if (n == 1) return 1;
-
-  int n1;
-  int n2;
-
-  task_region([&](task_region_handle& trh)
-      {
-        trh.run([&]
-            {
-              n1 = fib_task_region(n - 1);
-            });
-
-        n2 = fib_task_region(n - 2);
-      });
-
-  return n1 + n2;
-}
-
-#if defined BOOST_THREAD_PROVIDES_EXECUTORS
-template <class Ex>
-int fib_task_region_gen( Ex& ex, int n)
-{
-  using boost::experimental::parallel::task_region;
-  using boost::experimental::parallel::task_region_handle_gen;
-
-  if (n == 0) return 0;
-  if (n == 1) return 1;
-
-  int n1;
-  int n2;
-
-  task_region(ex, [&](task_region_handle_gen<Ex>& trh)
-      {
-        trh.run([&]
-            {
-              n1 = fib_task_region(n - 1);
-            });
-
-        n2 = fib_task_region(n - 2);
-      });
-
-  return n1 + n2;
-}
-#endif
-
-int main()
-{
-  for (int i = 0; i<10; ++i) {
-    std::cout << fib_task_region(i) << " ";
-  }
-  std::cout << std::endl;
-
-#if defined BOOST_THREAD_PROVIDES_EXECUTORS
-  boost::basic_thread_pool tp;
-  for (int i = 0; i<10; ++i) {
-    std::cout << fib_task_region_gen(tp,i) << " ";
-  }
-  std::cout << std::endl;
-#endif
-  return 0;
-}
-#else
-int main()
-{
-  return 0;
-}
-#endif
--- a/example/future_fallback_to.cpp
+++ b/example/future_fallback_to.cpp
@@ -1,157 +0,0 @@
-// Copyright (C) 2012-2013 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-
-#include <boost/thread/detail/log.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <exception>
-#include <string>
-#include <iostream>
-
-#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
-
-int p1_ex()
-{
-  BOOST_THREAD_LOG << "P1" << BOOST_THREAD_END_LOG;
-  throw std::logic_error("kk");
-}
-
-int p1()
-{
-  BOOST_THREAD_LOG << "P1" << BOOST_THREAD_END_LOG;
-  return 1;;
-}
-
-int main()
-{
-  const int number_of_tests = 200;
-  BOOST_THREAD_LOG << "<MAIN" << BOOST_THREAD_END_LOG;
-
-  {
-    for (int i=0; i< number_of_tests; i++)
-    try
-    {
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      f1.wait();
-      BOOST_ASSERT(f1.get()==1);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << "ERRORRRRR "<<ex.what() << "" << std::endl;
-      BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << " ERRORRRRR exception thrown" << std::endl;
-      BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-
-  {
-    for (int i=0; i< number_of_tests; i++)
-    try
-    {
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f1 = boost::async(&p1);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f2 = f1.fallback_to(-1);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      f2.wait();
-      //std::cout << __FILE__ << "["<< __LINE__<<"] " << std::endl;
-      BOOST_ASSERT(f2.get()==1);
-      //std::cout << __FILE__ << "["<< __LINE__<<"] " << std::endl;
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << "ERRORRRRR "<<ex.what() << "" << std::endl;
-      BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << " ERRORRRRR exception thrown" << std::endl;
-      BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-
-  {
-    for (int i=0; i< number_of_tests; i++)
-    try
-    {
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f1 = boost::async(boost::launch::async, &p1_ex);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      f1.wait();
-      BOOST_ASSERT(f1.get_or(-1)==-1);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << "ERRORRRRR "<<ex.what() << "" << std::endl;
-      BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << " ERRORRRRR exception thrown" << std::endl;
-      BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-
-  {
-    for (int i=0; i< number_of_tests; i++)
-    try
-    {
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f1 = boost::async(boost::launch::async, &p1_ex);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f2 = f1.fallback_to(-1);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      f2.wait();
-      //std::cout << __FILE__ << "["<< __LINE__<<"] " << std::endl;
-      BOOST_ASSERT(f2.get()==-1);
-      //std::cout << __FILE__ << "["<< __LINE__<<"] " << std::endl;
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << "ERRORRRRR "<<ex.what() << "" << std::endl;
-      BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << __FILE__ << "["<< __LINE__<<"] " << " ERRORRRRR exception thrown" << std::endl;
-      BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-  BOOST_THREAD_LOG << "MAIN>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
-#else
-
-int main()
-{
-  return 0;
-}
-#endif
--- a/example/future_then.cpp
+++ b/example/future_then.cpp
@@ -1,23 +1,17 @@
-// Copyright (C) 2012-2013 Vicente Botet
+// Copyright (C) 2012 Vicente Botet
 //
 //  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-
-#define BOOST_THREAD_VERSION 4
+//#define BOOST_THREAD_VERSION 4
 //#define BOOST_THREAD_USES_LOG
 #define BOOST_THREAD_USES_LOG_THREAD_ID
+//#define BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET

 #include <boost/thread/detail/log.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/assert.hpp>
 #include <string>
-#include <iostream>
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION

 int p1()
@@ -26,16 +20,15 @@ int p1()
  return 123;
 }

-int p2(boost::future<int> f)
+int p2(boost::future<int>& f)
 {
-  BOOST_THREAD_LOG << "P2<" << BOOST_THREAD_END_LOG;
+  BOOST_THREAD_LOG << "<P2" << BOOST_THREAD_END_LOG;
  try
  {
    return 2 * f.get();
  }
  catch (std::exception& ex)
  {
-    std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
    BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
    BOOST_ASSERT(false);
  }
@@ -45,81 +38,28 @@ int p2(boost::future<int> f)
    BOOST_ASSERT(false);
  }
  BOOST_THREAD_LOG << "P2>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
-int p2s(boost::shared_future<int> f)
-{
-  BOOST_THREAD_LOG << "<P2S" << BOOST_THREAD_END_LOG;
-  try
-  {
-    return 2 * f.get();
-  }
-  catch (std::exception& ex)
-  {
-    std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
-    BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-    BOOST_ASSERT(false);
-  }
-  catch (...)
-  {
-    BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-    BOOST_ASSERT(false);
-  }
-  BOOST_THREAD_LOG << "P2S>" << BOOST_THREAD_END_LOG;
-  return 0;
 }

 int main()
 {
-  const int number_of_tests = 100;
  BOOST_THREAD_LOG << "<MAIN" << BOOST_THREAD_END_LOG;
+  try
  {
-    for (int i=0; i< number_of_tests; i++)
-    try
-    {
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f1 = boost::async(&p1);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f2 = f1.then(&p2);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      (void)f2.get();
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
-      BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
+    boost::future<int> f1 = boost::async(&p1);
+    BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
+    boost::future<int> f2 = f1.then(&p2);
+    BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+    BOOST_THREAD_LOG << f2.get() << BOOST_THREAD_END_LOG;
  }
+  catch (std::exception& ex)
  {
-    for (int i=0; i< number_of_tests; i++)
-    try
-    {
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::shared_future<int> f1 = boost::async(&p1).share();
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      boost::future<int> f2 = f1.then(&p2s);
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-      (void)f2.get();
-      BOOST_THREAD_LOG << "" << BOOST_THREAD_END_LOG;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
-      BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
+    BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
+    return 1;
+  }
+  catch (...)
+  {
+    BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
+    return 2;
  }
  BOOST_THREAD_LOG << "MAIN>" << BOOST_THREAD_END_LOG;
  return 0;
--- a/example/future_unwrap.cpp
+++ b/example/future_unwrap.cpp
@@ -1,88 +0,0 @@
-// Copyright (C) 2012-2013 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-
-#include <boost/thread/detail/log.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <string>
-#include <iostream>
-
-#if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP
-
-int p1()
-{
-  BOOST_THREAD_LOG << "P1" << BOOST_THREAD_END_LOG;
-  return 123;
-}
-
-boost::future<int> p2()
-{
-  BOOST_THREAD_LOG << "<P2" << BOOST_THREAD_END_LOG;
-  boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-  BOOST_THREAD_LOG << "P2>" << BOOST_THREAD_END_LOG;
-  return boost::move(f1);
-}
-
-int main()
-{
-  const int number_of_tests = 100;
-  BOOST_THREAD_LOG << "<MAIN" << BOOST_THREAD_END_LOG;
-  for (int i=0; i< number_of_tests; i++)
-  try
-  {
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    {
-      boost::future<int> inner_future = boost::async(boost::launch::async, &p2).unwrap();
-      inner_future.wait();
-      int ii = inner_future.get();
-      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
-    }
-#endif
-    {
-      boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
-      boost::future<int> inner_future = outer_future.unwrap();
-      inner_future.wait();
-      int ii = inner_future.get();
-      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
-    }
-    {
-      boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
-      boost::future<int> inner_future = outer_future.unwrap();
-      int ii = inner_future.get();
-      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
-    }
-  }
-  catch (std::exception& ex)
-  {
-    std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
-    BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-    return 1;
-  }
-  catch (...)
-  {
-    std::cout << " ERRORRRRR exception thrown" << std::endl;
-    BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-    return 2;
-  }
-  BOOST_THREAD_LOG << "MAIN>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
-#else
-
-int main()
-{
-  return 0;
-}
-#endif
--- a/example/future_when_all.cpp
+++ b/example/future_when_all.cpp
@@ -1,326 +0,0 @@
-// Copyright (C) 2012-2013 Vicente Botet
-//
-//  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/config.hpp>
-
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-
-#include <boost/thread/future.hpp>
-#include <boost/thread/csbl/vector.hpp>
-#include <boost/assert.hpp>
-#include <boost/thread/detail/log.hpp>
-#include <string>
-#if defined BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY
-
-int p1()
-{
-  BOOST_THREAD_LOG
-    << "P1" << BOOST_THREAD_END_LOG;
-  boost::this_thread::sleep_for(boost::chrono::seconds(1));
-  return 123;
-}
-int p1b()
-{
-  BOOST_THREAD_LOG
-    << "P1b" << BOOST_THREAD_END_LOG;
-  boost::this_thread::sleep_for(boost::chrono::seconds(1));
-  return 321;
-}
-
-int p2(boost::future<int> f)
-{
-  BOOST_THREAD_LOG
-    << " P2 " << BOOST_THREAD_END_LOG;
-  try
-  {
-    return 2 * f.get();
-  }
-  catch (std::exception& ex)
-  {
-    BOOST_THREAD_LOG
-      << "ERRORRRRR " << ex.what() << "" << BOOST_THREAD_END_LOG;
-    BOOST_ASSERT(false);
-  }
-  catch (...)
-  {
-    BOOST_THREAD_LOG
-      << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-    BOOST_ASSERT(false);
-  }
-  BOOST_THREAD_LOG
-    << "P2>" << BOOST_THREAD_END_LOG;
-  return 0;
-
-}
-int p2s(boost::shared_future<int> f)
-{
-  BOOST_THREAD_LOG
-    << "<P2" << BOOST_THREAD_END_LOG;
-  try
-  {
-    return 2 * f.get();
-  }
-  catch (std::exception& ex)
-  {
-    BOOST_THREAD_LOG
-      << "ERRORRRRR " << ex.what() << "" << BOOST_THREAD_END_LOG;
-    BOOST_ASSERT(false);
-  }
-  catch (...)
-  {
-    BOOST_THREAD_LOG
-      << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-    BOOST_ASSERT(false);
-  }
-  BOOST_THREAD_LOG
-    << "P2>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
-
-int main()
-{
-  BOOST_THREAD_LOG
-    << "<MAIN" << BOOST_THREAD_END_LOG;
-  {
-    try
-    {
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<boost::csbl::tuple<> > all0 = boost::when_all();
-        BOOST_THREAD_LOG
-          <<  BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-        boost::future<boost::csbl::tuple<boost::future<int> > > all = boost::when_all(boost::move(f1));
-        boost::csbl::tuple<boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-#if  defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::deferred, &p1);
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<boost::csbl::tuple<boost::future<int> > > all = boost::when_all(boost::move(f1));
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::csbl::tuple<boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-#endif
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::make_ready_future(1);
-        boost::future<boost::csbl::tuple<boost::future<int> > > all = boost::when_all(boost::move(f1));
-        boost::csbl::tuple<boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-        boost::future<int> f2 = boost::async(boost::launch::async, &p1b);
-        boost::future<boost::csbl::tuple<boost::future<int>,boost::future<int> > > all = boost::when_all(boost::move(f1), boost::move(f2));
-        //(void) all.wait();
-        boost::csbl::tuple<boost::future<int>,boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-        boost::future<std::string> f2 = boost::make_ready_future(std::string("nnnnnnn"));;
-        boost::future<boost::csbl::tuple<boost::future<int>, boost::future<std::string> > > all = boost::when_all(boost::move(f1), boost::move(f2));
-        //(void) all.wait();
-        boost::csbl::tuple<boost::future<int>, boost::future<std::string> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::csbl::vector<boost::future<int> > v;
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        v.push_back(boost::async(boost::launch::async, &p1));
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        v.push_back(boost::async(boost::launch::async, &p1b));
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<boost::csbl::vector<boost::future<int> > > all = boost::when_all(v.begin(), v.end());
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::csbl::vector<boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << res[0].get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << res[1].get() <<" " << BOOST_THREAD_END_LOG;
-      }
-    }
-    catch (std::exception& ex)
-    {
-      BOOST_THREAD_LOG
-        << "ERRORRRRR " << ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      BOOST_THREAD_LOG
-        << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-  {
-    try
-    {
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<boost::csbl::tuple<> > all0 = boost::when_any();
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-        boost::future<boost::csbl::tuple<boost::future<int> > > all = boost::when_any(boost::move(f1));
-        boost::csbl::tuple<boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::deferred, &p1);
-        boost::future<boost::csbl::tuple<boost::future<int> > > all = boost::when_any(boost::move(f1));
-        boost::csbl::tuple<boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-#endif
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-        boost::future<int> f2 = boost::async(boost::launch::async, &p1b);
-        boost::future<boost::csbl::tuple<boost::future<int>,boost::future<int> > > all = boost::when_any(boost::move(f1), boost::move(f2));
-        boost::csbl::tuple<boost::future<int>,boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::make_ready_future(1);
-        boost::future<int> f2 = boost::async(boost::launch::async, &p1b);
-        boost::future<boost::csbl::tuple<boost::future<int>,boost::future<int> > > all = boost::when_any(boost::move(f1), boost::move(f2));
-        boost::csbl::tuple<boost::future<int>,boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<std::string> f1 = boost::make_ready_future(std::string("aaaa"));
-        boost::future<int> f2 = boost::async(boost::launch::async, &p1b);
-        boost::future<boost::csbl::tuple<boost::future<std::string>,boost::future<int> > > all = boost::when_any(boost::move(f1), boost::move(f2));
-        boost::csbl::tuple<boost::future<std::string>,boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f2 = boost::make_ready_future(1);
-        boost::future<int> f1 = boost::async(boost::launch::async, &p1b);
-        boost::future<boost::csbl::tuple<boost::future<int>,boost::future<int> > > all = boost::when_any(boost::move(f1), boost::move(f2));
-        boost::csbl::tuple<boost::future<int>,boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::deferred, &p1);
-        boost::future<int> f2 = boost::async(boost::launch::async, &p1b);
-        boost::future<boost::csbl::tuple<boost::future<int>,boost::future<int> > > all = boost::when_any(boost::move(f1), boost::move(f2));
-        boost::csbl::tuple<boost::future<int>,boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<int> f1 = boost::async(boost::launch::async, &p1);
-        boost::future<int> f2 = boost::async(boost::launch::deferred, &p1b);
-        boost::future<boost::csbl::tuple<boost::future<int>,boost::future<int> > > all = boost::when_any(boost::move(f1), boost::move(f2));
-        boost::csbl::tuple<boost::future<int>,boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << boost::csbl::get<0>(res).get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << boost::csbl::get<1>(res).get() <<" " << BOOST_THREAD_END_LOG;
-      }
-#endif
-      {
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::csbl::vector<boost::future<int> > v;
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        v.push_back(boost::async(boost::launch::async, &p1));
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        v.push_back(boost::async(boost::launch::async, &p1b));
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::future<boost::csbl::vector<boost::future<int> > > all = boost::when_any(v.begin(), v.end());
-        BOOST_THREAD_LOG <<  BOOST_THREAD_END_LOG;
-        boost::csbl::vector<boost::future<int> > res = all.get();
-        BOOST_THREAD_LOG
-          << res[0].get() <<" " << BOOST_THREAD_END_LOG;
-        BOOST_THREAD_LOG
-          << res[1].get() <<" " << BOOST_THREAD_END_LOG;
-      }
-    }
-    catch (std::exception& ex)
-    {
-      BOOST_THREAD_LOG
-        << "ERRORRRRR " << ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      BOOST_THREAD_LOG
-        << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-  BOOST_THREAD_LOG
-    << "MAIN>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
-#else
-#include <boost/thread/csbl/vector.hpp>
-using namespace boost;
-
-void f(  boost::csbl::vector<future<int> > &//vec
-    , BOOST_THREAD_RV_REF(future<int>) //f
-    ) {
-}
-int main()
-{
-  boost::csbl::vector<future<int> > vec;
-  f(vec, make_ready_future(0));
-  return 0;
-}
-#endif
--- a/example/generic_executor_ref.cpp
+++ b/example/generic_executor_ref.cpp
@@ -1,163 +0,0 @@
-// Copyright (C) 2014 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-
-#include <boost/thread/caller_context.hpp>
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/executors/loop_executor.hpp>
-#include <boost/thread/executors/serial_executor.hpp>
-#include <boost/thread/executors/inline_executor.hpp>
-#include <boost/thread/executors/thread_executor.hpp>
-#include <boost/thread/executors/executor.hpp>
-#include <boost/thread/executors/executor_adaptor.hpp>
-#include <boost/thread/executor.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <string>
-#include <iostream>
-
-void p1()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  //boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-}
-
-void p2()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  //boost::this_thread::sleep_for(boost::chrono::seconds(10));
-}
-
-int f1()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(1));
-  return 1;
-}
-int f2(int i)
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(2));
-  return i + 1;
-}
-
-void submit_some(boost::generic_executor_ref tp)
-{
-  for (int i = 0; i < 3; ++i) {
-    tp.submit(&p2);
-  }
-  for (int i = 0; i < 3; ++i) {
-    tp.submit(&p1);
-  }
-
-}
-
-void at_th_entry(boost::basic_thread_pool& )
-{
-
-}
-
-
-
-int test_generic_executor_ref()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  {
-    try
-    {
-      {
-        boost::basic_thread_pool ea(4);
-        submit_some( ea);
-        {
-          boost::future<int> t1 = boost::async(ea, &f1);
-          boost::future<int> t2 = boost::async(ea, &f1);
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
-        }
-        submit_some(ea);
-        {
-          boost::basic_thread_pool ea3(1);
-          boost::future<int> t1 = boost::async(ea3, &f1);
-          boost::future<int> t2 = boost::async(ea3, &f1);
-          //boost::future<int> t2 = boost::async(ea3, f2, 1); // todo this doesn't compiles yet on C++11
-          //boost::future<int> t2 = boost::async(ea3, boost::bind(f2, 1)); // todo this doesn't compiles yet on C++98
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
-        }
-        submit_some(ea);
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::loop_executor ea2;
-        submit_some( ea2);
-        ea2.run_queued_closures();
-      }
-#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::basic_thread_pool ea1(4);
-        boost::serial_executor ea2(ea1);
-        submit_some(ea2);
-      }
-#endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::inline_executor ea1;
-        submit_some(ea1);
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        //boost::thread_executor ea1;
-        //submit_some(ea1);
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::basic_thread_pool  ea(4, at_th_entry);
-        boost::future<int> t1 = boost::async(ea, &f1);
-        std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::basic_thread_pool  ea(4, at_th_entry);
-        boost::async(ea, &f1);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-      std::cout << BOOST_CONTEXTOF << std::endl;
-
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << "ERROR= " << ex.what() << "" << std::endl;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << " ERROR= exception thrown" << std::endl;
-      return 2;
-    }
-  }
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  return 0;
-}
-
-
-int main()
-{
-  return test_generic_executor_ref();
-
-
-}
--- a/example/lambda_future.cpp
+++ b/example/lambda_future.cpp
@@ -1,75 +0,0 @@
-// Copyright (C) 2013 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-
-#include <boost/thread/detail/log.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <string>
-#include <iostream>
-
-#if    defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION \
-  && ! defined BOOST_NO_CXX11_LAMBDAS && ! (defined BOOST_MSVC && _MSC_VER < 1700)
-
-
-int main()
-{
-  const int number_of_tests = 100;
-  BOOST_THREAD_LOG << "<MAIN" << BOOST_THREAD_END_LOG;
-
-  for (int i=0; i< number_of_tests; i++)
-  try
-  {
-    {
-      boost::future<int> f1 = boost::async(boost::launch::async, []()  {return 123;});
-      int result = f1.get();
-      BOOST_THREAD_LOG << "f1 " << result << BOOST_THREAD_END_LOG;
-    }
-    {
-      boost::future<int> f1 = boost::async(boost::launch::async, []() {return 123;});
-      boost::future<int> f2 = f1.then([](boost::future<int> f)  {return 2*f.get(); });
-      int result = f2.get();
-      BOOST_THREAD_LOG << "f2 " << result << BOOST_THREAD_END_LOG;
-    }
-#if ! defined    BOOST_NO_CXX14_GENERIC_LAMBDAS
-    {
-      boost::future<int> f1 = boost::async(boost::launch::async, []() {return 123;});
-      boost::future<int> f2 = f1.then([](auto f)  {return 2*f.get(); });
-      int result = f2.get();
-      BOOST_THREAD_LOG << "f2 " << result << BOOST_THREAD_END_LOG;
-    }
-#endif
-  }
-  catch (std::exception& ex)
-  {
-    std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
-    BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
-    return 1;
-  }
-  catch (...)
-  {
-    std::cout << " ERRORRRRR exception thrown" << std::endl;
-    BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-    return 2;
-  }
-  BOOST_THREAD_LOG << "MAIN>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
-#else
-
-int main()
-{
-  return 0;
-}
-#endif
--- a/example/make_future.cpp
+++ b/example/make_future.cpp
@@ -3,152 +3,40 @@
 //  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
 #define BOOST_THREAD_VERSION 4

 #include <boost/thread/future.hpp>
 #include <iostream>

-namespace boost
-{
-
-  template <typename T>
-  exception_ptr make_exception_ptr(T v)
-  {
-    return copy_exception(v);
-  }
-}
-
 int p1() { return 5; }
-int& p1r() { static int i=0; return i; }
-
-void p() { }
-
-#if defined BOOST_THREAD_USES_MOVE
-boost::future<void> void_compute()
-{
-  return BOOST_THREAD_MAKE_RV_REF(boost::make_ready_future());
-}
-#endif

 boost::future<int> compute(int x)
 {
-  if (x == 0) return boost::make_ready_future(0);
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-  if (x < 0) return boost::make_exceptional_future<int>(std::logic_error("Error"));
-#else
-  if (x < 0) return boost::make_exceptional(std::logic_error("Error"));
-#endif
+  if (x == 0) return boost::make_future(0);
+  if (x < 0) return boost::make_future(-1);
  //boost::future<int> f1 = boost::async([]() { return x+1; });
-  boost::future<int> f1 = boost::async(p1);
+  boost::future<int> f1 = boost::async(boost::launch::async, p1);
  return boost::move(f1);
 }
-
-boost::future<int&> compute_ref(int x)
-{
-  static int i = 0;
-  //if (x == 0) return boost::make_ready_future<int&>(i); //This must not compile as the type is deduced as boost::future<int>
-  if (x == 0) return boost::make_ready_no_decay_future<int&>(i);
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-  if (x < 0) return boost::make_exceptional_future<int&>(std::logic_error("Error"));
-#else
-  if (x < 0) return boost::make_exceptional(std::logic_error("Error"));
-#endif
-  boost::future<int&> f1 = boost::async(p1r);
-  return boost::move(f1);
-}
-
 boost::shared_future<int> shared_compute(int x)
 {
-  if (x == 0) return boost::make_ready_future(0).share();
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-  if (x < 0) return boost::make_exceptional_future<int>(std::logic_error("Error")).share();
-#else
-  if (x < 0) return boost::make_exceptional(std::logic_error("Error"));
-#endif
+  if (x == 0) return boost::make_shared_future(0);
+  if (x < 0) return boost::make_shared_future(-1);
  //boost::future<int> f1 = boost::async([]() { return x+1; });
-  boost::shared_future<int> f1 = boost::async(&p1).share();
-  return f1;
+  boost::shared_future<int> f1 = boost::async(p1).share();
+  return boost::move(f1);
 }


 int main()
 {
-  const int number_of_tests = 100;
-  for (int i=0; i< number_of_tests; i++)
-  try
  {
-//    {
-//    std::cout << __FILE__ << " "<<__LINE__ << std::endl;
-//    boost::future<int> f = boost::async(boost::launch::async, p1);
-//    std::cout << i << " "<<f.get() << std::endl;
-//    }
-#if defined BOOST_THREAD_USES_MOVE
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    boost::future<void> f = void_compute();
-    f.get();
-  }
-#endif
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    boost::future<int> f = compute(-1);
-    f.wait();
-  }
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    boost::future<int> f = compute(0);
-    std::cout << f.get() << std::endl;
-  }
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    boost::future<int&> f = compute_ref(0);
-    std::cout << f.get() << std::endl;
-  }
-#if __cplusplus > 201103L
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    int i = 0;
-    boost::future<int&> f = boost::make_ready_future(std::ref(i));
-    std::cout << f.get() << std::endl;
-  }
-#endif
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    int i = 0;
-    boost::future<int&> f = boost::make_ready_future(boost::ref(i));
-    std::cout << f.get() << std::endl;
-  }
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    const int i = 0;
-    boost::future<int const&> f = boost::make_ready_future(boost::cref(i));
-    std::cout << f.get() << std::endl;
-  }
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
    boost::future<int> f = compute(2);
    std::cout << f.get() << std::endl;
  }
  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    boost::shared_future<int> f = shared_compute(0);
+    boost::shared_future<int> f = shared_compute(2);
    std::cout << f.get() << std::endl;
  }
-  }
-  catch (std::exception& ex)
-  {
-    std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
-    return 1;
-  }
-  catch (...)
-  {
-    std::cout << "ERRORRRRR "<<"ERRORRRRR exception thrown" << std::endl;
-    return 2;
-  }
  return 0;
 }
--- a/example/monitor.cpp
+++ b/example/monitor.cpp
@@ -9,7 +9,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>

 namespace {
 const int ITERS = 100;
--- a/example/not_interleaved.cpp
+++ b/example/not_interleaved.cpp
@@ -15,7 +15,7 @@
 void use_cerr(boost::externally_locked_stream<std::ostream> &mcerr)
 {
  using namespace boost;
-  chrono::steady_clock::time_point tf = chrono::steady_clock::now() + chrono::seconds(10);
+  auto tf = chrono::steady_clock::now() + chrono::seconds(10);
  while (chrono::steady_clock::now() < tf)
  {
    mcerr << "logging data to cerr\n";
@@ -26,7 +26,7 @@ void use_cerr(boost::externally_locked_stream<std::ostream> &mcerr)
 void use_cout(boost::externally_locked_stream<std::ostream> &mcout)
 {
  using namespace boost;
-  chrono::steady_clock::time_point tf = chrono::steady_clock::now() + chrono::seconds(5);
+  auto tf = chrono::steady_clock::now() + chrono::seconds(5);
  while (chrono::steady_clock::now() < tf)
  {
    mcout << "logging data to cout\n";
@@ -44,20 +44,20 @@ int main()
  externally_locked_stream<std::ostream> mcout(std::cout, terminal_mutex);
  externally_locked_stream<std::istream> mcin(std::cin, terminal_mutex);

-  scoped_thread<> t1(boost::thread(use_cerr, boost::ref(mcerr)));
-  scoped_thread<> t2(boost::thread(use_cout, boost::ref(mcout)));
+  scoped_thread<> t1(thread(use_cerr, boost::ref(mcerr)));
+  scoped_thread<> t2(thread(use_cout, boost::ref(mcout)));
  this_thread::sleep_for(chrono::seconds(2));
  std::string nm;
  {
    strict_lock<recursive_mutex> lk(terminal_mutex);
-    std::ostream & gcout = mcout.get(lk);
-    //std::istream & gcin = mcin.get(lk);
+    auto& gcout = mcout.hold(lk);
+    auto& gcin = mcin.hold(lk);
    gcout << "Enter name: ";
    //gcin >> nm;
  }
  t1.join();
  t2.join();
  mcout << nm << '\n';
-  return 0;
+  return 1;
 }

--- a/example/not_interleaved2.cpp
+++ b/example/not_interleaved2.cpp
@@ -1,61 +0,0 @@
-// (C) Copyright 2012 Howard Hinnant
-// (C) Copyright 2012 Vicente Botet
-//
-//  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)
-
-// adapted from the example given by Howard Hinnant in
-
-#define BOOST_THREAD_VERSION 4
-
-#include <iostream>
-#include <boost/thread/scoped_thread.hpp>
-#include <boost/thread/ostream_buffer.hpp>
-
-void use_cerr()
-{
-  using namespace boost;
-  chrono::steady_clock::time_point tf = chrono::steady_clock::now() + chrono::seconds(5);
-  int i = 0;
-  while (chrono::steady_clock::now() < tf)
-  {
-    ostream_buffer<std::ostream> mcerr(std::cerr);
-    mcerr.stream() << "logging data to cerr " << i++ << "\n";
-    this_thread::sleep_for(chrono::milliseconds(250));
-  }
-}
-
-void use_cout()
-{
-  using namespace boost;
-  chrono::steady_clock::time_point tf = chrono::steady_clock::now() + chrono::seconds(5);
-  int i = 0;
-  while (chrono::steady_clock::now() < tf)
-  {
-    ostream_buffer<std::ostream> mcout(std::cout);
-    mcout.stream() << "logging data to cout " << i++ << "\n";
-    this_thread::sleep_for(chrono::milliseconds(500));
-  }
-}
-
-int main()
-{
-  using namespace boost;
-
-  scoped_thread<> t1(&use_cerr);
-  scoped_thread<> t2(&use_cout);
-  this_thread::sleep_for(chrono::seconds(2));
-  std::string nm = "he, he\n";
-  {
-    ostream_buffer<std::ostream> mcout(std::cout);
-    mcout.stream() << "Enter name: \n";
-  }
-  t1.join();
-  t2.join();
-  {
-    ostream_buffer<std::ostream> mcout(std::cout);
-    mcout.stream() << nm;
-  }
-  return 0;
-}
-
--- a/example/once.cpp
+++ b/example/once.cpp
@@ -12,11 +12,10 @@

 int value=0;
 #ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11
-static boost::once_flag once;
-//static boost::once_flag once2 = BOOST_ONCE_INIT;
+boost::once_flag once;
 #else
-static boost::once_flag once = BOOST_ONCE_INIT;
-//static boost::once_flag once2 = once;
+boost::once_flag once = BOOST_ONCE_INIT;
+boost::once_flag once2 = once;
 #endif

 void init()
--- a/example/parallel_accumulate.cpp
+++ b/example/parallel_accumulate.cpp
@@ -1,102 +0,0 @@
-// Copyright (C) 2014 Vicente Botet
-//
-//  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/config.hpp>
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/future.hpp>
-
-#include <numeric>
-#include <algorithm>
-#include <functional>
-#include <iostream>
-#include <vector>
-
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-
-template<typename Iterator,typename T>
-struct accumulate_block
-{
-    //typedef T result_type;
-    T operator()(Iterator first,Iterator last)
-    {
-        return std::accumulate(first,last,T());
-    }
-};
-
-template<typename Iterator,typename T>
-T parallel_accumulate(Iterator first,Iterator last,T init)
-{
-    unsigned long const length=std::distance(first,last);
-
-    if(!length)
-        return init;
-
-    unsigned long const block_size=25;
-    unsigned long const num_blocks=(length+block_size-1)/block_size;
-
-    boost::csbl::vector<boost::future<T> > futures(num_blocks-1);
-    boost::basic_thread_pool pool;
-
-    Iterator block_start=first;
-    for(unsigned long i=0;i<(num_blocks-1);++i)
-    {
-        Iterator block_end=block_start;
-        std::advance(block_end,block_size);
-        futures[i]=boost::async(pool, accumulate_block<Iterator,T>(), block_start, block_end);
-        block_start=block_end;
-    }
-    T last_result=accumulate_block<Iterator,T>()(block_start,last);
-    T result=init;
-    for(unsigned long i=0;i<(num_blocks-1);++i)
-    {
-        result+=futures[i].get();
-    }
-    result += last_result;
-    return result;
-}
-
-
-int main()
-{
-  try
-  {
-    const int s = 1001;
-    std::vector<int> vec;
-    vec.reserve(s);
-    for (int i=0; i<s;++i)
-      vec.push_back(1);
-    int r = parallel_accumulate(vec.begin(), vec.end(),0);
-    std::cout << r << std::endl;
-
-  }
-  catch (std::exception& ex)
-  {
-    std::cout << "ERROR= " << ex.what() << "" << std::endl;
-    return 1;
-  }
-  catch (...)
-  {
-    std::cout << " ERROR= exception thrown" << std::endl;
-    return 2;
-  }
-  return 0;
-}
-
-#else
-///#warning "This compiler doesn't supports variadics"
-int main()
-{
-  return 0;
-}
-#endif
--- a/example/parallel_quick_sort.cpp
+++ b/example/parallel_quick_sort.cpp
@@ -1,110 +0,0 @@
-// Copyright (C) 2012-2013 Vicente Botet
-//
-//  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/config.hpp>
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/future.hpp>
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-
-#include <numeric>
-#include <algorithm>
-#include <functional>
-#include <iostream>
-#include <list>
-
-template<typename T>
-struct sorter
-{
-    boost::basic_thread_pool pool;
-    typedef std::list<T> return_type;
-
-    std::list<T> do_sort(std::list<T> chunk_data)
-    {
-        if(chunk_data.empty())
-        {
-            return chunk_data;
-        }
-
-        std::list<T> result;
-        result.splice(result.begin(),chunk_data, chunk_data.begin());
-        T const& partition_val=*result.begin();
-
-        typename std::list<T>::iterator divide_point=
-            std::partition(chunk_data.begin(), chunk_data.end(), [&](T const& val){return val<partition_val;});
-
-        std::list<T> new_lower_chunk;
-        new_lower_chunk.splice(new_lower_chunk.end(), chunk_data, chunk_data.begin(), divide_point);
-
-        boost::future<std::list<T> > new_lower = boost::async(pool, &sorter::do_sort, this, std::move(new_lower_chunk));
-        //boost::future<std::list<T> > new_lower = boost::async<return_type>(pool, &sorter::do_sort, this, std::move(new_lower_chunk));
-
-        std::list<T> new_higher(do_sort(chunk_data));
-
-        result.splice(result.end(),new_higher);
-        while(!new_lower.is_ready())
-        {
-            pool.schedule_one_or_yield();
-        }
-
-        result.splice(result.begin(),new_lower.get());
-        return result;
-    }
-};
-
-
-template<typename T>
-std::list<T> parallel_quick_sort(std::list<T>& input)
-{
-    if(input.empty())
-    {
-        return input;
-    }
-    sorter<T> s;
-
-    return s.do_sort(input);
-}
-
-
-int main()
-{
-  try
-  {
-    const int s = 101;
-    std::list<int> lst;
-    for (int i=0; i<s;++i)
-      lst.push_back(100-i);
-    std::list<int> r = parallel_quick_sort(lst);
-    for (std::list<int>::const_iterator it=r.begin(); it != r.end(); ++it)
-      std::cout << *it << std::endl;
-
-  }
-  catch (std::exception& ex)
-  {
-    std::cout << "ERROR= " << ex.what() << "" << std::endl;
-    return 1;
-  }
-  catch (...)
-  {
-    std::cout << " ERROR= exception thrown" << std::endl;
-    return 2;
-  }
-  return 0;
-}
-#else
-//#warning "This compiler doesn't supports variadics and move semantics"
-int main()
-{
-  return 0;
-}
-#endif
--- a/example/perf_condition_variable.cpp
+++ b/example/perf_condition_variable.cpp
@@ -143,7 +143,7 @@ namespace
  {
    typedef SharedData<Types> S;

-    auto best_producer_time = std::numeric_limits<Stopwatch::rep>::max BOOST_PREVENT_MACRO_SUBSTITUTION ();
+    auto best_producer_time = std::numeric_limits<Stopwatch::rep>::max();

    std::vector<std::thread> consumers
    { consumer_count };
@@ -165,7 +165,7 @@ namespace
      for (unsigned i = 0; i < consumer_count; ++i)
        consumers[i].join();

-      best_producer_time = std::min BOOST_PREVENT_MACRO_SUBSTITUTION (best_producer_time, shared_data.producer_time);
+      best_producer_time = std::min(best_producer_time, shared_data.producer_time);

    }

--- a/example/perf_shared_mutex.cpp
+++ b/example/perf_shared_mutex.cpp
@@ -1,72 +0,0 @@
-//  (C) Copyright 2013 Andrey
-//  (C) Copyright 2013 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)
-//
-// This performance test is based on the performance test provided by maxim.yegorushkin
-// at https://svn.boost.org/trac/boost/ticket/7422
-
-#define BOOST_THREAD_USES_CHRONO
-
-#include <iostream>
-#include <boost/thread/lock_types.hpp>
-#include <boost/thread/thread_only.hpp>
-#include <boost/chrono/chrono_io.hpp>
-
-#include <boost/thread/shared_mutex.hpp>
-
-using namespace boost;
-
-shared_mutex mtx;
-const int cycles = 10000;
-
-void shared()
-{
-  int cycle(0);
-  while (++cycle < cycles)
-  {
-    shared_lock<shared_mutex> lock(mtx);
-  }
-}
-
-void unique()
-{
-  int cycle(0);
-  while (++cycle < cycles)
-  {
-    unique_lock<shared_mutex> lock(mtx);
-  }
-}
-
-int main()
-{
-  boost::chrono::high_resolution_clock::duration best_time(std::numeric_limits<boost::chrono::high_resolution_clock::duration::rep>::max BOOST_PREVENT_MACRO_SUBSTITUTION ());
-  for (int i =100; i>0; --i) {
-    boost::chrono::high_resolution_clock clock;
-    boost::chrono::high_resolution_clock::time_point s1 = clock.now();
-    thread t0(shared);
-    thread t1(shared);
-    thread t2(unique);
-    //thread t11(shared);
-    //thread t12(shared);
-    //thread t13(shared);
-
-    t0.join();
-    t1.join();
-    t2.join();
-    //t11.join();
-//    t12.join();
-  //  t13.join();
-    boost::chrono::high_resolution_clock::time_point f1 = clock.now();
-    //std::cout << "     Time spent:" << (f1 - s1) << std::endl;
-    best_time = std::min BOOST_PREVENT_MACRO_SUBSTITUTION (best_time, f1 - s1);
-
-  }
-  std::cout << "Best Time spent:" << best_time << std::endl;
-  std::cout << "Time spent/cycle:" << best_time/cycles/3 << std::endl;
-
-  return 1;
-}
-
--- a/example/producer_consumer.cpp
+++ b/example/producer_consumer.cpp
@@ -1,147 +0,0 @@
-// (C) Copyright 2012 Howard Hinnant
-// (C) Copyright 2012 Vicente Botet
-//
-//  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)
-
-// adapted from the example given by Howard Hinnant in
-
-#include <boost/config.hpp>
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-#include <iostream>
-#include <boost/thread/scoped_thread.hpp>
-#ifdef XXXX
-#include <boost/thread/externally_locked_stream.hpp>
-    typedef  boost::externally_locked_stream<std::ostream> the_ostream;
-#else
-    typedef std::ostream the_ostream;
-    typedef std::istream the_istream;
-#endif
-#include <boost/thread/concurrent_queues/sync_queue.hpp>
-
-void producer(the_ostream & /*mos*/, boost::sync_queue<int> & sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      sbq.push(i);
-      //sbq << i;
-      //mos << "push(" << i << ") "<< sbq.size()<<"\n";
-      this_thread::sleep_for(chrono::milliseconds(200));
-    }
-  }
-  catch(sync_queue_is_closed&)
-  {
-    //mos << "closed !!!\n";
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-
-void consumer(
-    the_ostream & /*mos*/,
-    boost::sync_queue<int> & sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      sbq.pull(r);
-      //sbq >> r;
-      //mos << i << " pull(" << r << ") "<< sbq.size()<<"\n";
-
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(sync_queue_is_closed&)
-  {
-    //mos << "closed !!!\n";
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-void consumer2(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      queue_op_status st = sbq.try_pull(r);
-      if (queue_op_status::closed == st) break;
-      if (queue_op_status::success == st) {
-        //mos << i << " pull(" << r << ")\n";
-      }
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-void consumer3(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      queue_op_status res = sbq.wait_pull(r);
-      if (res==queue_op_status::closed) break;
-      //mos << i << " wait_pull(" << r << ")\n";
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-
-int main()
-{
-  using namespace boost;
-
-#ifdef XXXX
-  recursive_mutex terminal_mutex;
-
-  externally_locked_stream<std::ostream> mcerr(std::cerr, terminal_mutex);
-  externally_locked_stream<std::ostream> mcout(std::cout, terminal_mutex);
-  externally_locked_stream<std::istream> mcin(std::cin, terminal_mutex);
-#else
-  the_ostream &mcerr = std::cout;
-  the_ostream &mcout = std::cerr;
-  //the_istream &mcin = std::cin;
-#endif
-
-  sync_queue<int> sbq;
-
-  {
-    mcout << "begin of main" << std::endl;
-    scoped_thread<> t11(boost::thread(producer, boost::ref(mcerr), boost::ref(sbq)));
-    scoped_thread<> t12(boost::thread(producer, boost::ref(mcerr), boost::ref(sbq)));
-    scoped_thread<> t2(boost::thread(consumer, boost::ref(mcout), boost::ref(sbq)));
-
-    this_thread::sleep_for(chrono::seconds(1));
-
-    mcout << "closed()" << std::endl;
-    sbq.close();
-    mcout << "closed()" << std::endl;
-
-  } // all threads joined here.
-  mcout << "end of main" << std::endl;
-  return 0;
-}
-
--- a/example/producer_consumer2.cpp
+++ b/example/producer_consumer2.cpp
@@ -1,150 +0,0 @@
-// (C) Copyright 2014 Vicente Botet
-//
-//  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)
-
-// adapted from the example given by Howard Hinnant in
-
-#include <boost/config.hpp>
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-#include <iostream>
-#include <boost/thread/scoped_thread.hpp>
-#ifdef XXXX
-#include <boost/thread/externally_locked_stream.hpp>
-    typedef  boost::externally_locked_stream<std::ostream> the_ostream;
-#else
-    typedef std::ostream the_ostream;
-    typedef std::istream the_istream;
-#endif
-#include <boost/thread/concurrent_queues/sync_queue.hpp>
-#include <boost/thread/concurrent_queues/queue_adaptor.hpp>
-#include <boost/thread/concurrent_queues/queue_views.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits.hpp>
-
-void producer(the_ostream &/*mos*/, boost::queue_back<int> sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      sbq.push(i);
-      //sbq << i;
-      //mos << "push(" << i << ") " << sbq.size() <<"\n";
-      this_thread::sleep_for(chrono::milliseconds(200));
-    }
-  }
-  catch(sync_queue_is_closed&)
-  {
-    //mos << "closed !!!\n";
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-
-void consumer(
-    the_ostream &/*mos*/,
-    boost::queue_front<int> sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      sbq.pull(r);
-      //sbq >> r;
-      //mos << i << " pull(" << r << ") " << sbq.size()  <<"\n";
-
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(sync_queue_is_closed&)
-  {
-    //mos << "closed !!!\n";
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-void consumer2(the_ostream &/*mos*/, boost::queue_front<int> sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      queue_op_status st = sbq.try_pull(r);
-      if (queue_op_status::closed == st) break;
-      if (queue_op_status::success == st) {
-        //mos << i << " try_pull(" << r << ")\n";
-      }
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-void consumer3(the_ostream &/*mos*/, boost::queue_front<int> sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      queue_op_status res = sbq.wait_pull(r);
-      if (res==queue_op_status::closed) break;
-      //mos << i << " wait_pull(" << r << ")\n";
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-
-int main()
-{
-  using namespace boost;
-
-#ifdef XXXX
-  recursive_mutex terminal_mutex;
-
-  externally_locked_stream<std::ostream> mcerr(std::cerr, terminal_mutex);
-  externally_locked_stream<std::ostream> mcout(std::cout, terminal_mutex);
-  externally_locked_stream<std::istream> mcin(std::cin, terminal_mutex);
-#else
-  the_ostream &mcerr = std::cout;
-  the_ostream &mcout = std::cerr;
-  //the_istream &mcin = std::cin;
-#endif
-
-  queue_adaptor<sync_queue<int> > sbq;
-
-  {
-    mcout << "begin of main" << std::endl;
-    scoped_thread<> t11(boost::thread(producer, boost::ref(mcerr), concurrent::queue_back<int>(sbq)));
-    scoped_thread<> t12(boost::thread(producer, boost::ref(mcerr), concurrent::queue_back<int>(sbq)));
-    scoped_thread<> t2(boost::thread(consumer, boost::ref(mcout), concurrent::queue_front<int>(sbq)));
-
-    this_thread::sleep_for(chrono::seconds(1));
-
-    mcout << "closed()" << std::endl;
-    sbq.close();
-    mcout << "closed()" << std::endl;
-
-  } // all threads joined here.
-  mcout << "end of main" << std::endl;
-  return 0;
-}
-
--- a/example/producer_consumer_bounded.cpp
+++ b/example/producer_consumer_bounded.cpp
@@ -1,146 +0,0 @@
-// (C) Copyright 2012 Howard Hinnant
-// (C) Copyright 2012 Vicente Botet
-//
-//  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)
-
-// adapted from the example given by Howard Hinnant in
-
-#include <boost/config.hpp>
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-//#define XXXX
-
-#include <iostream>
-#include <boost/thread/scoped_thread.hpp>
-#ifdef XXXX
-#include <boost/thread/externally_locked_stream.hpp>
-    typedef  boost::externally_locked_stream<std::ostream> the_ostream;
-#else
-    typedef std::ostream the_ostream;
-    typedef std::istream the_istream;
-#endif
-
-#include <boost/thread/sync_bounded_queue.hpp>
-
-void producer(the_ostream &/*mos*/, boost::sync_bounded_queue<int> & sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      sbq.push_back(i);
-      //sbq << i;
-      //mos << "push_back(" << i << ") "<< sbq.size()<<"\n";
-      this_thread::sleep_for(chrono::milliseconds(200));
-    }
-  }
-  catch(sync_queue_is_closed&)
-  {
-    //mos << "closed !!!\n";
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-
-void consumer(the_ostream &/*mos*/, boost::sync_bounded_queue<int> & sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      sbq.pull_front(r);
-      //sbq >> r;
-      //mos << i << " pull_front(" << r << ") "<< sbq.size()<<"\n";
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(sync_queue_is_closed&)
-  {
-    //mos << "closed !!!\n";
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-void consumer2(the_ostream &/*mos*/,  boost::sync_bounded_queue<int> & sbq)
-{
-  using namespace boost;
-  try {
-    for(int i=0; ;++i)
-    {
-      int r;
-      queue_op_status st = sbq.try_pull_front(r);
-      if (queue_op_status::closed == st) break;
-      if (queue_op_status::success == st) {
-        //mos << i << " pull(" << r << ")\n";
-      }
-      this_thread::sleep_for(chrono::milliseconds(250));
-    }
-  }
-  catch(...)
-  {
-    //mos << "exception !!!\n";
-  }
-}
-//void consumer3(the_ostream &mos, boost::sync_bounded_queue<int> & sbq)
-//{
-//  using namespace boost;
-//  bool closed=false;
-//  try {
-//    for(int i=0; ;++i)
-//    {
-//      int r;
-//      queue_op_status res = sbq.wait_and_pull(r);
-//      if (res==queue_op_status::closed) break;
-//      //mos << i << " wait_and_pull(" << r << ")\n";
-//      this_thread::sleep_for(chrono::milliseconds(250));
-//    }
-//  }
-//  catch(...)
-//  {
-//    //mos << "exception !!!\n";
-//  }
-//}
-
-int main()
-{
-  using namespace boost;
-#ifdef XXXX
-  recursive_mutex terminal_mutex;
-
-  externally_locked_stream<std::ostream> mcerr(std::cerr, terminal_mutex);
-  externally_locked_stream<std::ostream> mcout(std::cout, terminal_mutex);
-  externally_locked_stream<std::istream> mcin(std::cin, terminal_mutex);
-#else
-  the_ostream &mcerr = std::cout;
-  the_ostream &mcout = std::cerr;
-  //the_istream &mcin = std::cin;
-#endif
-
-  sync_bounded_queue<int> sbq(10);
-
-  {
-    mcout << "begin of main" << std::endl;
-    scoped_thread<> t11(boost::thread(producer, boost::ref(mcerr), boost::ref(sbq)));
-    scoped_thread<> t12(boost::thread(producer, boost::ref(mcerr), boost::ref(sbq)));
-    scoped_thread<> t2(boost::thread(consumer, boost::ref(mcout), boost::ref(sbq)));
-
-    this_thread::sleep_for(chrono::seconds(1));
-
-    sbq.close();
-    mcout << "closed()" << std::endl;
-
-  } // all threads joined here.
-  mcout << "end of main" << std::endl;
-  return 0;
-}
-
--- a/example/recursive_mutex.cpp
+++ b/example/recursive_mutex.cpp
@@ -32,7 +32,7 @@ counter c;

 void change_count()
 {
-    //std::cout << "count == " << c.increment() << std::endl;
+    std::cout << "count == " << c.increment() << std::endl;
 }

 int main(int, char*[])
--- a/example/scoped_thread.cpp
+++ b/example/scoped_thread.cpp
@@ -13,9 +13,6 @@ void do_something(int& i)
 {
  ++i;
 }
-void f(int, int)
-{
-}

 struct func
 {
@@ -39,45 +36,34 @@ void do_something_in_current_thread()
 {
 }

+//void do_something_with_current_thread(boost::thread&& th)
+//{
+//  th.join();
+//}
+
 int main()
 {
  {
-    int some_local_state=0;
+    int some_local_state;
    boost::strict_scoped_thread<> t( (boost::thread(func(some_local_state))));

    do_something_in_current_thread();
  }
  {
-    int some_local_state=0;
+    int some_local_state;
    boost::thread t(( func(some_local_state) ));
    boost::strict_scoped_thread<> g( (boost::move(t)) );

    do_something_in_current_thread();
  }
-  {
-    int some_local_state=0;
-    boost::scoped_thread<> t( (boost::thread(func(some_local_state))));
-
-    if (t.joinable())
-      t.join();
-    else
-      do_something_in_current_thread();
-  }
-#if 0
-  {
-    int some_local_state=0;
-    boost::thread t(( func(some_local_state) ));
-    boost::scoped_thread<> g( (boost::move(t)) );
-    if (g.joinable())
-      g.detach();
-
-    do_something_in_current_thread();
-  }
-#endif
-  {
-    boost::scoped_thread<> g( &f, 1, 2 );
-    do_something_in_current_thread();
-  }
+//  {
+//    int some_local_state;
+//    boost::thread t(( func(some_local_state) ));
+//    boost::strict_scoped_thread<> g( (boost::move(t)) );
+//
+//    do_something_in_current_thread();
+//    do_something_with_current_thread(boost::thread(g));
+//  }
  return 0;
 }

--- a/example/serial_executor.cpp
+++ b/example/serial_executor.cpp
@@ -1,107 +0,0 @@
-// Copyright (C) 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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-
-#include <boost/thread/caller_context.hpp>
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/executors/serial_executor.hpp>
-#include <boost/thread/executors/executor.hpp>
-#include <boost/thread/executors/executor_adaptor.hpp>
-#include <boost/thread/executor.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <string>
-#include <iostream>
-
-void p1()
-{
-  //std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(30));
-  //std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-void p2()
-{
-  //std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
-  //std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-int f1()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(1));
-  return 1;
-}
-int f2(int i)
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(2));
-  return i + 1;
-}
-
-void submit_some(boost::serial_executor& tp)
-{
-  for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
-    tp.submit(&p2);
-  }
-  for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
-    tp.submit(&p1);
-  }
-
-}
-
-
-void at_th_entry(boost::basic_thread_pool& )
-{
-
-}
-
-int test_executor_adaptor()
-{
-  {
-    try
-    {
-
-#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      {
-        boost::basic_thread_pool ea1(4);
-        boost::serial_executor ea2(ea1);
-        submit_some(ea2);
-        boost::this_thread::sleep_for(boost::chrono::seconds(10));
-      }
-#endif
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << "ERROR= " << ex.what() << "" << std::endl;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << " ERROR= exception thrown" << std::endl;
-      return 2;
-    }
-  }
-  return 0;
-}
-
-
-int main()
-{
-  return test_executor_adaptor();
-}
--- a/example/serial_executor_cont.cpp
+++ b/example/serial_executor_cont.cpp
@@ -1,113 +0,0 @@
-// Copyright (C) 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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-
-#include <boost/thread/caller_context.hpp>
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/executors/serial_executor_cont.hpp>
-#include <boost/thread/executors/executor.hpp>
-#include <boost/thread/executors/executor_adaptor.hpp>
-#include <boost/thread/executor.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <string>
-#include <iostream>
-
-void p1()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(30));
-  std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-void p2()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
-  std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-int f1()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(1));
-  return 1;
-}
-int f2(int i)
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::seconds(2));
-  return i + 1;
-}
-
-void submit_some(boost::serial_executor_cont& tp)
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
-    tp.submit(&p2);
-  }
-  for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
-    tp.submit(&p1);
-  }
-  std::cout << BOOST_CONTEXTOF << std::endl;
-
-}
-
-
-void at_th_entry(boost::basic_thread_pool& )
-{
-
-}
-
-int test_executor_adaptor()
-{
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  {
-    try
-    {
-
-#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      // std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::basic_thread_pool ea1(4);
-        boost::serial_executor_cont ea2(ea1);
-        submit_some(ea2);
-        boost::this_thread::sleep_for(boost::chrono::seconds(10));
-      }
-#endif
-      // std::cout << BOOST_CONTEXTOF << std::endl;
-    }
-    catch (std::exception& ex)
-    {
-      std::cout << "ERROR= " << ex.what() << "" << std::endl;
-      return 1;
-    }
-    catch (...)
-    {
-      std::cout << " ERROR= exception thrown" << std::endl;
-      return 2;
-    }
-  }
-  // std::cout << BOOST_CONTEXTOF << std::endl;
-  return 0;
-}
-
-
-int main()
-{
-  return test_executor_adaptor();
-}
--- a/example/shared_monitor.cpp
+++ b/example/shared_monitor.cpp
@@ -7,7 +7,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/lock_algorithms.hpp>
-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #if defined BOOST_THREAD_DONT_USE_CHRONO
 #include <boost/chrono/chrono_io.hpp>
 #endif
--- a/example/shared_mutex.cpp
+++ b/example/shared_mutex.cpp
@@ -11,7 +11,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/lock_algorithms.hpp>
-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #include <vector>

 #if defined BOOST_THREAD_USES_CHRONO
--- a/example/starvephil.cpp
+++ b/example/starvephil.cpp
@@ -8,7 +8,7 @@

 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <iostream>
 #include <time.h>
--- a/example/std_scoped_thread.cpp
+++ b/example/std_scoped_thread.cpp
@@ -1,112 +0,0 @@
-// (C) Copyright 2009-2012 Anthony Williams
-// (C) Copyright 2012 Vicente Botet
-//
-//  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)
-
-#if __cplusplus < 201103L
-int main()
-{
-  return 0;
-}
-#else
-
-#define BOOST_THREAD_VERSION 3
-
-#include <iostream>
-#include <boost/thread/scoped_thread.hpp>
-#include <thread>
-#include <cassert>
-
-void do_something(int& i)
-{
-  ++i;
-}
-void f(int, int)
-{
-}
-
-struct func
-{
-  int& i;
-
-  func(int& i_) :
-    i(i_)
-  {
-  }
-
-  void operator()()
-  {
-    for (unsigned j = 0; j < 1000000; ++j)
-    {
-      do_something(i);
-    }
-  }
-};
-
-void do_something_in_current_thread()
-{
-}
-
-using strict_scoped_thread = boost::strict_scoped_thread<boost::join_if_joinable, std::thread>;
-using scoped_thread = boost::scoped_thread<boost::join_if_joinable, std::thread>;
-
-int main()
-{
-  {
-    int some_local_state=0;
-    strict_scoped_thread t( (std::thread(func(some_local_state))));
-
-    do_something_in_current_thread();
-  }
-  {
-    int some_local_state=0;
-    std::thread t(( func(some_local_state) ));
-    strict_scoped_thread g( (boost::move(t)) );
-
-    do_something_in_current_thread();
-  }
-  {
-    int some_local_state=0;
-    std::thread t(( func(some_local_state) ));
-    strict_scoped_thread g( (std::move(t)) );
-
-    do_something_in_current_thread();
-  }
-  {
-    int some_local_state=1;
-    scoped_thread t( (std::thread(func(some_local_state))));
-
-    if (t.joinable()) {
-      t.join();
-      assert( ! t.joinable() );
-    }
-    else
-      do_something_in_current_thread();
-  }
-#if 0
-  try
-  {
-    int some_local_state=1;
-    std::thread t(( func(some_local_state) ));
-    scoped_thread g( (boost::move(t)) );
-    if (g.joinable()) {
-      // CLANG crash here
-      g.detach();
-      assert( ! g.joinable() );
-    }
-
-    do_something_in_current_thread();
-  }
-  catch (...) {
-    assert( false);
-  }
-#endif
-  {
-    scoped_thread g( &f, 1, 2 );
-    do_something_in_current_thread();
-  }
-  return 0;
-}
-
-#endif
--- a/example/std_thread_guard.cpp
+++ b/example/std_thread_guard.cpp
@@ -1,66 +0,0 @@
-// (C) Copyright 2009-2012 Anthony Williams
-// (C) Copyright 2012 Vicente Botet
-//
-//  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)
-
-#if __cplusplus < 201103L
-int main()
-{
-  return 0;
-}
-#else
-#include <iostream>
-#include <string>
-#include <boost/thread/thread_only.hpp>
-#include <boost/thread/thread_guard.hpp>
-#include <thread>
-
-void do_something(int& i)
-{
-    ++i;
-}
-
-struct func
-{
-    int& i;
-
-    func(int& i_):i(i_){}
-
-    void operator()()
-    {
-        for(unsigned j=0;j<1000000;++j)
-        {
-            do_something(i);
-        }
-    }
-
-private:
-    func& operator=(func const&);
-
-};
-
-void do_something_in_current_thread()
-{}
-
-using thread_guard = boost::thread_guard<boost::join_if_joinable, std::thread>;
-
-
-void f()
-{
-    int some_local_state;
-    func my_func(some_local_state);
-    std::thread t(my_func);
-    thread_guard g(t);
-
-    do_something_in_current_thread();
-}
-
-int main()
-{
-    f();
-    return 0;
-}
-
-
-#endif
--- a/example/synchronized_person.cpp
+++ b/example/synchronized_person.cpp
@@ -255,28 +255,5 @@ int main()
    lk2->SetName("Javier");
    lk3->SetName("Matias");
  }
-#if ! defined BOOST_NO_CXX11_AUTO_DECLARATIONS \
-&& ! defined(BOOST_THREAD_NO_SYNCHRONIZE)
-  {
-    Person3_ts p1(1);
-    Person3_ts p2(2);
-    Person3_ts p3(3);
-
-    auto t  = boost::synchronize(p1,p2,p3);
-    std::get<0>(t)->SetName("Carmen");
-    std::get<1>(t)->SetName("Javier");
-    std::get<2>(t)->SetName("Matias");
-  }
-  {
-    const Person3_ts p1(1);
-    Person3_ts p2(2);
-    const Person3_ts p3(3);
-
-    auto t  = boost::synchronize(p1,p2,p3);
-    //std::get<0>(t)->SetName("Carmen");
-    std::get<1>(t)->SetName("Javier");
-    //std::get<2>(t)->SetName("Matias");
-  }
-#endif
  return 0;
 }
--- a/example/synchronized_value.cpp
+++ b/example/synchronized_value.cpp
@@ -10,15 +10,15 @@
 #include <string>
 #include <boost/thread/synchronized_value.hpp>

-  void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
-  {
-    boost::strict_lock_ptr<std::string> u=path.synchronize();
+void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
+{
+  boost::strict_lock_ptr<std::string> u=path.synchronize();

-    if(u->empty() || (*u->rbegin()!='/'))
-    {
-      *u+='/';
-    }
+  if(u->empty() || (*u->rbegin()!='/'))
+  {
+    *u+='/';
  }
+}

 void f(const boost::synchronized_value<int> &v) {
  std::cout<<"v="<<*v<<std::endl;
@@ -80,68 +80,6 @@ int main()
    addTrailingSlashIfMissing(s);
    std::cout<<"s="<<std::string(*s)<<std::endl;
  }
-  {
-    boost::synchronized_value<std::string> s;
-    s = std::string("foo/");
-    std::cout<<"ss="<< s << std::endl;
-  }
-  {
-    boost::synchronized_value<std::string> s;
-    s = "foo/";
-    std::cout<<"ss="<< s << std::endl;
-  }
-  {
-    boost::synchronized_value<std::string> s1("a");
-    boost::synchronized_value<std::string> s2;
-    s2=s1;
-    std::cout<<"s1="<< s1 << std::endl;
-    std::cout<<"s2="<< s2 << std::endl;
-  }
-  {
-    boost::synchronized_value<std::string> s1("a");
-    boost::synchronized_value<std::string> s2("b");
-    std::cout<<"s1="<< s1 << std::endl;
-    std::cout<<"s2="<< s2 << std::endl;
-    swap(s1,s2);
-    std::cout<<"s1="<< s1 << std::endl;
-    std::cout<<"s2="<< s2 << std::endl;
-  }
-#if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-  {
-    boost::synchronized_value<std::string> sts("a");
-    std::string s(sts);
-    std::cout<<"ssts="<< s << std::endl;
-  }
-#endif
-  {
-    boost::synchronized_value<int> s1(1);
-    boost::synchronized_value<int> s2(1);
-    BOOST_ASSERT(s1==s2);
-    BOOST_ASSERT(s1<=s2);
-    BOOST_ASSERT(s1>=s2);
-    BOOST_ASSERT(s1==1);
-    BOOST_ASSERT(s1<=1);
-    BOOST_ASSERT(s1>=1);
-  }
-  {
-    boost::synchronized_value<int> s1(1);
-    boost::synchronized_value<int> s2(2);
-    BOOST_ASSERT(s1!=s2);
-    BOOST_ASSERT(s1!=2);
-    BOOST_ASSERT(2!=s1);
-  }
-  {
-    boost::synchronized_value<int> s1(1);
-    boost::synchronized_value<int> s2(2);
-    BOOST_ASSERT(s1<s2);
-    BOOST_ASSERT(s1<=s2);
-    BOOST_ASSERT(s2>s1);
-    BOOST_ASSERT(s2>=s1);
-    BOOST_ASSERT(s1<2);
-    BOOST_ASSERT(s1<=2);
-    BOOST_ASSERT(s2>1);
-    BOOST_ASSERT(s2>=1);
-  }
  return 0;
 }

--- a/example/tennis.cpp
+++ b/example/tennis.cpp
@@ -4,12 +4,9 @@
 //  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)

-#undef BOOST_THREAD_VERSION
-#define BOOST_THREAD_VERSION 2
-
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <iostream>

@@ -32,25 +29,26 @@ int state;
 boost::mutex mutex;
 boost::condition cond;

-const char* player_name(int state)
+char* player_name(int state)
 {
    if (state == PLAYER_A)
        return "PLAYER-A";
    if (state == PLAYER_B)
        return "PLAYER-B";
    throw "bad player";
-    //return 0;
+    return 0;
 }

-void player(int active)
+void player(void* param)
 {
    boost::unique_lock<boost::mutex> lock(mutex);

+    int active = (int)param;
    int other = active == PLAYER_A ? PLAYER_B : PLAYER_A;

    while (state < GAME_OVER)
    {
-        //std::cout << player_name(active) << ": Play." << std::endl;
+        std::cout << player_name(active) << ": Play." << std::endl;
        state = other;
        cond.notify_all();
        do
@@ -98,12 +96,12 @@ private:
    void* _param;
 };

-int main()
+int main(int argc, char* argv[])
 {
    state = START;

-    boost::thread thrda(&player, PLAYER_A);
-    boost::thread thrdb(&player, PLAYER_B);
+    boost::thread thrda(thread_adapter(&player, (void*)PLAYER_A));
+    boost::thread thrdb(thread_adapter(&player, (void*)PLAYER_B));

    boost::xtime xt;
    boost::xtime_get(&xt, boost::TIME_UTC_);
@@ -114,7 +112,7 @@ int main()
        std::cout << "---Noise ON..." << std::endl;
    }

-    for (int i = 0; i < 10; ++i)
+    for (int i = 0; i < 1000000000; ++i)
        cond.notify_all();

    {
--- a/example/this_executor.cpp
+++ b/example/this_executor.cpp
@@ -1,86 +0,0 @@
-// Copyright (C) 2014 Vicente Botet
-//
-//  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/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-
-#include <boost/thread/caller_context.hpp>
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/thread/executors/generic_executor_ref.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-#include <string>
-#include <iostream>
-
-#include <boost/thread/caller_context.hpp>
-
-struct current_executor_state_type {
-  boost::shared_ptr<boost::generic_executor_ref> current_executor_ptr;
-
-  template <class Executor>
-  void set_current_executor(Executor& ex)
-  {
-    current_executor_ptr = boost::make_shared<boost::generic_executor_ref>(ex);
-  }
-  boost::generic_executor_ref current_executor()
-  {
-    if (current_executor_ptr)
-      return *current_executor_ptr;
-    else
-      throw "";
-  }
-};
-
-thread_local current_executor_state_type current_executor_state;
-
-boost::generic_executor_ref current_executor()
-{
-  return current_executor_state.current_executor();
-}
-
-void p2()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-  std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-
-void p1()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-  current_executor().submit(&p2);
-  boost::this_thread::sleep_for(boost::chrono::milliseconds(400));
-  std::cout << BOOST_CONTEXTOF << std::endl;
-}
-
-int main()
-{
-  std::cout << BOOST_CONTEXTOF << std::endl;
-
-  boost::basic_thread_pool tp(4,
-      // at_thread_entry
-      [](boost::basic_thread_pool& pool)
-      {
-        current_executor_state.set_current_executor(pool);
-      }
-  );
-
-  tp.submit(&p1);
-
-  boost::this_thread::sleep_for(boost::chrono::seconds(5));
-
-  std::cout << BOOST_CONTEXTOF << std::endl;
-
-  return 1;
-
-}
--- a/example/thread.cpp
+++ b/example/thread.cpp
@@ -6,7 +6,7 @@

 #define BOOST_THREAD_VERSION 2

-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <iostream>

--- a/example/thread_group.cpp
+++ b/example/thread_group.cpp
@@ -59,7 +59,6 @@ int main()
    threads.remove_thread(th);
    BOOST_TEST(! threads.is_thread_in(th));
    th->join();
-    delete th;
  }
  {
    {
--- a/example/thread_guard.cpp
+++ b/example/thread_guard.cpp
@@ -7,7 +7,7 @@

 #include <iostream>
 #include <string>
-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #include <boost/thread/thread_guard.hpp>

 void do_something(int& i)
--- a/example/thread_pool.cpp
+++ b/example/thread_pool.cpp
@@ -1,73 +0,0 @@
-// Copyright (C) 2012-2013 Vicente Botet
-//
-//  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/config.hpp>
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#include <boost/thread/detail/log.hpp>
-#include <boost/thread/executors/basic_thread_pool.hpp>
-#include <boost/assert.hpp>
-#include <string>
-
-void p1()
-{
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << " P1" << BOOST_THREAD_END_LOG;
-}
-
-void p2()
-{
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << " P2" << BOOST_THREAD_END_LOG;
-}
-
-void submit_some(boost::basic_thread_pool& tp) {
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-}
-
-
-int main()
-{
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << " <MAIN" << BOOST_THREAD_END_LOG;
-  {
-    try
-    {
-      boost::basic_thread_pool tp;
-      submit_some(tp);
-    }
-    catch (std::exception& ex)
-    {
-      BOOST_THREAD_LOG
-        << "ERRORRRRR " << ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      BOOST_THREAD_LOG
-        << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << "MAIN>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
--- a/example/tss.cpp
+++ b/example/tss.cpp
@@ -24,7 +24,6 @@ void thread_proc()
        increment();
        int* p = value.get();
        assert(*p == i+1);
-        (void)(p);
    }
 }

--- a/example/user_scheduler.cpp
+++ b/example/user_scheduler.cpp
@@ -1,75 +0,0 @@
-// Copyright (C) 2013 Vicente Botet
-//
-//  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/config.hpp>
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_USES_LOG_THREAD_ID
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-#include <boost/thread/detail/log.hpp>
-#include <boost/thread/executors/loop_executor.hpp>
-#include <boost/assert.hpp>
-#include <boost/thread/thread_only.hpp>
-#include <string>
-
-void p1()
-{
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << " P1" << BOOST_THREAD_END_LOG;
-}
-
-void p2()
-{
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << " P2" << BOOST_THREAD_END_LOG;
-}
-
-void submit_some(boost::loop_executor& tp) {
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-  tp.submit(&p1);
-  tp.submit(&p2);
-}
-
-int main()
-{
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << " <MAIN" << BOOST_THREAD_END_LOG;
-  {
-    try
-    {
-      boost::loop_executor tp;
-      submit_some(tp);
-      tp.run_queued_closures();
-      submit_some(tp);
-      tp.run_queued_closures();
-    }
-    catch (std::exception& ex)
-    {
-      BOOST_THREAD_LOG
-        << "ERRORRRRR " << ex.what() << "" << BOOST_THREAD_END_LOG;
-      return 1;
-    }
-    catch (...)
-    {
-      BOOST_THREAD_LOG
-        << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
-      return 2;
-    }
-  }
-
-  BOOST_THREAD_LOG
-    << boost::this_thread::get_id()  << "MAIN>" << BOOST_THREAD_END_LOG;
-  return 0;
-}
--- a/example/with_lock_guard.cpp
+++ b/example/with_lock_guard.cpp
@@ -1,53 +0,0 @@
-// (C) Copyright 2013 Ruslan Baratov
-// Copyright (C) 2014 Vicente Botet
-//
-// 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 www.boost.org/libs/thread for documentation.
-
-#define BOOST_THREAD_VERSION 4
-
-#include <iostream> // std::cout
-#include <boost/thread/scoped_thread.hpp>
-#include <boost/thread/with_lock_guard.hpp>
-
-boost::mutex m; // protection for 'x' and 'std::cout'
-int x;
-
-#if defined(BOOST_NO_CXX11_LAMBDAS)  || (defined BOOST_MSVC && _MSC_VER < 1700)
-void print_x() {
-  ++x;
-  std::cout << "x = " << x << std::endl;
-}
-
-void job() {
-  for (int i = 0; i < 10; ++i) {
-    boost::with_lock_guard(m, print_x);
-    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
-  }
-}
-#else
-void job() {
-  for (int i = 0; i < 10; ++i) {
-    boost::with_lock_guard(
-        m,
-        []() {
-          ++x;
-          std::cout << "x = " << x << std::endl;
-        }
-    );
-    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
-  }
-}
-#endif
-
-int main() {
-#if defined(BOOST_NO_CXX11_LAMBDAS)  || (defined BOOST_MSVC && _MSC_VER < 1700)
-  std::cout << "(no lambdas)" << std::endl;
-#endif
-  boost::scoped_thread<> thread_1((boost::thread(job)));
-  boost::scoped_thread<> thread_2((boost::thread(job)));
-  boost::scoped_thread<> thread_3((boost::thread(job)));
-  return 0;
-}
--- a/example/xtime.cpp
+++ b/example/xtime.cpp
@@ -6,7 +6,7 @@

 #define BOOST_THREAD_VERSION 2

-#include <boost/thread/thread_only.hpp>
+#include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>

 int main()
--- a/include/boost/detail/atomic_redef_macros.hpp
+++ b/include/boost/detail/atomic_redef_macros.hpp
@@ -1,19 +0,0 @@
-// Copyright (C) 2013 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)
-
-
-#if defined(BOOST_INTEL)
-
-#pragma pop_macro("atomic_compare_exchange")
-#pragma pop_macro("atomic_compare_exchange_explicit")
-#pragma pop_macro("atomic_exchange")
-#pragma pop_macro("atomic_exchange_explicit")
-#pragma pop_macro("atomic_is_lock_free")
-#pragma pop_macro("atomic_load")
-#pragma pop_macro("atomic_load_explicit")
-#pragma pop_macro("atomic_store")
-#pragma pop_macro("atomic_store_explicit")
-
-#endif // #if defined(BOOST_INTEL)
--- a/include/boost/detail/atomic_undef_macros.hpp
+++ b/include/boost/detail/atomic_undef_macros.hpp
@@ -1,39 +0,0 @@
-// Copyright (C) 2013 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)
-
-
-#if defined(BOOST_INTEL)
-
-#pragma push_macro("atomic_compare_exchange")
-#undef atomic_compare_exchange
-
-#pragma push_macro("atomic_compare_exchange_explicit")
-#undef atomic_compare_exchange_explicit
-
-#pragma push_macro("atomic_exchange")
-#undef atomic_exchange
-
-#pragma push_macro("atomic_exchange_explicit")
-#undef atomic_exchange_explicit
-
-#pragma push_macro("atomic_is_lock_free")
-#undef atomic_is_lock_free
-
-#pragma push_macro("atomic_load")
-#undef atomic_load
-
-#pragma push_macro("atomic_load_explicit")
-#undef atomic_load_explicit
-
-#pragma push_macro("atomic_store")
-#undef atomic_store
-
-#pragma push_macro("atomic_store_explicit")
-#undef atomic_store_explicit
-
-
-#endif // #if defined(BOOST_INTEL)
-
-
--- a/include/boost/thread/barrier.hpp
+++ b/include/boost/thread/barrier.hpp
@@ -1,7 +1,6 @@
 // Copyright (C) 2002-2003
 // David Moore, William E. Kempf
 // Copyright (C) 2007-8 Anthony Williams
-// (C) Copyright 2013 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)
@@ -10,245 +9,56 @@
 #define BOOST_BARRIER_JDM030602_HPP

 #include <boost/thread/detail/config.hpp>
-#include <boost/thread/detail/delete.hpp>
-
 #include <boost/throw_exception.hpp>
+
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/condition_variable.hpp>
 #include <string>
 #include <stdexcept>
-#include <boost/thread/detail/nullary_function.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/utility/result_of.hpp>

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
-  namespace thread_detail
-  {
-    typedef detail::nullary_function<void()> void_completion_function;
-    typedef detail::nullary_function<size_t()> size_completion_function;

-    struct default_barrier_reseter
+    class barrier
    {
-      unsigned int size_;
-      default_barrier_reseter(unsigned int size) :
-        size_(size)
-      {
-      }
-      BOOST_THREAD_MOVABLE(default_barrier_reseter)
-      //BOOST_THREAD_COPYABLE_AND_MOVABLE(default_barrier_reseter)
+    public:
+        barrier(unsigned int count)
+            : m_threshold(count), m_count(count), m_generation(0)
+        {
+            if (count == 0)
+                boost::throw_exception(thread_exception(system::errc::invalid_argument, "barrier constructor: count cannot be zero."));
+        }

-      default_barrier_reseter(default_barrier_reseter const& other) BOOST_NOEXCEPT :
-      size_(other.size_)
-      {
-      }
-      default_barrier_reseter(BOOST_THREAD_RV_REF(default_barrier_reseter) other) BOOST_NOEXCEPT :
-      size_(BOOST_THREAD_RV(other).size_)
-      {
-      }
+        bool wait()
+        {
+            boost::unique_lock<boost::mutex> lock(m_mutex);
+            unsigned int gen = m_generation;

-      unsigned int operator()()
-      {
-        return size_;
-      }
+            if (--m_count == 0)
+            {
+                m_generation++;
+                m_count = m_threshold;
+                m_cond.notify_all();
+                return true;
+            }
+
+            while (gen == m_generation)
+                m_cond.wait(lock);
+            return false;
+        }
+
+    private:
+        mutex m_mutex;
+        condition_variable m_cond;
+        unsigned int m_threshold;
+        unsigned int m_count;
+        unsigned int m_generation;
    };

-    struct void_functor_barrier_reseter
-    {
-      unsigned int size_;
-      void_completion_function fct_;
-      template <typename F>
-      void_functor_barrier_reseter(unsigned int size, BOOST_THREAD_RV_REF(F) funct)
-      : size_(size), fct_(boost::move(funct))
-      {}
-      template <typename F>
-      void_functor_barrier_reseter(unsigned int size, F& funct)
-      : size_(size), fct_(funct)
-      {}
-
-      BOOST_THREAD_MOVABLE(void_functor_barrier_reseter)
-      //BOOST_THREAD_COPYABLE_AND_MOVABLE(void_functor_barrier_reseter)
-
-      void_functor_barrier_reseter(void_functor_barrier_reseter const& other) BOOST_NOEXCEPT :
-      size_(other.size_), fct_(other.fct_)
-      {
-      }
-      void_functor_barrier_reseter(BOOST_THREAD_RV_REF(void_functor_barrier_reseter) other) BOOST_NOEXCEPT :
-      size_(BOOST_THREAD_RV(other).size_), fct_(BOOST_THREAD_RV(other).fct_)
-      //size_(BOOST_THREAD_RV(other).size_), fct_(boost::move(BOOST_THREAD_RV(other).fct_))
-      {
-      }
-
-      unsigned int operator()()
-      {
-        fct_();
-        return size_;
-      }
-    };
-    struct void_fct_ptr_barrier_reseter
-    {
-      unsigned int size_;
-      void(*fct_)();
-      void_fct_ptr_barrier_reseter(unsigned int size, void(*funct)()) :
-        size_(size), fct_(funct)
-      {
-      }
-      BOOST_THREAD_MOVABLE(void_fct_ptr_barrier_reseter)
-      //BOOST_THREAD_COPYABLE_AND_MOVABLE(void_fct_ptr_barrier_reseter)
-
-      void_fct_ptr_barrier_reseter(void_fct_ptr_barrier_reseter const& other) BOOST_NOEXCEPT :
-      size_(other.size_), fct_(other.fct_)
-      {
-      }
-      void_fct_ptr_barrier_reseter(BOOST_THREAD_RV_REF(void_fct_ptr_barrier_reseter) other) BOOST_NOEXCEPT :
-      size_(BOOST_THREAD_RV(other).size_), fct_(BOOST_THREAD_RV(other).fct_)
-      {
-      }
-      unsigned int operator()()
-      {
-        fct_();
-        return size_;
-      }
-    };
-  }
-  //BOOST_THREAD_DCL_MOVABLE(thread_detail::default_barrier_reseter)
-  //BOOST_THREAD_DCL_MOVABLE(thread_detail::void_functor_barrier_reseter)
-  //BOOST_THREAD_DCL_MOVABLE(thread_detail::void_fct_ptr_barrier_reseter)
-
-  class barrier
-  {
-    static inline unsigned int check_counter(unsigned int count)
-    {
-      if (count == 0) boost::throw_exception(
-          thread_exception(system::errc::invalid_argument, "barrier constructor: count cannot be zero."));
-      return count;
-    }
-    struct dummy
-    {
-    };
-
-  public:
-    BOOST_THREAD_NO_COPYABLE( barrier)
-
-    explicit barrier(unsigned int count) :
-      m_count(check_counter(count)), m_generation(0), fct_(BOOST_THREAD_MAKE_RV_REF(thread_detail::default_barrier_reseter(count)))
-    {
-    }
-
-    template <typename F>
-    barrier(
-        unsigned int count,
-        BOOST_THREAD_RV_REF(F) funct,
-        typename enable_if<
-        typename is_void<typename result_of<F()>::type>::type, dummy*
-        >::type=0
-    )
-    : m_count(check_counter(count)),
-      m_generation(0),
-      fct_(BOOST_THREAD_MAKE_RV_REF(thread_detail::void_functor_barrier_reseter(count,
-        boost::move(funct)))
-    )
-    {
-    }
-    template <typename F>
-    barrier(
-        unsigned int count,
-        F &funct,
-        typename enable_if<
-        typename is_void<typename result_of<F()>::type>::type, dummy*
-        >::type=0
-    )
-    : m_count(check_counter(count)),
-      m_generation(0),
-      fct_(BOOST_THREAD_MAKE_RV_REF(thread_detail::void_functor_barrier_reseter(count,
-        funct))
-    )
-    {
-    }
-
-    template <typename F>
-    barrier(
-        unsigned int count,
-        BOOST_THREAD_RV_REF(F) funct,
-        typename enable_if<
-        typename is_same<typename result_of<F()>::type, unsigned int>::type, dummy*
-        >::type=0
-    )
-    : m_count(check_counter(count)),
-      m_generation(0),
-      fct_(boost::move(funct))
-    {
-    }
-    template <typename F>
-    barrier(
-        unsigned int count,
-        F& funct,
-        typename enable_if<
-        typename is_same<typename result_of<F()>::type, unsigned int>::type, dummy*
-        >::type=0
-    )
-    : m_count(check_counter(count)),
-      m_generation(0),
-      fct_(funct)
-    {
-    }
-
-    barrier(unsigned int count, void(*funct)()) :
-      m_count(check_counter(count)), m_generation(0),
-      fct_(funct
-          ? BOOST_THREAD_MAKE_RV_REF(thread_detail::size_completion_function(BOOST_THREAD_MAKE_RV_REF(thread_detail::void_fct_ptr_barrier_reseter(count, funct))))
-          : BOOST_THREAD_MAKE_RV_REF(thread_detail::size_completion_function(BOOST_THREAD_MAKE_RV_REF(thread_detail::default_barrier_reseter(count))))
-      )
-    {
-    }
-    barrier(unsigned int count, unsigned int(*funct)()) :
-      m_count(check_counter(count)), m_generation(0),
-      fct_(funct
-          ? BOOST_THREAD_MAKE_RV_REF(thread_detail::size_completion_function(funct))
-          : BOOST_THREAD_MAKE_RV_REF(thread_detail::size_completion_function(BOOST_THREAD_MAKE_RV_REF(thread_detail::default_barrier_reseter(count))))
-      )
-    {
-    }
-
-    bool wait()
-    {
-      boost::unique_lock < boost::mutex > lock(m_mutex);
-      unsigned int gen = m_generation;
-
-      if (--m_count == 0)
-      {
-        m_generation++;
-        m_count = static_cast<unsigned int>(fct_());
-        BOOST_ASSERT(m_count != 0);
-        lock.unlock();
-        m_cond.notify_all();
-        return true;
-      }
-
-      while (gen == m_generation)
-        m_cond.wait(lock);
-      return false;
-    }
-
-    void count_down_and_wait()
-    {
-      wait();
-    }
-
-  private:
-    mutex m_mutex;
-    condition_variable m_cond;
-    unsigned int m_count;
-    unsigned int m_generation;
-    thread_detail::size_completion_function fct_;
-  };
-
-} // namespace boost
+}   // namespace boost

 #include <boost/config/abi_suffix.hpp>

--- a/include/boost/thread/caller_context.hpp
+++ b/include/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
--- a/include/boost/thread/completion_latch.hpp
+++ b/include/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
--- a/include/boost/thread/concurrent_queues/deque_adaptor.hpp
+++ b/include/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
--- a/include/boost/thread/concurrent_queues/deque_base.hpp
+++ b/include/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
--- a/include/boost/thread/concurrent_queues/deque_views.hpp
+++ b/include/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
--- a/include/boost/thread/concurrent_queues/detail/sync_deque_base.hpp
+++ b/include/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-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/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/duration.hpp>
-#include <boost/chrono/time_point.hpp>
-#include <boost/chrono/system_clocks.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;
-
-    typedef typename chrono::steady_clock clock;
-    typedef typename clock::duration duration;
-    typedef typename clock::time_point time_point;
-
-    // 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 void wait_until_not_empty(unique_lock<mutex>& lk);
-    inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
-    inline queue_op_status wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&);
-
-    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>
-  void sync_deque_base<ValueType, Queue>::wait_until_not_empty(unique_lock<mutex>& lk)
-  {
-    for (;;)
-    {
-      if (! empty(lk)) break;
-      throw_if_closed(lk);
-      not_empty_.wait(lk);
-    }
-  }
-  template <class ValueType, class Queue>
-  bool sync_deque_base<ValueType, Queue>::wait_until_not_empty_or_closed(unique_lock<mutex>& lk)
-  {
-    for (;;)
-    {
-      if (! empty(lk)) break;
-      if (closed(lk)) return true;
-      not_empty_.wait(lk);
-    }
-     return false;
-  }
-
-  template <class ValueType, class Queue>
-  queue_op_status sync_deque_base<ValueType, Queue>::wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&tp)
-  {
-    for (;;)
-    {
-      if (! empty(lk)) return queue_op_status::success;
-      throw_if_closed(lk);
-      if (not_empty_.wait_until(lk, tp) == cv_status::timeout ) return queue_op_status::timeout;
-    }
-  }
-
-
-} // detail
-} // concurrent
-} // boost
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/detail/sync_queue_base.hpp
+++ b/include/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-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/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/duration.hpp>
-#include <boost/chrono/time_point.hpp>
-#include <boost/chrono/system_clocks.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;
-
-    typedef typename chrono::steady_clock clock;
-    typedef typename clock::duration duration;
-    typedef typename clock::time_point time_point;
-
-    // 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 void wait_until_not_empty(unique_lock<mutex>& lk);
-    inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
-    inline queue_op_status wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&);
-
-    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>
-  void sync_queue_base<ValueType, Queue>::wait_until_not_empty(unique_lock<mutex>& lk)
-  {
-    for (;;)
-    {
-      if (! empty(lk)) break;
-      throw_if_closed(lk);
-      not_empty_.wait(lk);
-    }
-  }
-  template <class ValueType, class Queue>
-  bool sync_queue_base<ValueType, Queue>::wait_until_not_empty_or_closed(unique_lock<mutex>& lk)
-  {
-    for (;;)
-    {
-      if (! empty(lk)) break;
-      if (closed(lk)) return true;
-      not_empty_.wait(lk);
-    }
-     return false;
-  }
-
-  template <class ValueType, class Queue>
-  queue_op_status sync_queue_base<ValueType, Queue>::wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&tp)
-  {
-    for (;;)
-    {
-      if (! empty(lk)) return queue_op_status::success;
-      throw_if_closed(lk);
-      if (not_empty_.wait_until(lk, tp) == cv_status::timeout ) return queue_op_status::timeout;
-    }
-  }
-
-
-} // detail
-} // concurrent
-} // boost
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/queue_adaptor.hpp
+++ b/include/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
--- a/include/boost/thread/concurrent_queues/queue_base.hpp
+++ b/include/boost/thread/concurrent_queues/queue_base.hpp
@@ -1,202 +0,0 @@
-#ifndef BOOST_THREAD_QUEUE_BASE_HPP
-#define BOOST_THREAD_QUEUE_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 queue_base_copyable_only
-  {
-  public:
-    typedef ValueType value_type;
-    typedef SizeType size_type;
-
-    // Constructors/Assignment/Destructors
-    virtual ~queue_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(const value_type& x) = 0;
-
-    virtual void pull(value_type&) = 0;
-    virtual value_type pull() = 0;
-
-    virtual queue_op_status try_push(const value_type& x) = 0;
-    virtual queue_op_status try_pull(value_type&) = 0;
-
-    virtual queue_op_status nonblocking_push(const value_type& x) = 0;
-    virtual queue_op_status nonblocking_pull(value_type&) = 0;
-
-    virtual queue_op_status wait_push(const value_type& x) = 0;
-    virtual queue_op_status wait_pull(ValueType& elem) = 0;
-
-  };
-
-  template <typename ValueType, class SizeType>
-  class queue_base_movable_only
-  {
-  public:
-    typedef ValueType value_type;
-    typedef SizeType size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~queue_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(value_type&) = 0;
-    // enable_if is_nothrow_movable<value_type>
-    virtual value_type pull() = 0;
-
-    virtual queue_op_status try_pull(value_type&) = 0;
-
-    virtual queue_op_status nonblocking_pull(value_type&) = 0;
-
-    virtual queue_op_status wait_pull(value_type& elem) = 0;
-
-    virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
-  };
-
-
-  template <typename ValueType, class SizeType>
-  class queue_base_copyable_and_movable
-  {
-  public:
-    typedef ValueType value_type;
-    typedef SizeType size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~queue_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(const value_type& x) = 0;
-
-    virtual void pull(value_type&) = 0;
-    // enable_if is_nothrow_copy_movable<value_type>
-    virtual value_type pull() = 0;
-
-    virtual queue_op_status try_push(const value_type& x) = 0;
-    virtual queue_op_status try_pull(value_type&) = 0;
-
-    virtual queue_op_status nonblocking_push(const value_type& x) = 0;
-    virtual queue_op_status nonblocking_pull(value_type&) = 0;
-
-    virtual queue_op_status wait_push(const value_type& x) = 0;
-    virtual queue_op_status wait_pull(value_type& elem) = 0;
-
-    virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
-    virtual queue_op_status wait_push(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 queue_base;
-
-  template <class T, class ST>
-  struct queue_base<T, ST, true, true> {
-    typedef queue_base_copyable_and_movable<T, ST> type;
-  };
-  template <class T, class ST>
-  struct queue_base<T, ST, true, false> {
-    typedef queue_base_copyable_only<T, ST> type;
-  };
-  template <class T, class ST>
-  struct queue_base<T, ST, false, true> {
-    typedef queue_base_movable_only<T, ST> type;
-  };
-
-}
-
-  template <typename ValueType, class SizeType=std::size_t>
-  class queue_base :
-    public detail::queue_base<ValueType, SizeType>::type
-  {
-  public:
-      typedef ValueType value_type;
-      typedef SizeType size_type;
-    // Constructors/Assignment/Destructors
-    virtual ~queue_base() {};
-  };
-
-}
-using concurrent::queue_base;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/queue_op_status.hpp
+++ b/include/boost/thread/concurrent_queues/queue_op_status.hpp
@@ -1,46 +0,0 @@
-#ifndef BOOST_THREAD_QUEUE_OP_STATUS_HPP
-#define BOOST_THREAD_QUEUE_OP_STATUS_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/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-
-  BOOST_SCOPED_ENUM_DECLARE_BEGIN(queue_op_status)
-  { success = 0, empty, full, closed, busy, timeout, not_ready }
-  BOOST_SCOPED_ENUM_DECLARE_END(queue_op_status)
-
-  struct sync_queue_is_closed : std::exception
-  {
-  };
-
-}
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  struct no_block_tag{};
-  BOOST_CONSTEXPR_OR_CONST no_block_tag no_block = {};
-#endif
-
-  using concurrent::queue_op_status;
-  using concurrent::sync_queue_is_closed;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/queue_views.hpp
+++ b/include/boost/thread/concurrent_queues/queue_views.hpp
@@ -1,144 +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/queue_base.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-
-  template <typename Queue>
-  class queue_back_view
-  {
-   Queue* queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-    queue_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(x); }
-
-    queue_op_status try_push(const value_type& x) { return queue->try_push(x); }
-
-    queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push(x); }
-    queue_op_status wait_push(const value_type& x) { return queue->wait_push(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_front_view
-  {
-   Queue* queue;
-  public:
-    typedef typename Queue::value_type value_type;
-    typedef typename Queue::size_type size_type;
-
-    // Constructors/Assignment/Destructors
-    queue_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 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); }
-
-  };
-
-#if ! defined BOOST_NO_CXX11_TEMPLATE_ALIASES
-
-  template <class T>
-  using queue_back = queue_back_view<queue_base<T> > ;
-  template <class T>
-  using queue_front = queue_front_view<queue_base<T> > ;
-
-#else
-
-  template <class T>
-  struct queue_back : queue_back_view<queue_base<T> >
-  {
-    typedef queue_back_view<queue_base<T> > base_type;
-    queue_back(queue_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
-  };
-  template <class T>
-  struct queue_front : queue_front_view<queue_base<T> >
-  {
-    typedef queue_front_view<queue_base<T> > base_type;
-    queue_front(queue_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
-
-  };
-
-#endif
-
-//  template <class Queue>
-//  queue_back_view<Queue> back(Queue & q) { return queue_back_view<Queue>(q); }
-//  template <class Queue>
-//  queue_front_view<Queue> front(Queue & q) { return queue_front_view<Queue>(q); }
-//#if 0
-//  template <class T>
-//  queue_back<T> back(queue_base<T> & q) { return queue_back<T>(q); }
-//  template <class T>
-//  queue_front<T> front(queue_base<T> & q) { return queue_front<T>(q); }
-//#else
-//  template <class T>
-//  typename queue_back<T>::type back(queue_base<T> & q) { return typename queue_back<T>::type(q); }
-//  template <class T>
-//  typename queue_front<T>::type front(queue_base<T> & q) { return typename queue_front<T>::type(q); }
-//#endif
-}
-
-using concurrent::queue_back_view;
-using concurrent::queue_front_view;
-using concurrent::queue_back;
-using concurrent::queue_front;
-//using concurrent::back;
-//using concurrent::front;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/sync_bounded_queue.hpp
+++ b/include/boost/thread/concurrent_queues/sync_bounded_queue.hpp
@@ -1,727 +0,0 @@
-#ifndef BOOST_THREAD_CONCURRENT_QUEUES_SYNC_BOUNDED_QUEUE_HPP
-#define BOOST_THREAD_CONCURRENT_QUEUES_SYNC_BOUNDED_QUEUE_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (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)
-//
-// See http://www.boost.org/libs/thread for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#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/thread/concurrent_queues/queue_op_status.hpp>
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-#endif
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-  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
-    inline bool empty() const;
-    inline bool full() const;
-    inline size_type capacity() const;
-    inline size_type size() const;
-    inline bool closed() const;
-
-    // Modifiers
-    inline void close();
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-    inline void push(const value_type& x);
-    inline void push(BOOST_THREAD_RV_REF(value_type) x);
-    inline bool try_push(const value_type& x);
-    inline bool try_push(BOOST_THREAD_RV_REF(value_type) x);
-    inline bool try_push(no_block_tag, const value_type& x);
-    inline bool try_push(no_block_tag, BOOST_THREAD_RV_REF(value_type) x);
-#endif
-    inline void push_back(const value_type& x);
-    inline void push_back(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status try_push_back(const value_type& x);
-    inline queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status nonblocking_push_back(const value_type& x);
-    inline queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status wait_push_back(const value_type& x);
-    inline queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x);
-
-    // Observers/Modifiers
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-    inline void pull(value_type&);
-    // enable_if is_nothrow_copy_movable<value_type>
-    inline value_type pull();
-    inline shared_ptr<ValueType> ptr_pull();
-    inline bool try_pull(value_type&);
-    inline bool try_pull(no_block_tag,value_type&);
-    inline shared_ptr<ValueType> try_pull();
-#endif
-    inline void pull_front(value_type&);
-    // enable_if is_nothrow_copy_movable<value_type>
-    inline value_type pull_front();
-    inline queue_op_status try_pull_front(value_type&);
-    inline queue_op_status nonblocking_pull_front(value_type&);
-
-    inline queue_op_status wait_pull_front(ValueType& elem);
-
-  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_;
-
-    inline size_type inc(size_type idx) const BOOST_NOEXCEPT
-    {
-      return (idx + 1) % capacity_;
-    }
-
-    inline bool empty(unique_lock<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return in_ == out_;
-    }
-    inline bool empty(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return in_ == out_;
-    }
-    inline bool full(unique_lock<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return (inc(in_) == out_);
-    }
-    inline bool full(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return (inc(in_) == out_);
-    }
-    inline size_type capacity(lock_guard<mutex>& ) const BOOST_NOEXCEPT
-    {
-      return capacity_-1;
-    }
-    inline size_type size(lock_guard<mutex>& lk) const BOOST_NOEXCEPT
-    {
-      if (full(lk)) return capacity(lk);
-      return ((in_+capacity(lk)-out_) % capacity(lk));
-    }
-
-    inline void throw_if_closed(unique_lock<mutex>&);
-    inline bool closed(unique_lock<mutex>&) const;
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-    inline bool try_pull(value_type& x, unique_lock<mutex>& lk);
-    inline shared_ptr<value_type> try_pull(unique_lock<mutex>& lk);
-    inline bool try_push(const value_type& x, unique_lock<mutex>& lk);
-    inline bool try_push(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-#endif
-    inline queue_op_status try_pull_front(value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status try_push_back(const value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-
-    inline queue_op_status wait_pull_front(value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_push_back(const value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-
-    inline void wait_until_not_empty(unique_lock<mutex>& lk);
-    inline void wait_until_not_empty(unique_lock<mutex>& lk, bool&);
-    inline size_type wait_until_not_full(unique_lock<mutex>& lk);
-    inline size_type wait_until_not_full(unique_lock<mutex>& lk, bool&);
-
-
-    inline void notify_not_empty_if_needed(unique_lock<mutex>& lk)
-    {
-      if (waiting_empty_ > 0)
-      {
-        --waiting_empty_;
-        lk.unlock();
-        not_empty_.notify_one();
-      }
-    }
-    inline void notify_not_full_if_needed(unique_lock<mutex>& lk)
-    {
-      if (waiting_full_ > 0)
-      {
-        --waiting_full_;
-        lk.unlock();
-        not_full_.notify_one();
-      }
-    }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-    inline void pull(value_type& elem, unique_lock<mutex>& lk)
-    {
-      elem = boost::move(data_[out_]);
-      out_ = inc(out_);
-      notify_not_full_if_needed(lk);
-    }
-    inline value_type pull(unique_lock<mutex>& lk)
-    {
-      value_type elem = boost::move(data_[out_]);
-      out_ = inc(out_);
-      notify_not_full_if_needed(lk);
-      return boost::move(elem);
-    }
-    inline 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;
-    }
-#endif
-    inline void pull_front(value_type& elem, unique_lock<mutex>& lk)
-    {
-      elem = boost::move(data_[out_]);
-      out_ = inc(out_);
-      notify_not_full_if_needed(lk);
-    }
-    inline value_type pull_front(unique_lock<mutex>& lk)
-    {
-      value_type elem = boost::move(data_[out_]);
-      out_ = inc(out_);
-      notify_not_full_if_needed(lk);
-      return boost::move(elem);
-    }
-
-    inline void set_in(size_type in, unique_lock<mutex>& lk)
-    {
-      in_ = in;
-      notify_not_empty_if_needed(lk);
-    }
-
-    inline 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);
-    }
-
-    inline 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>::closed(unique_lock<mutex>& ) const
-  {
-    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);
-  }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  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)
-  {
-      unique_lock<mutex> lk(mtx_);
-      return try_pull(elem, lk);
-  }
-#endif
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::try_pull_front(ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (empty(lk))
-    {
-      if (closed(lk)) return queue_op_status::closed;
-      return queue_op_status::empty;
-    }
-    pull_front(elem, lk);
-    return queue_op_status::success;
-  }
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::try_pull_front(ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      return try_pull_front(elem, lk);
-  }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_pull(no_block_tag,ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock())
-      {
-        return false;
-      }
-      return try_pull(elem, lk);
-  }
-  template <typename ValueType>
-  boost::shared_ptr<ValueType> sync_bounded_queue<ValueType>::try_pull()
-  {
-      unique_lock<mutex> lk(mtx_);
-      return try_pull(lk);
-  }
-#endif
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::nonblocking_pull_front(ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock())
-      {
-        return queue_op_status::busy;
-      }
-      return try_pull_front(elem, lk);
-  }
-
-  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);
-    }
-  }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::pull(ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk);
-      pull(elem, lk);
-  }
-//  template <typename ValueType>
-//  void sync_bounded_queue<ValueType>::pull(ValueType& elem, bool & closed)
-//  {
-//      unique_lock<mutex> lk(mtx_);
-//      wait_until_not_empty(lk, closed);
-//      if (closed) {return;}
-//      pull(elem, lk);
-//  }
-
-  // enable if ValueType is nothrow movable
-  template <typename ValueType>
-  ValueType sync_bounded_queue<ValueType>::pull()
-  {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk);
-      return pull(lk);
-  }
-  template <typename ValueType>
-  boost::shared_ptr<ValueType> sync_bounded_queue<ValueType>::ptr_pull()
-  {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk);
-      return ptr_pull(lk);
-  }
-
-#endif
-
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::pull_front(ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk);
-      pull_front(elem, lk);
-  }
-
-  // enable if ValueType is nothrow movable
-  template <typename ValueType>
-  ValueType sync_bounded_queue<ValueType>::pull_front()
-  {
-      unique_lock<mutex> lk(mtx_);
-      wait_until_not_empty(lk);
-      return pull_front(lk);
-  }
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::wait_pull_front(ValueType& elem, unique_lock<mutex>& lk)
-  {
-      if (empty(lk) && closed(lk)) {return queue_op_status::closed;}
-      bool is_closed = false;
-      wait_until_not_empty(lk, is_closed);
-      if (is_closed) {return queue_op_status::closed;}
-      pull_front(elem, lk);
-      return queue_op_status::success;
-  }
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::wait_pull_front(ValueType& elem)
-  {
-    unique_lock<mutex> lk(mtx_);
-    return wait_pull_front(elem, lk);
-  }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  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)
-  {
-      unique_lock<mutex> lk(mtx_);
-      return try_push(elem, lk);
-  }
-
-#endif
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::try_push_back(const ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (closed(lk)) return queue_op_status::closed;
-    size_type in_p_1 = inc(in_);
-    if (in_p_1 == out_)  // full()
-    {
-      return queue_op_status::full;
-    }
-    push_at(elem, in_p_1, lk);
-    return queue_op_status::success;
-  }
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::try_push_back(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(mtx_);
-    return try_push_back(elem, lk);
-  }
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::wait_push_back(const ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (closed(lk)) return queue_op_status::closed;
-    push_at(elem, wait_until_not_full(lk), lk);
-    return queue_op_status::success;
-  }
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::wait_push_back(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(mtx_);
-    return wait_push_back(elem, lk);
-  }
-
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(no_block_tag, const ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock()) return false;
-      return try_push(elem, lk);
-  }
-#endif
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::nonblocking_push_back(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(mtx_, try_to_lock);
-    if (!lk.owns_lock()) return queue_op_status::busy;
-    return try_push_back(elem, lk);
-  }
-
-  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);
-    }
-  }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::push(const ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      push_at(elem, wait_until_not_full(lk), lk);
-  }
-#endif
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::push_back(const ValueType& elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      push_at(elem, wait_until_not_full(lk), lk);
-  }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  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)
-  {
-      unique_lock<mutex> lk(mtx_);
-      return try_push(boost::move(elem), lk);
-  }
-#endif
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::try_push_back(BOOST_THREAD_RV_REF(ValueType) elem, unique_lock<mutex>& lk)
-  {
-    if (closed(lk)) return queue_op_status::closed;
-    size_type in_p_1 = inc(in_);
-    if (in_p_1 == out_) // full()
-    {
-      return queue_op_status::full;
-    }
-    push_at(boost::move(elem), in_p_1, lk);
-    return queue_op_status::success;
-  }
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::try_push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      return try_push_back(boost::move(elem), lk);
-  }
-
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::wait_push_back(BOOST_THREAD_RV_REF(ValueType) elem, unique_lock<mutex>& lk)
-  {
-    if (closed(lk)) return queue_op_status::closed;
-    push_at(boost::move(elem), wait_until_not_full(lk), lk);
-    return queue_op_status::success;
-  }
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::wait_push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      return try_push_back(boost::move(elem), lk);
-  }
-
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  template <typename ValueType>
-  bool sync_bounded_queue<ValueType>::try_push(no_block_tag, BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock())
-      {
-        return false;
-      }
-      return try_push(boost::move(elem), lk);
-  }
-#endif
-  template <typename ValueType>
-  queue_op_status sync_bounded_queue<ValueType>::nonblocking_push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(mtx_, try_to_lock);
-      if (!lk.owns_lock())
-      {
-        return queue_op_status::busy;
-      }
-      return try_push_back(boost::move(elem), lk);
-  }
-
-#ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::push(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      push_at(boost::move(elem), wait_until_not_full(lk), lk);
-  }
-#endif
-  template <typename ValueType>
-  void sync_bounded_queue<ValueType>::push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(mtx_);
-      push_at(boost::move(elem), wait_until_not_full(lk), lk);
-  }
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    sbq.push_back(boost::move(elem));
-    return sbq;
-  }
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, ValueType const&elem)
-  {
-    sbq.push_back(elem);
-    return sbq;
-  }
-
-  template <typename ValueType>
-  sync_bounded_queue<ValueType>& operator>>(sync_bounded_queue<ValueType>& sbq, ValueType &elem)
-  {
-    sbq.pull_front(elem);
-    return sbq;
-  }
-}
-using concurrent::sync_bounded_queue;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/sync_deque.hpp
+++ b/include/boost/thread/concurrent_queues/sync_deque.hpp
@@ -1,327 +0,0 @@
-#ifndef BOOST_THREAD_CONCURRENT_QUEUES_SYNC_DEQUE_HPP
-#define BOOST_THREAD_CONCURRENT_QUEUES_SYNC_DEQUE_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (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)
-//
-// See http://www.boost.org/libs/thread for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/concurrent_queues/detail/sync_queue_base.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/csbl/devector.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/mutex.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
-{
-namespace concurrent
-{
-  template <class ValueType, class Container = csbl::devector<ValueType> >
-  class sync_deque
-    : public detail::sync_queue_base<ValueType, Container >
-  {
-    typedef detail::sync_queue_base<ValueType, Container >  super;
-
-  public:
-    typedef ValueType value_type;
-    //typedef typename super::value_type value_type; // fixme
-    typedef typename super::underlying_queue_type underlying_queue_type;
-    typedef typename super::size_type size_type;
-    typedef typename super::op_status op_status;
-
-    // Constructors/Assignment/Destructors
-    BOOST_THREAD_NO_COPYABLE(sync_deque)
-    inline sync_deque();
-    //template <typename Range>
-    //inline explicit sync_deque(Range range);
-    inline ~sync_deque();
-
-    // Modifiers
-    inline void push_back(const value_type& x);
-    inline queue_op_status try_push_back(const value_type& x);
-    inline queue_op_status nonblocking_push_back(const value_type& x);
-    inline queue_op_status wait_push_back(const value_type& x);
-    inline void push_back(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x);
-
-    // Observers/Modifiers
-    inline void pull_front(value_type&);
-    // enable_if is_nothrow_copy_movable<value_type>
-    inline value_type pull_front();
-
-    inline queue_op_status try_pull_front(value_type&);
-    inline queue_op_status nonblocking_pull_front(value_type&);
-    inline queue_op_status wait_pull_front(ValueType& elem);
-
-  private:
-
-    inline queue_op_status try_pull_front(value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_pull_front(value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status try_push_back(const value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_push_back(const value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-
-    inline void pull_front(value_type& elem, unique_lock<mutex>& )
-    {
-      elem = boost::move(super::data_.front());
-      super::data_.pop_front();
-    }
-    inline value_type pull_front(unique_lock<mutex>& )
-    {
-      value_type e = boost::move(super::data_.front());
-      super::data_.pop_front();
-      return boost::move(e);
-    }
-
-    inline void push_back(const value_type& elem, unique_lock<mutex>& lk)
-    {
-      super::data_.push_back(elem);
-      super::notify_not_empty_if_needed(lk);
-    }
-
-    inline void push_back(BOOST_THREAD_RV_REF(value_type) elem, unique_lock<mutex>& lk)
-    {
-      super::data_.push_back(boost::move(elem));
-      super::notify_not_empty_if_needed(lk);
-    }
-  };
-
-  template <class ValueType, class Container>
-  sync_deque<ValueType, Container>::sync_deque() :
-    super()
-  {
-  }
-
-//  template <class ValueType, class Container>
-//  template <class Range>
-//  explicit sync_deque<ValueType, Container>::sync_deque(Range range) :
-//    data_(), closed_(false)
-//  {
-//    try
-//    {
-//      typedef typename Range::iterator iterator_t;
-//      iterator_t first = boost::begin(range);
-//      iterator_t end = boost::end(range);
-//      for (iterator_t cur = first; cur != end; ++cur)
-//      {
-//        data_.push(boost::move(*cur));;
-//      }
-//      notify_not_empty_if_needed(lk);
-//    }
-//    catch (...)
-//    {
-//      delete[] data_;
-//    }
-//  }
-
-  template <class ValueType, class Container>
-  sync_deque<ValueType, Container>::~sync_deque()
-  {
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::try_pull_front(ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (super::empty(lk))
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::empty;
-    }
-    pull_front(elem, lk);
-    return queue_op_status::success;
-  }
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::wait_pull_front(ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (super::empty(lk))
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-    }
-    bool has_been_closed = super::wait_until_not_empty_or_closed(lk);
-    if (has_been_closed) return queue_op_status::closed;
-    pull_front(elem, lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::try_pull_front(ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return try_pull_front(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::wait_pull_front(ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_pull_front(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::nonblocking_pull_front(ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (!lk.owns_lock())
-    {
-      return queue_op_status::busy;
-    }
-    return try_pull_front(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  void sync_deque<ValueType, Container>::pull_front(ValueType& elem)
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::wait_until_not_empty(lk);
-      pull_front(elem, lk);
-  }
-
-  // enable if ValueType is nothrow movable
-  template <class ValueType, class Container>
-  ValueType sync_deque<ValueType, Container>::pull_front()
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::wait_until_not_empty(lk);
-      return pull_front(lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::try_push_back(const ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push_back(elem, lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::try_push_back(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return try_push_back(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::wait_push_back(const ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push_back(elem, lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::wait_push_back(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_push_back(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::nonblocking_push_back(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (!lk.owns_lock()) return queue_op_status::busy;
-    return try_push_back(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  void sync_deque<ValueType, Container>::push_back(const ValueType& elem)
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::throw_if_closed(lk);
-      push_back(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::try_push_back(BOOST_THREAD_RV_REF(ValueType) elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push_back(boost::move(elem), lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::try_push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return try_push_back(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::wait_push_back(BOOST_THREAD_RV_REF(ValueType) elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push_back(boost::move(elem), lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::wait_push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_push_back(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_deque<ValueType, Container>::nonblocking_push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (!lk.owns_lock())
-    {
-      return queue_op_status::busy;
-    }
-    return try_push_back(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  void sync_deque<ValueType, Container>::push_back(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::throw_if_closed(lk);
-      push_back(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  sync_deque<ValueType, Container>& operator<<(sync_deque<ValueType, Container>& sbq, BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    sbq.push_back(boost::move(elem));
-    return sbq;
-  }
-
-  template <class ValueType, class Container>
-  sync_deque<ValueType, Container>& operator<<(sync_deque<ValueType, Container>& sbq, ValueType const&elem)
-  {
-    sbq.push_back(elem);
-    return sbq;
-  }
-
-  template <class ValueType, class Container>
-  sync_deque<ValueType, Container>& operator>>(sync_deque<ValueType, Container>& sbq, ValueType &elem)
-  {
-    sbq.pull_front(elem);
-    return sbq;
-  }
-
-}
-using concurrent::sync_deque;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/sync_priority_queue.hpp
+++ b/include/boost/thread/concurrent_queues/sync_priority_queue.hpp
@@ -1,369 +0,0 @@
-// Copyright (C) 2014 Ian Forbed
-// Copyright (C) 2014 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_SYNC_PRIORITY_QUEUE
-#define BOOST_THREAD_SYNC_PRIORITY_QUEUE
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/thread/concurrent_queues/detail/sync_queue_base.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/csbl/vector.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/mutex.hpp>
-
-#include <boost/atomic.hpp>
-#include <boost/chrono/duration.hpp>
-#include <boost/chrono/time_point.hpp>
-
-#include <exception>
-#include <queue>
-#include <utility>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace detail {
-
-  template <
-    class Type,
-    class Container = csbl::vector<Type>,
-    class Compare = std::less<Type>
-  >
-  class priority_queue
-  {
-  private:
-      Container _elements;
-      Compare _compare;
-  public:
-      typedef Type value_type;
-      typedef typename Container::size_type size_type;
-
-      explicit priority_queue(const Compare& compare = Compare())
-          : _elements(), _compare(compare)
-      { }
-
-      size_type size() const
-      {
-          return _elements.size();
-      }
-
-      bool empty() const
-      {
-          return _elements.empty();
-      }
-
-      void push(Type const& element)
-      {
-          _elements.push_back(element);
-          std::push_heap(_elements.begin(), _elements.end(), _compare);
-      }
-      void push(BOOST_RV_REF(Type) element)
-      {
-          _elements.push_back(boost::move(element));
-          std::push_heap(_elements.begin(), _elements.end(), _compare);
-      }
-
-      void pop()
-      {
-          std::pop_heap(_elements.begin(), _elements.end(), _compare);
-          _elements.pop_back();
-      }
-      Type pull()
-      {
-          Type result = boost::move(_elements.front());
-          pop();
-          return boost::move(result);
-      }
-
-      Type const& top()
-      {
-          return _elements.front();
-      }
-  };
-}
-
-namespace concurrent
-{
-  template <class ValueType,
-            class Container = csbl::vector<ValueType>,
-            class Compare = std::less<typename Container::value_type> >
-  class sync_priority_queue
-    : public detail::sync_queue_base<ValueType, boost::detail::priority_queue<ValueType,Container,Compare> >
-  {
-    typedef detail::sync_queue_base<ValueType, boost::detail::priority_queue<ValueType,Container,Compare> >  super;
-
-  public:
-    typedef ValueType value_type;
-    //typedef typename super::value_type value_type; // fixme
-    typedef typename super::underlying_queue_type underlying_queue_type;
-    typedef typename super::size_type size_type;
-    typedef typename super::op_status op_status;
-
-    typedef chrono::steady_clock clock;
-  protected:
-
-  public:
-    sync_priority_queue() {}
-
-    ~sync_priority_queue()
-    {
-      if(!super::closed())
-      {
-        super::close();
-      }
-    }
-
-    void push(const ValueType& elem);
-    void push(BOOST_THREAD_RV_REF(ValueType) elem);
-
-    queue_op_status try_push(const ValueType& elem);
-    queue_op_status try_push(BOOST_THREAD_RV_REF(ValueType) elem);
-
-    ValueType pull();
-
-    void pull(ValueType&);
-
-    queue_op_status pull_until(const clock::time_point&, ValueType&);
-    queue_op_status pull_for(const clock::duration&, ValueType&);
-
-    queue_op_status try_pull(ValueType& elem);
-    queue_op_status wait_pull(ValueType& elem);
-    queue_op_status nonblocking_pull(ValueType&);
-
-  private:
-    void push(unique_lock<mutex>&, const ValueType& elem);
-    void push(lock_guard<mutex>&, const ValueType& elem);
-    void push(unique_lock<mutex>&, BOOST_THREAD_RV_REF(ValueType) elem);
-    void push(lock_guard<mutex>&, BOOST_THREAD_RV_REF(ValueType) elem);
-
-    queue_op_status try_push(unique_lock<mutex>&, const ValueType& elem);
-    queue_op_status try_push(unique_lock<mutex>&, BOOST_THREAD_RV_REF(ValueType) elem);
-
-    ValueType pull(unique_lock<mutex>&);
-    ValueType pull(lock_guard<mutex>&);
-
-    void pull(unique_lock<mutex>&, ValueType&);
-    void pull(lock_guard<mutex>&, ValueType&);
-
-    queue_op_status try_pull(lock_guard<mutex>& lk, ValueType& elem);
-    queue_op_status try_pull(unique_lock<mutex>& lk, ValueType& elem);
-
-    queue_op_status wait_pull(unique_lock<mutex>& lk, ValueType& elem);
-
-    queue_op_status nonblocking_pull(unique_lock<mutex>& lk, ValueType&);
-
-    sync_priority_queue(const sync_priority_queue&);
-    sync_priority_queue& operator= (const sync_priority_queue&);
-    sync_priority_queue(BOOST_THREAD_RV_REF(sync_priority_queue));
-    sync_priority_queue& operator= (BOOST_THREAD_RV_REF(sync_priority_queue));
-  }; //end class
-
-
-  //////////////////////
-  template <class T, class Container,class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::push(unique_lock<mutex>& lk, const T& elem)
-  {
-    super::throw_if_closed(lk);
-    super::data_.push(elem);
-    super::notify_not_empty_if_needed(lk);
-  }
-  template <class T, class Container,class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::push(lock_guard<mutex>& lk, const T& elem)
-  {
-    super::throw_if_closed(lk);
-    super::data_.push(elem);
-    super::notify_not_empty_if_needed(lk);
-  }
-  template <class T, class Container,class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::push(const T& elem)
-  {
-    lock_guard<mutex> lk(super::mtx_);
-    push(lk, elem);
-  }
-
-  //////////////////////
-  template <class T, class Container,class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::push(unique_lock<mutex>& lk, BOOST_THREAD_RV_REF(T) elem)
-  {
-    super::throw_if_closed(lk);
-    super::data_.push(boost::move(elem));
-    super::notify_not_empty_if_needed(lk);
-  }
-  template <class T, class Container,class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::push(lock_guard<mutex>& lk, BOOST_THREAD_RV_REF(T) elem)
-  {
-    super::throw_if_closed(lk);
-    super::data_.push(boost::move(elem));
-    super::notify_not_empty_if_needed(lk);
-  }
-  template <class T, class Container,class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::push(BOOST_THREAD_RV_REF(T) elem)
-  {
-    lock_guard<mutex> lk(super::mtx_);
-    push(lk, boost::move(elem));
-  }
-
-  //////////////////////
-  template <class T, class Container,class Cmp>
-  queue_op_status sync_priority_queue<T,Container,Cmp>::try_push(const T& elem)
-  {
-    lock_guard<mutex> lk(super::mtx_);
-    if (super::closed(lk)) return queue_op_status::closed;
-    push(lk, elem);
-    return queue_op_status::success;
-  }
-
-  //////////////////////
-  template <class T, class Container,class Cmp>
-  queue_op_status sync_priority_queue<T,Container,Cmp>::try_push(BOOST_THREAD_RV_REF(T) elem)
-  {
-    lock_guard<mutex> lk(super::mtx_);
-    if (super::closed(lk)) return queue_op_status::closed;
-    push(lk, boost::move(elem));
-
-    return queue_op_status::success;
-  }
-
-  //////////////////////
-  template <class T,class Container, class Cmp>
-  T sync_priority_queue<T,Container,Cmp>::pull(unique_lock<mutex>&)
-  {
-    return super::data_.pull();
-  }
-  template <class T,class Container, class Cmp>
-  T sync_priority_queue<T,Container,Cmp>::pull(lock_guard<mutex>&)
-  {
-    return super::data_.pull();
-  }
-
-  template <class T,class Container, class Cmp>
-  T sync_priority_queue<T,Container,Cmp>::pull()
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    super::wait_until_not_empty(lk);
-    return pull(lk);
-  }
-
-  //////////////////////
-  template <class T,class Container, class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::pull(unique_lock<mutex>&, T& elem)
-  {
-    elem = super::data_.pull();
-  }
-  template <class T,class Container, class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::pull(lock_guard<mutex>&, T& elem)
-  {
-    elem = super::data_.pull();
-  }
-
-  template <class T,class Container, class Cmp>
-  void sync_priority_queue<T,Container,Cmp>::pull(T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    super::wait_until_not_empty(lk);
-    pull(lk, elem);
-  }
-
-  //////////////////////
-  template <class T, class Cont,class Cmp>
-  queue_op_status
-  sync_priority_queue<T,Cont,Cmp>::pull_until(const clock::time_point& tp, T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    if (queue_op_status::timeout == super::wait_until_not_empty_until(lk, tp))
-      return queue_op_status::timeout;
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-
-  //////////////////////
-  template <class T, class Cont,class Cmp>
-  queue_op_status
-  sync_priority_queue<T,Cont,Cmp>::pull_for(const clock::duration& dura, T& elem)
-  {
-    return pull_until(clock::now() + dura, elem);
-  }
-
-  //////////////////////
-  template <class T, class Container,class Cmp>
-  queue_op_status
-  sync_priority_queue<T,Container,Cmp>::try_pull(unique_lock<mutex>& lk, T& elem)
-  {
-    if (super::empty(lk))
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::empty;
-    }
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-
-  template <class T, class Container,class Cmp>
-  queue_op_status
-  sync_priority_queue<T,Container,Cmp>::try_pull(lock_guard<mutex>& lk, T& elem)
-  {
-    if (super::empty(lk))
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::empty;
-    }
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-
-  template <class T, class Container,class Cmp>
-  queue_op_status
-  sync_priority_queue<T,Container,Cmp>::try_pull(T& elem)
-  {
-    lock_guard<mutex> lk(super::mtx_);
-    return try_pull(lk, elem);
-  }
-
-  //////////////////////
-  template <class T,class Container, class Cmp>
-  queue_op_status sync_priority_queue<T,Container,Cmp>::wait_pull(unique_lock<mutex>& lk, T& elem)
-  {
-    if (super::empty(lk))
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-    }
-    bool has_been_closed = super::wait_until_not_empty_or_closed(lk);
-    if (has_been_closed) return queue_op_status::closed;
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-
-  template <class T,class Container, class Cmp>
-  queue_op_status sync_priority_queue<T,Container,Cmp>::wait_pull(T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_pull(lk, elem);
-  }
-
-  //////////////////////
-
-  template <class T,class Container, class Cmp>
-  queue_op_status sync_priority_queue<T,Container,Cmp>::nonblocking_pull(T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (!lk.owns_lock()) return queue_op_status::busy;
-    return try_pull(lk, elem);
-  }
-
-
-
-} //end concurrent namespace
-
-using concurrent::sync_priority_queue;
-
-} //end boost namespace
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/sync_queue.hpp
+++ b/include/boost/thread/concurrent_queues/sync_queue.hpp
@@ -1,335 +0,0 @@
-#ifndef BOOST_THREAD_CONCURRENT_QUEUES_SYNC_QUEUE_HPP
-#define BOOST_THREAD_CONCURRENT_QUEUES_SYNC_QUEUE_HPP
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// (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)
-//
-// See http://www.boost.org/libs/thread for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-#include <iostream>
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/concurrent_queues/detail/sync_queue_base.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/csbl/devector.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/thread/mutex.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
-{
-namespace concurrent
-{
-  template <class ValueType, class Container = csbl::devector<ValueType> >
-  class sync_queue
-    : public detail::sync_queue_base<ValueType, Container >
-  {
-    typedef detail::sync_queue_base<ValueType, Container >  super;
-
-  public:
-    typedef ValueType value_type;
-    //typedef typename super::value_type value_type; // fixme
-    typedef typename super::underlying_queue_type underlying_queue_type;
-    typedef typename super::size_type size_type;
-    typedef typename super::op_status op_status;
-
-    // Constructors/Assignment/Destructors
-    BOOST_THREAD_NO_COPYABLE(sync_queue)
-    inline sync_queue();
-    //template <class Range>
-    //inline explicit sync_queue(Range range);
-    inline ~sync_queue();
-
-    // Modifiers
-
-    inline void push(const value_type& x);
-    inline queue_op_status try_push(const value_type& x);
-    inline queue_op_status nonblocking_push(const value_type& x);
-    inline queue_op_status wait_push(const value_type& x);
-    inline void push(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x);
-    inline queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x);
-
-    // Observers/Modifiers
-    inline void pull(value_type&);
-    // enable_if is_nothrow_copy_movable<value_type>
-    inline value_type pull();
-
-    inline queue_op_status try_pull(value_type&);
-    inline queue_op_status nonblocking_pull(value_type&);
-    inline queue_op_status wait_pull(ValueType& elem);
-
-  private:
-
-    inline queue_op_status try_pull(value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_pull(value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status try_push(const value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_push(const value_type& x, unique_lock<mutex>& lk);
-    inline queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-    inline queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x, unique_lock<mutex>& lk);
-
-    inline void pull(value_type& elem, unique_lock<mutex>& )
-    {
-      elem = boost::move(super::data_.front());
-      super::data_.pop_front();
-    }
-    inline value_type pull(unique_lock<mutex>& )
-    {
-      value_type e = boost::move(super::data_.front());
-      super::data_.pop_front();
-      return boost::move(e);
-    }
-
-    inline void push(const value_type& elem, unique_lock<mutex>& lk)
-    {
-      super::data_.push_back(elem);
-      super::notify_not_empty_if_needed(lk);
-    }
-
-    inline void push(BOOST_THREAD_RV_REF(value_type) elem, unique_lock<mutex>& lk)
-    {
-      super::data_.push_back(boost::move(elem));
-      super::notify_not_empty_if_needed(lk);
-    }
-  };
-
-  template <class ValueType, class Container>
-  sync_queue<ValueType, Container>::sync_queue() :
-    super()
-  {
-  }
-
-//  template <class ValueType, class Container>
-//  template <class Range>
-//  explicit sync_queue<ValueType, Container>::sync_queue(Range range) :
-//    data_(), closed_(false)
-//  {
-//    try
-//    {
-//      typedef typename Range::iterator iterator_t;
-//      iterator_t first = boost::begin(range);
-//      iterator_t end = boost::end(range);
-//      for (iterator_t cur = first; cur != end; ++cur)
-//      {
-//        data_.push(boost::move(*cur));;
-//      }
-//      notify_not_empty_if_needed(lk);
-//    }
-//    catch (...)
-//    {
-//      delete[] data_;
-//    }
-//  }
-
-  template <class ValueType, class Container>
-  sync_queue<ValueType, Container>::~sync_queue()
-  {
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::try_pull(ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (super::empty(lk))
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::empty;
-    }
-    pull(elem, lk);
-    return queue_op_status::success;
-  }
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::wait_pull(ValueType& elem, unique_lock<mutex>& lk)
-  {
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    if (super::empty(lk))
-    {
-      //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-      if (super::closed(lk)) return queue_op_status::closed;
-    }
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    bool has_been_closed = super::wait_until_not_empty_or_closed(lk);
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    if (has_been_closed) return queue_op_status::closed;
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    pull(elem, lk);
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::try_pull(ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return try_pull(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::wait_pull(ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_pull(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::nonblocking_pull(ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (!lk.owns_lock())
-    {
-      return queue_op_status::busy;
-    }
-    return try_pull(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  void sync_queue<ValueType, Container>::pull(ValueType& elem)
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::wait_until_not_empty(lk);
-      pull(elem, lk);
-  }
-
-  // enable if ValueType is nothrow movable
-  template <class ValueType, class Container>
-  ValueType sync_queue<ValueType, Container>::pull()
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::wait_until_not_empty(lk);
-      return pull(lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::try_push(const ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push(elem, lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::try_push(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return try_push(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::wait_push(const ValueType& elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push(elem, lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::wait_push(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_push(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::nonblocking_push(const ValueType& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (!lk.owns_lock()) return queue_op_status::busy;
-    return try_push(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  void sync_queue<ValueType, Container>::push(const ValueType& elem)
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::throw_if_closed(lk);
-      push(elem, lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::try_push(BOOST_THREAD_RV_REF(ValueType) elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push(boost::move(elem), lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::try_push(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return try_push(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::wait_push(BOOST_THREAD_RV_REF(ValueType) elem, unique_lock<mutex>& lk)
-  {
-    if (super::closed(lk)) return queue_op_status::closed;
-    push(boost::move(elem), lk);
-    return queue_op_status::success;
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::wait_push(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_push(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  queue_op_status sync_queue<ValueType, Container>::nonblocking_push(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (!lk.owns_lock())
-    {
-      return queue_op_status::busy;
-    }
-    return try_push(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  void sync_queue<ValueType, Container>::push(BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-      unique_lock<mutex> lk(super::mtx_);
-      super::throw_if_closed(lk);
-      push(boost::move(elem), lk);
-  }
-
-  template <class ValueType, class Container>
-  sync_queue<ValueType, Container>& operator<<(sync_queue<ValueType, Container>& sbq, BOOST_THREAD_RV_REF(ValueType) elem)
-  {
-    sbq.push(boost::move(elem));
-    return sbq;
-  }
-
-  template <class ValueType, class Container>
-  sync_queue<ValueType, Container>& operator<<(sync_queue<ValueType, Container>& sbq, ValueType const&elem)
-  {
-    sbq.push(elem);
-    return sbq;
-  }
-
-  template <class ValueType, class Container>
-  sync_queue<ValueType, Container>& operator>>(sync_queue<ValueType, Container>& sbq, ValueType &elem)
-  {
-    sbq.pull(elem);
-    return sbq;
-  }
-
-}
-using concurrent::sync_queue;
-
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/concurrent_queues/sync_timed_queue.hpp
+++ b/include/boost/thread/concurrent_queues/sync_timed_queue.hpp
@@ -1,468 +0,0 @@
-// Copyright (C) 2014 Ian Forbed
-// Copyright (C) 2014 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_SYNC_TIMED_QUEUE_HPP
-#define BOOST_THREAD_SYNC_TIMED_QUEUE_HPP
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/thread/concurrent_queues/sync_priority_queue.hpp>
-#include <boost/chrono/duration.hpp>
-#include <boost/chrono/time_point.hpp>
-#include <boost/chrono/system_clocks.hpp>
-#include <boost/chrono/chrono_io.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-namespace concurrent
-{
-namespace detail
-{
-  template <class T, class Clock = chrono::steady_clock>
-  struct scheduled_type
-  {
-    typedef T value_type;
-    typedef Clock clock;
-    typedef typename clock::time_point time_point;
-    T data;
-    time_point time;
-
-    BOOST_THREAD_COPYABLE_AND_MOVABLE(scheduled_type)
-
-    scheduled_type(T const& pdata, time_point tp) : data(pdata), time(tp) {}
-    scheduled_type(BOOST_THREAD_RV_REF(T) pdata, time_point tp) : data(boost::move(pdata)), time(tp) {}
-
-    scheduled_type(scheduled_type const& other) : data(other.data), time(other.time) {}
-    scheduled_type& operator=(BOOST_THREAD_COPY_ASSIGN_REF(scheduled_type) other) {
-      data = other.data;
-      time = other.time;
-      return *this;
-    }
-
-    scheduled_type(BOOST_THREAD_RV_REF(scheduled_type) other) : data(boost::move(other.data)), time(other.time) {}
-    scheduled_type& operator=(BOOST_THREAD_RV_REF(scheduled_type) other) {
-      data = boost::move(other.data);
-      time = other.time;
-      return *this;
-    }
-
-    bool time_not_reached() const
-    {
-      return time > clock::now();
-    }
-
-    bool operator <(const scheduled_type<T> other) const
-    {
-      return this->time > other.time;
-    }
-  }; //end struct
-
-} //end detail namespace
-
-  template <class T, class Clock = chrono::steady_clock>
-  class sync_timed_queue
-    : private sync_priority_queue<detail::scheduled_type<T, Clock> >
-  {
-    typedef detail::scheduled_type<T, Clock> stype;
-    typedef sync_priority_queue<stype> super;
-  public:
-    typedef T value_type;
-    typedef Clock clock;
-    typedef typename clock::duration duration;
-    typedef typename clock::time_point time_point;
-    typedef typename super::underlying_queue_type underlying_queue_type;
-    typedef typename super::size_type size_type;
-    typedef typename super::op_status op_status;
-
-    sync_timed_queue() : super() {};
-    ~sync_timed_queue() {}
-
-    using super::size;
-    using super::empty;
-    using super::full;
-    using super::close;
-    using super::closed;
-
-    T pull();
-    void pull(T& elem);
-
-    template <class Duration>
-    queue_op_status pull_until(chrono::time_point<clock,Duration> const& tp, T& elem);
-    template <class Rep, class Period>
-    queue_op_status pull_for(chrono::duration<Rep,Period> const& dura, T& elem);
-
-    queue_op_status try_pull(T& elem);
-    queue_op_status wait_pull(T& elem);
-    queue_op_status nonblocking_pull(T& elem);
-
-    template <class Duration>
-    void push(const T& elem, chrono::time_point<clock,Duration> const& tp);
-    template <class Rep, class Period>
-    void push(const T& elem, chrono::duration<Rep,Period> const& dura);
-
-    template <class Duration>
-    void push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp);
-    template <class Rep, class Period>
-    void push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura);
-
-    template <class Duration>
-    queue_op_status try_push(const T& elem, chrono::time_point<clock,Duration> const& tp);
-    template <class Rep, class Period>
-    queue_op_status try_push(const T& elem, chrono::duration<Rep,Period> const& dura);
-
-    template <class Duration>
-    queue_op_status try_push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp);
-    template <class Rep, class Period>
-    queue_op_status try_push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura);
-
-  private:
-    T pull(unique_lock<mutex>&);
-    T pull(lock_guard<mutex>&);
-
-    void pull(unique_lock<mutex>&, T& elem);
-    void pull(lock_guard<mutex>&, T& elem);
-
-    queue_op_status try_pull(unique_lock<mutex>&, T& elem);
-    queue_op_status try_pull(lock_guard<mutex>&, T& elem);
-
-    queue_op_status wait_pull(unique_lock<mutex>& lk, T& elem);
-
-    bool wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>&);
-    T pull_when_time_reached(unique_lock<mutex>&);
-    template <class Duration>
-    queue_op_status pull_when_time_reached_until(unique_lock<mutex>&, chrono::time_point<clock,Duration> const& tp, T& elem);
-    bool time_not_reached(unique_lock<mutex>&);
-    bool time_not_reached(lock_guard<mutex>&);
-    bool empty_or_time_not_reached(unique_lock<mutex>&);
-    bool empty_or_time_not_reached(lock_guard<mutex>&);
-
-    sync_timed_queue(const sync_timed_queue&);
-    sync_timed_queue& operator=(const sync_timed_queue&);
-    sync_timed_queue(BOOST_THREAD_RV_REF(sync_timed_queue));
-    sync_timed_queue& operator=(BOOST_THREAD_RV_REF(sync_timed_queue));
-  }; //end class
-
-
-  template <class T, class Clock>
-  template <class Duration>
-  void sync_timed_queue<T, Clock>::push(const T& elem, chrono::time_point<clock,Duration> const& tp)
-  {
-    super::push(stype(elem,tp));
-  }
-
-  template <class T, class Clock>
-  template <class Rep, class Period>
-  void sync_timed_queue<T, Clock>::push(const T& elem, chrono::duration<Rep,Period> const& dura)
-  {
-    push(elem, clock::now() + dura);
-  }
-
-  template <class T, class Clock>
-  template <class Duration>
-  void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
-  {
-    super::push(stype(boost::move(elem),tp));
-  }
-
-  template <class T, class Clock>
-  template <class Rep, class Period>
-  void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
-  {
-    push(boost::move(elem), clock::now() + dura);
-  }
-
-
-
-  template <class T, class Clock>
-  template <class Duration>
-  queue_op_status sync_timed_queue<T, Clock>::try_push(const T& elem, chrono::time_point<clock,Duration> const& tp)
-  {
-    return super::try_push(stype(elem,tp));
-  }
-
-  template <class T, class Clock>
-  template <class Rep, class Period>
-  queue_op_status sync_timed_queue<T, Clock>::try_push(const T& elem, chrono::duration<Rep,Period> const& dura)
-  {
-    return try_push(elem,clock::now() + dura);
-  }
-
-  template <class T, class Clock>
-  template <class Duration>
-  queue_op_status sync_timed_queue<T, Clock>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
-  {
-    return super::try_push(stype(boost::move(elem), tp));
-  }
-
-  template <class T, class Clock>
-  template <class Rep, class Period>
-  queue_op_status sync_timed_queue<T, Clock>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
-  {
-    return try_push(boost::move(elem), clock::now() + dura);
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  bool sync_timed_queue<T, Clock>::time_not_reached(unique_lock<mutex>&)
-  {
-    return super::data_.top().time_not_reached();
-  }
-
-  template <class T, class Clock>
-  bool sync_timed_queue<T, Clock>::time_not_reached(lock_guard<mutex>&)
-  {
-    return super::data_.top().time_not_reached();
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  bool sync_timed_queue<T, Clock>::wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>& lk)
-  {
-    for (;;)
-    {
-      if (super::closed(lk)) return true;
-      while (! super::empty(lk)) {
-        if (! time_not_reached(lk)) return false;
-        time_point tp = super::data_.top().time;
-        super::not_empty_.wait_until(lk, tp);
-        if (super::closed(lk)) return true;
-      }
-      if (super::closed(lk)) return true;
-      super::not_empty_.wait(lk);
-    }
-    //return false;
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  T sync_timed_queue<T, Clock>::pull_when_time_reached(unique_lock<mutex>& lk)
-  {
-    while (time_not_reached(lk))
-    {
-      super::throw_if_closed(lk);
-      time_point tp = super::data_.top().time;
-      super::not_empty_.wait_until(lk,tp);
-      super::wait_until_not_empty(lk);
-    }
-    return pull(lk);
-  }
-
-  template <class T, class Clock>
-  template <class Duration>
-  queue_op_status
-  sync_timed_queue<T, Clock>::pull_when_time_reached_until(unique_lock<mutex>& lk, chrono::time_point<clock,Duration> const& tp, T& elem)
-  {
-    chrono::time_point<clock,Duration> tpmin = (tp < super::data_.top().time) ? tp : super::data_.top().time;
-    while (time_not_reached(lk))
-    {
-      super::throw_if_closed(lk);
-      if (cv_status::timeout == super::not_empty_.wait_until(lk, tpmin)) {
-        if (time_not_reached(lk)) return queue_op_status::not_ready;
-        return queue_op_status::timeout;
-      }
-    }
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  bool sync_timed_queue<T, Clock>::empty_or_time_not_reached(unique_lock<mutex>& lk)
-  {
-    if ( super::empty(lk) ) return true;
-    if ( time_not_reached(lk) ) return true;
-    return false;
-  }
-  template <class T, class Clock>
-  bool sync_timed_queue<T, Clock>::empty_or_time_not_reached(lock_guard<mutex>& lk)
-  {
-    if ( super::empty(lk) ) return true;
-    if ( time_not_reached(lk) ) return true;
-    return false;
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  T sync_timed_queue<T, Clock>::pull(unique_lock<mutex>&)
-  {
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-    return boost::move(super::data_.pull().data);
-#else
-    return super::data_.pull().data;
-#endif
-  }
-
-  template <class T, class Clock>
-  T sync_timed_queue<T, Clock>::pull(lock_guard<mutex>&)
-  {
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-    return boost::move(super::data_.pull().data);
-#else
-    return super::data_.pull().data;
-#endif
-  }
-  template <class T, class Clock>
-  T sync_timed_queue<T, Clock>::pull()
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    super::wait_until_not_empty(lk);
-    return pull_when_time_reached(lk);
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  void sync_timed_queue<T, Clock>::pull(unique_lock<mutex>&, T& elem)
-  {
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-    elem = boost::move(super::data_.pull().data);
-#else
-    elem = super::data_.pull().data;
-#endif
-  }
-
-  template <class T, class Clock>
-  void sync_timed_queue<T, Clock>::pull(lock_guard<mutex>&, T& elem)
-  {
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-    elem = boost::move(super::data_.pull().data);
-#else
-    elem = super::data_.pull().data;
-#endif
-  }
-
-  template <class T, class Clock>
-  void sync_timed_queue<T, Clock>::pull(T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    super::wait_until_not_empty(lk);
-    elem = pull_when_time_reached(lk);
-  }
-
-  //////////////////////
-  template <class T, class Clock>
-  template <class Duration>
-  queue_op_status
-  sync_timed_queue<T, Clock>::pull_until(chrono::time_point<clock,Duration> const& tp, T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-
-    if (queue_op_status::timeout == super::wait_until_not_empty_until(lk, tp))
-      return queue_op_status::timeout;
-    return pull_when_time_reached_until(lk, tp, elem);
-  }
-
-  //////////////////////
-  template <class T, class Clock>
-  template <class Rep, class Period>
-  queue_op_status
-  sync_timed_queue<T, Clock>::pull_for(chrono::duration<Rep,Period> const& dura, T& elem)
-  {
-    return pull_until(clock::now() + dura, elem);
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  queue_op_status sync_timed_queue<T, Clock>::try_pull(unique_lock<mutex>& lk, T& elem)
-  {
-    if ( super::empty(lk) )
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::empty;
-    }
-    if ( time_not_reached(lk) )
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::not_ready;
-    }
-
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-  template <class T, class Clock>
-  queue_op_status sync_timed_queue<T, Clock>::try_pull(lock_guard<mutex>& lk, T& elem)
-  {
-    if ( super::empty(lk) )
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::empty;
-    }
-    if ( time_not_reached(lk) )
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-      return queue_op_status::not_ready;
-    }
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-
-  template <class T, class Clock>
-  queue_op_status sync_timed_queue<T, Clock>::try_pull(T& elem)
-  {
-    lock_guard<mutex> lk(super::mtx_);
-    return try_pull(lk, elem);
-  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  queue_op_status sync_timed_queue<T, Clock>::wait_pull(unique_lock<mutex>& lk, T& elem)
-  {
-    if (super::empty(lk))
-    {
-      if (super::closed(lk)) return queue_op_status::closed;
-    }
-    bool has_been_closed = wait_until_not_empty_time_reached_or_closed(lk);
-    if (has_been_closed) return queue_op_status::closed;
-    pull(lk, elem);
-    return queue_op_status::success;
-  }
-
-  template <class T, class Clock>
-  queue_op_status sync_timed_queue<T, Clock>::wait_pull(T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_);
-    return wait_pull(lk, elem);
-  }
-
-//  ///////////////////////////
-//  template <class T, class Clock>
-//  queue_op_status sync_timed_queue<T, Clock>::wait_pull(unique_lock<mutex> &lk, T& elem)
-//  {
-//    if (super::empty(lk))
-//    {
-//      if (super::closed(lk)) return queue_op_status::closed;
-//    }
-//    bool has_been_closed = super::wait_until_not_empty_or_closed(lk);
-//    if (has_been_closed) return queue_op_status::closed;
-//    pull(lk, elem);
-//    return queue_op_status::success;
-//  }
-//  template <class T>
-//  queue_op_status sync_timed_queue<T, Clock>::wait_pull(T& elem)
-//  {
-//    unique_lock<mutex> lk(super::mtx_);
-//    return wait_pull(lk, elem);
-//  }
-
-  ///////////////////////////
-  template <class T, class Clock>
-  queue_op_status sync_timed_queue<T, Clock>::nonblocking_pull(T& elem)
-  {
-    unique_lock<mutex> lk(super::mtx_, try_to_lock);
-    if (! lk.owns_lock()) return queue_op_status::busy;
-    return try_pull(lk, elem);
-  }
-
-} //end concurrent namespace
-
-using concurrent::sync_timed_queue;
-
-} //end boost namespace
-#include <boost/config/abi_suffix.hpp>
-
-#endif
--- a/include/boost/thread/csbl/deque.hpp
+++ b/include/boost/thread/csbl/deque.hpp
@@ -1,45 +0,0 @@
-// Copyright (C) 2013 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)
-//
-// 2013/10 Vicente J. Botet Escriba
-//   Creation.
-
-#ifndef BOOST_CSBL_DEQUE_HPP
-#define BOOST_CSBL_DEQUE_HPP
-
-#include <boost/config.hpp>
-// MSVC has some trouble instantiating a non_copyable type
-//C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\INCLUDE\xmemory0(606) : error C2248: 'non_copyable::non_copyable' : cannot access private member declared in class 'non_copyable'
-//        ..\libs\thread\test\sync\mutual_exclusion\queue_views\single_thread_pass.cpp(24) : see declaration of 'non_copyable::non_copyable'
-//        ..\libs\thread\test\sync\mutual_exclusion\queue_views\single_thread_pass.cpp(23) : see declaration of 'non_copyable'
-//        C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\INCLUDE\xmemory0(605) : while compiling class template member function 'void std::allocator<_Ty>::construct(_Ty *,const _Ty &)'
-//        with
-//        [
-//            _Ty=non_copyable
-//        ]
-#if defined BOOST_THREAD_USES_BOOST_DEQUE || defined BOOST_NO_CXX11_RVALUE_REFERENCES || (defined _MSC_VER && _MSC_FULL_VER < 180020827)
-#ifndef BOOST_THREAD_USES_BOOST_DEQUE
-#define BOOST_THREAD_USES_BOOST_DEQUE
-#endif
-#include <boost/container/deque.hpp>
-#else
-#include <deque>
-#endif
-
-namespace boost
-{
-  namespace csbl
-  {
-#if defined BOOST_THREAD_USES_BOOST_DEQUE
-    using ::boost::container::deque;
-
-#else
-    using ::std::deque;
-
-#endif
-
-  }
-}
-#endif // header
--- a/include/boost/thread/csbl/devector.hpp
+++ b/include/boost/thread/csbl/devector.hpp
@@ -1,102 +0,0 @@
-// Copyright (C) 2013 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)
-//
-// 2013/10 Vicente J. Botet Escriba
-//   Creation.
-
-#ifndef BOOST_CSBL_DEVECTOR_HPP
-#define BOOST_CSBL_DEVECTOR_HPP
-
-#include <boost/config.hpp>
-
-#include <boost/thread/csbl/vector.hpp>
-#include <boost/move/detail/move_helpers.hpp>
-
-namespace boost
-{
-  namespace csbl
-  {
-    template <class T>
-    class devector
-    {
-      typedef csbl::vector<T> vector_type;
-      vector_type data_;
-      std::size_t front_index_;
-
-      BOOST_COPYABLE_AND_MOVABLE(devector)
-
-      template <class U>
-      void priv_push_back(BOOST_FWD_REF(U) x)
-      { data_.push_back(boost::forward<U>(x)); }
-
-    public:
-      typedef typename vector_type::size_type size_type;
-      typedef typename vector_type::reference reference;
-      typedef typename vector_type::const_reference const_reference;
-
-
-      devector() : front_index_(0) {}
-      devector(devector const& x) BOOST_NOEXCEPT
-         :  data_(x.data_),
-            front_index_(x.front_index_)
-      {}
-      devector(BOOST_RV_REF(devector) x) BOOST_NOEXCEPT
-         :  data_(boost::move(x.data_)),
-            front_index_(x.front_index_)
-      {}
-
-      devector& operator=(BOOST_COPY_ASSIGN_REF(devector) x)
-      {
-         if (&x != this)
-         {
-           data_ = x.data_;
-           front_index_ = x.front_index_;
-         }
-         return *this;
-      }
-
-      devector& operator=(BOOST_RV_REF(devector) x)
-#if defined BOOST_THREAD_USES_BOOST_VECTOR
-         BOOST_NOEXCEPT_IF(vector_type::allocator_traits_type::propagate_on_container_move_assignment::value)
-#endif
-      {
-        data_ = boost::move(x.data_);
-        front_index_ = x.front_index_;
-        return *this;
-      }
-
-      bool empty() const BOOST_NOEXCEPT
-      { return data_.size() == front_index_; }
-
-      size_type size() const BOOST_NOEXCEPT
-      { return data_.size() - front_index_; }
-
-      reference         front() BOOST_NOEXCEPT
-      { return data_[front_index_]; }
-
-      const_reference         front() const BOOST_NOEXCEPT
-      { return data_[front_index_]; }
-
-      reference         back() BOOST_NOEXCEPT
-      { return data_.back(); }
-
-      const_reference         back() const BOOST_NOEXCEPT
-      { return data_.back(); }
-
-      BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
-
-      void pop_front()
-      {
-        ++front_index_;
-        if (empty()) {
-          data_.clear();
-          front_index_=0;
-        }
-       }
-
-    };
-  }
-}
-#endif // header
--- a/include/boost/thread/csbl/functional.hpp
+++ b/include/boost/thread/csbl/functional.hpp
@@ -1,49 +0,0 @@
-// Copyright (C) 2013 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)
-//
-// 2013/10 Vicente J. Botet Escriba
-//   Creation.
-
-#ifndef BOOST_CSBL_FUNCTIONAL_HPP
-#define BOOST_CSBL_FUNCTIONAL_HPP
-
-#include <boost/config.hpp>
-
-#include <functional>
-
-#if defined BOOST_THREAD_USES_BOOST_FUNCTIONAL || defined BOOST_NO_CXX11_HDR_FUNCTIONAL || defined BOOST_NO_CXX11_RVALUE_REFERENCES
-#ifndef BOOST_THREAD_USES_BOOST_FUNCTIONAL
-#define BOOST_THREAD_USES_BOOST_FUNCTIONAL
-#endif
-#include <boost/function.hpp>
-#endif
-
-namespace boost
-{
-  namespace csbl
-  {
-#if defined BOOST_THREAD_USES_BOOST_FUNCTIONAL
-    using ::boost::function;
-#else
-    // D.8.1, base (deprecated):
-    // 20.9.3, reference_wrapper:
-    // 20.9.4, arithmetic operations:
-    // 20.9.5, comparisons:
-    // 20.9.6, logical operations:
-    // 20.9.7, bitwise operations:
-    // 20.9.8, negators:
-    // 20.9.9, bind:
-    // D.9, binders (deprecated):
-    // D.8.2.1, adaptors (deprecated):
-    // D.8.2.2, adaptors (deprecated):
-    // 20.9.10, member function adaptors:
-    // 20.9.11 polymorphic function wrappers:
-    using ::std::function;
-    // 20.9.12, hash function primary template:
-#endif
-
-  }
-}
-#endif // header
--- a/include/boost/thread/csbl/list.hpp
+++ b/include/boost/thread/csbl/list.hpp
@@ -1,35 +0,0 @@
-// Copyright (C) 2013 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)
-//
-// 2013/10 Vicente J. Botet Escriba
-//   Creation.
-
-#ifndef BOOST_CSBL_LIST_HPP
-#define BOOST_CSBL_LIST_HPP
-
-#include <boost/config.hpp>
-
-#if defined BOOST_THREAD_USES_BOOST_LIST || defined BOOST_NO_CXX11_RVALUE_REFERENCES
-#ifndef BOOST_THREAD_USES_BOOST_LIST
-#define BOOST_THREAD_USES_BOOST_LIST
-#endif
-#include <boost/container/list.hpp>
-#else
-#include <list>
-#endif
-
-namespace boost
-{
-  namespace csbl
-  {
-#if defined BOOST_THREAD_USES_BOOST_LIST
-    using ::boost::container::list;
-#else
-    using ::std::list;
-#endif
-
-  }
-}
-#endif // header
--- a/include/boost/thread/csbl/memory.hpp
+++ b/include/boost/thread/csbl/memory.hpp
@@ -1,61 +0,0 @@
-// Copyright (C) 2013 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)
-//
-// 2013/10 Vicente J. Botet Escriba
-//   Creation.
-
-#ifndef BOOST_CSBL_MEMORY_HPP
-#define BOOST_CSBL_MEMORY_HPP
-
-// 20.7.2 Header <memory> synopsis
-
-// 20.7.3, pointer traits
-#include <boost/thread/csbl/memory/pointer_traits.hpp>
-
-// 20.7.4, pointer safety
-// 20.7.5, pointer alignment function
-
-// 20.7.6, allocator argument tag
-#include <boost/thread/csbl/memory/allocator_arg.hpp>
-
-// 20.7.8, allocator traits
-#include <boost/thread/csbl/memory/allocator_traits.hpp>
-
-// 20.7.7, uses_allocator
-#include <boost/thread/csbl/memory/scoped_allocator.hpp>
-
-// 20.7.9, the default allocator:
-namespace boost
-{
-  namespace csbl
-  {
-    using ::std::allocator;
-  }
-}
-// 20.7.10, raw storage iterator:
-// 20.7.11, temporary buffers:
-// 20.7.12, specialized algorithms:
-
-// 20.8.1 class template unique_ptr:
-// default_delete
-#include <boost/thread/csbl/memory/default_delete.hpp>
-#include <boost/thread/csbl/memory/unique_ptr.hpp>
-
-// 20.8.2.1, class bad_weak_ptr:
-// 20.8.2.2, class template shared_ptr:
-// 20.8.2.2.6, shared_ptr creation
-// 20.8.2.2.7, shared_ptr comparisons:
-// 20.8.2.2.8, shared_ptr specialized algorithms:
-// 20.8.2.2.9, shared_ptr casts:
-// 20.8.2.2.10, shared_ptr get_deleter:
-// 20.8.2.2.11, shared_ptr I/O:
-// 20.8.2.3, class template weak_ptr:
-// 20.8.2.3.6, weak_ptr specialized algorithms:
-// 20.8.2.3.7, class template owner_less:
-// 20.8.2.4, class template enable_shared_from_this:
-// 20.8.2.5, shared_ptr atomic access:
-// 20.8.2.6 hash support
-
-#endif // header
--- a/include/boost/thread/csbl/memory/allocator_arg.hpp
+++ b/include/boost/thread/csbl/memory/allocator_arg.hpp
@@ -1,41 +0,0 @@
-// Copyright (C) 2013 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)
-//
-// 2013/10 Vicente J. Botet Escriba
-//   Creation.
-
-#ifndef BOOST_CSBL_MEMORY_ALLOCATOR_ARG_HPP
-#define BOOST_CSBL_MEMORY_ALLOCATOR_ARG_HPP
-
-#include <boost/thread/csbl/memory/config.hpp>
-
-// 20.7.6, allocator argument tag
-#if defined BOOST_NO_CXX11_ALLOCATOR
-#include <boost/container/scoped_allocator.hpp>
-
-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::container::allocator_arg_t;
-    using ::boost::container::allocator_arg;
-  }
-}
-#else
-namespace boost
-{
-  namespace csbl
-  {
-    using ::std::allocator_arg_t;
-    using ::std::allocator_arg;
-  }
-}
-#endif // BOOST_NO_CXX11_ALLOCATOR
-namespace boost
-{
-  using ::boost::csbl::allocator_arg_t;
-  using ::boost::csbl::allocator_arg;
-}
-#endif // header
--- a/include/boost/thread/csbl/memory/allocator_traits.hpp
+++ b/include/boost/thread/csbl/memory/allocator_traits.hpp
@@ -1,35 +0,0 @@
-// Copyright (C) 2013 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)
-//
-// 2013/10 Vicente J. Botet Escriba
-//   Creation.
-
-#ifndef BOOST_CSBL_MEMORY_ALLOCATOR_TRAITS_HPP
-#define BOOST_CSBL_MEMORY_ALLOCATOR_TRAITS_HPP
-
-#include <boost/thread/csbl/memory/config.hpp>
-
-// 20.7.8, allocator traits
-#if defined BOOST_NO_CXX11_ALLOCATOR
-#include <boost/container/allocator_traits.hpp>
-
-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::container::allocator_traits;
-  }
-}
-#else
-namespace boost
-{
-  namespace csbl
-  {
-    using ::std::allocator_traits;
-  }
-}
-#endif // BOOST_NO_CXX11_POINTER_TRAITS
-
-#endif // header
--- a/Show More
+++ b/Show More