go on with the future refactoring.

minor fix on clang with executor forward declaration.
2026-07-22 13:43:42 +00:00 · 2015-10-14 03:04:26 +02:00 · 2015-10-13 23:55:38 +02:00 · 2015-10-13 19:15:18 +02:00 · 2015-10-13 19:13:56 +02:00 · 2015-10-13 03:08:59 +02:00
116 changed files with 4337 additions and 3554 deletions
@@ -1,365 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-os:
-  - linux
-  - osx
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-#    - os: linux
-#      compiler: g++-4.7
-#      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.7
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-4.8
-#      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-4.9
-#      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++98
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++98
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++98
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-#    - os: linux
-#      compiler: clang++-3.5
-#      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.5#
-#
-#    - os: linux
-#      compiler: clang++-3.6
-#      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.6
-#
-#    - os: linux
-#      compiler: clang++-3.7
-#      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.7
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.7
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++98
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++98
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - mkdir -p libs/thread
-  - cp -r $TRAVIS_BUILD_DIR/* libs/thread
-  - python tools/boostdep/depinst/depinst.py thread
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - ./b2 -j3 libs/thread/test toolset=$TOOLSET
-
-notifications:
-  email:
-    on_success: always
@@ -7,4 +7,135 @@ Portable C++ multi-threading. C++11, C++14.

 Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

+### Current Jenkins CI Test Status for unstable (develop) branch
+Overall build (nightly): <a href='https://ci.nedprod.com/view/All/job/Boost.Thread%20Build/'><img src='https://ci.nedprod.com/buildStatus/icon?job=Boost.Thread%20Build'></a> Overall tests (weekly, on Sundays): <a href='https://ci.nedprod.com/view/All/job/Boost.Thread%20Test/'><img src='https://ci.nedprod.com/buildStatus/icon?job=Boost.Thread%20Test'></a>

+#### Build (nightly):
+<table id="configuration-matrix" width="100%" border="1">
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="6" valign="top">android-ndk</td><td class="matrix-leftcolumn" rowspan="2" valign="top">c++03</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.6,LINKTYPE=static,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.6</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.8,LINKTYPE=static,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.5,LINKTYPE=static,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.6,LINKTYPE=shared,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.6</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.8,LINKTYPE=shared,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.5,LINKTYPE=shared,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++11</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.8,LINKTYPE=static,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.5,LINKTYPE=static,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.8,LINKTYPE=shared,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.5,LINKTYPE=shared,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++14</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=clang++-3.5,LINKTYPE=static,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=clang++-3.5,LINKTYPE=shared,label=android-ndk/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="6" valign="top">winphone8</td>
+  </tr>
+  <tr>
+    <td/>
+  </tr>
+  <tr>
+    <td/>
+  </tr>
+  <tr>
+    <td/>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++14</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-11.0,LINKTYPE=static,label=winphone8/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-11.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-12.0,LINKTYPE=static,label=winphone8/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-12.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-14.0,LINKTYPE=static,label=winphone8/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-14.0</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-11.0,LINKTYPE=shared,label=winphone8/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-11.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-12.0,LINKTYPE=shared,label=winphone8/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-12.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-14.0,LINKTYPE=shared,label=winphone8/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-14.0</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="6" valign="top">arm-gcc-clang</td><td class="matrix-leftcolumn" rowspan="2" valign="top">c++03</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.9,LINKTYPE=static,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.5,LINKTYPE=static,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.9,LINKTYPE=shared,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.5,LINKTYPE=shared,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++11</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.9,LINKTYPE=static,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.5,LINKTYPE=static,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.9,LINKTYPE=shared,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.5,LINKTYPE=shared,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++14</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=g++-4.9,LINKTYPE=static,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=g++-4.9,LINKTYPE=shared,label=arm-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="6" valign="top">freebsd10-clang3.3</td><td class="matrix-leftcolumn" rowspan="2" valign="top">c++03</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.3,LINKTYPE=static,label=freebsd10-clang3.3/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.3,LINKTYPE=shared,label=freebsd10-clang3.3/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++11</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.3,LINKTYPE=static,label=freebsd10-clang3.3/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.3,LINKTYPE=shared,label=freebsd10-clang3.3/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td>
+  </tr>
+  <tr>
+    <td/>
+  </tr>
+  <tr>
+    <td/>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="6" valign="top">linux-gcc-clang</td><td class="matrix-leftcolumn" rowspan="2" valign="top">c++03</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.6,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.6</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.7,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.7</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.2,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.2</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.3,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.4,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.4</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.6,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.6</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.7,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.7</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.2,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.2</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.3,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.4,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.4</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++11</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.7,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.7</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.2,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.2</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.3,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.4,LINKTYPE=static,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.4</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.7,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.7</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.2,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.2</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.3,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.3</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.4,LINKTYPE=shared,label=linux-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.4</div></td>
+  </tr>
+  <tr>
+    <td/>
+  </tr>
+  <tr>
+    <td/>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="6" valign="top">linux64-gcc-clang</td><td class="matrix-leftcolumn" rowspan="2" valign="top">c++03</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-analyse,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Unstable" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/yellow.png" tooltip="Unstable"/></a>clang++-analyse</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.8,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.9,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.5,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-analyse,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Unstable" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/yellow.png" tooltip="Unstable"/></a>clang++-analyse</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.8,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=g++-4.9,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=clang++-3.5,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++11</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-analyse,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-analyse</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.8,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.9,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.5,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-analyse,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-analyse</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.8,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.8</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=g++-4.9,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=clang++-3.5,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++14</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=clang++-analyse,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-analyse</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=g++-4.9,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=clang++-3.5,LINKTYPE=static,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=clang++-analyse,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-analyse</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=g++-4.9,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>g++-4.9</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=clang++-3.5,LINKTYPE=shared,label=linux64-gcc-clang/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>clang++-3.5</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="6" valign="top">win8-msvc-mingw</td><td class="matrix-leftcolumn" rowspan="2" valign="top">c++03</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=mingw32,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw32</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=mingw64,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw64</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=mingw32,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw32</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++03,CXX=mingw64,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw64</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++11</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=mingw32,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw32</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=mingw64,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw64</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=mingw32,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw32</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++11,CXX=mingw64,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>mingw64</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="2" valign="top">c++14</td><td class="matrix-leftcolumn" rowspan="1" valign="top">static</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-10.0,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-10.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-11.0,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-11.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-12.0,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-12.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-14.0,LINKTYPE=static,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-14.0</div></td>
+  </tr>
+  <tr>
+    <td class="matrix-leftcolumn" rowspan="1" valign="top">shared</td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-analyse,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-analyse</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-10.0,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-10.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-11.0,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-11.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-12.0,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-12.0</div></td><td class="matrix-cell"><div><a class="model-link inside" href="https://ci.nedprod.com/job/Boost.Thread%20Build/CPPSTD=c++14,CXX=msvc-14.0,LINKTYPE=shared,label=win8-msvc-mingw/"><img height="24" alt="Success" width="24" src="https://ci.nedprod.com/static/5e289396/images/24x24/blue.png" tooltip="Success"/></a>msvc-14.0</div></td>
+  </tr>
+</table>
@@ -1,41 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-12.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\thread\
-  - python tools/boostdep/depinst/depinst.py thread
-  - cmd /c bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - b2 libs/mp11/test toolset=%TOOLSET%
@@ -60,8 +60,7 @@ 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>-Wno-variadic-macros
        #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
        <toolset>gcc:<cxxflags>-Wunused-function
        <toolset>gcc:<cxxflags>-Wno-unused-parameter
@@ -71,9 +70,7 @@ project boost/thread
        #<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>-Wno-variadic-macros
        #<toolset>darwin:<cxxflags>-Wunused-local-typedefs
        <toolset>darwin:<cxxflags>-Wunused-function
        <toolset>darwin:<cxxflags>-Wno-unused-parameter
@@ -126,8 +123,6 @@ project boost/thread
        <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)
@@ -318,5 +313,3 @@ lib boost_thread
      <link>static:<define>BOOST_THREAD_USE_LIB=1
      <conditional>@usage-requirements
    ;
-
-boost-install boost_thread ;
@@ -29,12 +29,4 @@ boostbook standalone
        <xsl:param>boost.root=../../../..
    ;

-###############################################################################
-alias boostdoc
-    : thread
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;
+
@@ -112,7 +112,7 @@ A question arises of which of these executors (or others) be included in this li
 [////////////////////////]
 [section:rationale Design Rationale]

-The authors of Boost.Thread have taken a different approach respect to N3785. Instead of basing all the design on an abstract executor class we make executor concepts. We believe that this is the good direction as a static polymorphic executor can be seen as a dynamic polymorphic executor using a simple adaptor. We believe also that it would make the library more usable, and more convenient for users.
+The authors of Boost.Thread have taken a different approach respect to N3785. Instead of basing all the design on a abstract executor class we make executor concepts. We believe that this is the good direction as a static polymorphic executor can be seen as a dynamic polymorphic executor using a simple adaptor. We believe also that it would make the library more usable, and more convenient for users.

 The major design decisions concern deciding what a unit of work is, how to manage with units of work and time related functions in a polymorphic way.

@@ -174,7 +174,7 @@ This has several advantages:
 * The scheduled operations are available for all the executors via wrappers.
 * The template functions could accept any chrono `time_point` and `duration` respectively as we are not working with virtual functions.

-In order to manage with all the clocks, this library propose generic solution. `scheduler<Clock>` know how to manage with the `submit_at`/`submit_after` `Clock::time_point`/`Clock::duration` tasks. Note that the durations on different clocks differ.
+In order to manage with all the clocks, this library propose a generic solution. `scheduler<Clock>` know how to manage with the `submit_at`/`submit_after` `Clock::time_point`/`Clock::duration` tasks. Note that the durations on different clocks differ.

 [heading Not Handled Exceptions]
 As in N3785 and based on the same design decision than `std`/`boost::thread` if a user closure throws an exception, the executor must call the `std::terminate` function.
@@ -364,8 +364,8 @@ A type `E` meets the `Executor` requirements if the following expressions are we
 where 

 * `e` denotes a value of type `E`, 
-* `lc` denotes a lvalue reference of type `Closure`, 
-* `rc` denotes a rvalue reference of type `Closure`
+* `lc` denotes a lvalue referece of type `Closure`, 
+* `rc` denotes a rvalue referece of type `Closure`
 * `p` denotes a value of type `Predicate`

 [/////////////////////////////////////]
@@ -388,7 +388,7 @@ If invoked closure throws an exception the executor will call std::terminate, as

 [endsect]
 [/////////////////////////////////////]
-[section:submitrc `e.submit(rc);`]
+[section:submitrc `e.submit(lc);`]

 [variablelist

@@ -417,7 +417,7 @@ If invoked closure throws an exception the executor will call std::terminate, as

 [[Return type:] [`void`.]]

-[[Throws:] [Whatever exception that can be thrown while ensuring the thread safety.]]
+[[Throws:] [Whatever exception that can be throw while ensuring the thread safety.]]

 [[Exception safety:] [If an exception is thrown then the executor state is unmodified.]]

@@ -462,7 +462,7 @@ If invoked closure throws an exception the executor will call std::terminate, as

 [variablelist

-[[Requires:] [This must be called from a scheduled work]]
+[[Requires:] [This must be called from an scheduled work]]

 [[Effects:] [reschedule works until `p()`.]]

@@ -506,9 +506,6 @@ Executor abstract base class.
    public:
      typedef  boost::work work;
  
-      executor(executor const&) = delete;
-      executor& operator=(executor const&) = delete;
-
      executor(); 
      virtual ~executor() {};
  
@@ -533,7 +530,7 @@ Executor abstract base class.

 [variablelist

-[[Effects:] [Constructs an executor. ]]
+[[Effects:] [Constructs a executor. ]]

 [[Throws:] [Nothing. ]]

@@ -573,9 +570,6 @@ Polymorphic adaptor of a model of Executor to an executor.
    public:
      typedef  executor::work work;
  
-      executor_adaptor(executor_adaptor const&) = delete;
-      executor_adaptor& operator=(executor_adaptor const&) = delete;
-  
      template <typename ...Args>
      executor_adaptor(Args&& ... args);

@@ -600,7 +594,7 @@ Polymorphic adaptor of a model of Executor to an executor.

 [variablelist

-[[Effects:] [Constructs an executor_adaptor. ]]
+[[Effects:] [Constructs a executor_adaptor. ]]

 [[Throws:] [Nothing. ]]

@@ -641,20 +635,24 @@ Polymorphic adaptor of a model of Executor to an executor.
 [/////////////////////////////////]
 [section:generic_executor_ref Class `generic_executor_ref`]

-Executor abstract base class.
+Type erased executor class.

  #include <boost/thread/generic_executor_ref.hpp>
  namespace boost {
    class generic_executor_ref
    {
    public:
-      generic_executor_ref(generic_executor_ref const&);
-      generic_executor_ref& operator=(generic_executor_ref const&);

      template <class Executor>
      generic_executor_ref(Executor& ex); 
-      generic_executor_ref() {};
+      generic_executor_ref() = delete;
+      generic_executor_ref(generic_executor_ref const&) = default;
+      generic_executor_ref(generic_executor_ref &&) = default;
+      generic_executor_ref& operator=(generic_executor_ref const&) = default;
+      generic_executor_ref& operator=(generic_executor_ref &&) = default;
  
+      executor& underlying_executor() noexcept;
+
      void close() = 0;
      bool closed() = 0;
  
@@ -669,6 +667,44 @@ Executor abstract base class.

 [endsect]

+
+[/////////////////////////////////]
+[section:generic_executor Class `generic_executor`]
+
+Type erased executor class.
+
+  #include <boost/thread/generic_executor.hpp>
+  namespace boost {
+    class generic_executor
+    {
+    public:
+
+      template <class Executor>
+      generic_executor(Executor& ex); 
+      generic_executor() = delete;
+
+      generic_executor(generic_executor const&) = default;
+      generic_executor(generic_executor &&) = default;
+      generic_executor& operator=(generic_executor const&) = default;
+      generic_executor& operator=(generic_executor &&) = default;
+  
+      executor& underlying_executor() noexcept;
+
+      void close() = 0;
+      bool closed() = 0;
+  
+      template <typename Closure>
+      void submit(Closure&& closure);
+  
+      virtual bool try_executing_one() = 0;
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred);
+    };
+  }
+
+[endsect]
+
+
 [//////////////////////////////////////////////////////////]
 [section: scheduler Template Class `scheduler `]

@@ -683,10 +719,7 @@ Scheduler providing time related functions. Note that `scheduler` is not an Exec
    public:
      using work = boost::function<void()> ;
      using clock = Clock;
-
-      scheduler(scheduler const&) = delete;
-      scheduler& operator=(scheduler const&) = delete;
-  
+ 
      scheduler();
      ~scheduler();
 
@@ -733,7 +766,7 @@ Scheduler providing time related functions. Note that `scheduler` is not an Exec

 [[Effects:] [Destroys the scheduler.]]

-[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
+[[Synchronization:] [The completion of all the closures happen before the completion of the destructor.]]

 ]

@@ -1339,10 +1372,6 @@ A serial executor ensuring that there are no two work units that executes concur
    class serial_executor
    {
    public:
-      serial_executor(serial_executor const&) = delete;
-      serial_executor& operator=(serial_executor const&) = delete;
-  
-      template <class Executor>
      serial_executor(Executor& ex);
 
      Executor& underlying_executor() noexcept;
@@ -1393,7 +1422,7 @@ A serial executor ensuring that there are no two work units that executes concur
 [/////////////////////////////////////]
 [section:underlying_executor Function member `underlying_executor()`]

-      generic_executor_ref& underlying_executor() noexcept;
+      Executor& underlying_executor() noexcept;

 [variablelist

@@ -1418,13 +1447,10 @@ A serial executor ensuring that there are no two work units that executes concur
    class generic_serial_executor
    {
    public:
-      generic_serial_executor(generic_serial_executor const&) = delete;
-      generic_serial_executor& operator=(generic_serial_executor const&) = delete;
-  
      template <class Executor>
      generic_serial_executor(Executor& ex);
 
-      generic_executor_ref& underlying_executor() noexcept;
+      generic_executor& underlying_executor() noexcept;

      void close();
      bool closed();
@@ -1433,6 +1459,7 @@ A serial executor ensuring that there are no two work units that executes concur
      void submit(Closure&& closure);
  
      bool try_executing_one();
+
      template <typename Pred>
      bool reschedule_until(Pred const& pred);

@@ -1456,7 +1483,7 @@ A serial executor ensuring that there are no two work units that executes concur

 [endsect]
 [/////////////////////////////////////]
-[section:destructor Destructor `~serial_executor()`]
+[section:destructor Destructor `~generic_serial_executor()`]

      ~generic_serial_executor();

@@ -1468,6 +1495,80 @@ A serial executor ensuring that there are no two work units that executes concur

 ]

+[endsect]
+[/////////////////////////////////////]
+[section:underlying_executor Function member `underlying_executor()`]
+
+      generic_executor& underlying_executor() noexcept;
+
+[variablelist
+
+[[Return:] [The underlying executor instance. ]]
+
+]
+
+
+[endsect]
+
+[endsect]
+
+[//////////////////////////////////////////////////////////]
+[section:serial_executor_cont Template Class `serial_executor_cont`]
+
+A serial executor ensuring that there are no two work units that executes concurrently.
+
+  #include <boost/thread/serial_executor_cont.hpp>
+  namespace boost {
+    template <class Executor>
+    class serial_executor_cont
+    {
+    public:
+      serial_executor_cont(Executor& ex);
+ 
+      Executor& underlying_executor() noexcept;
+
+      void close();
+      bool closed();
+  
+      template <typename Closure>
+      void submit(Closure&& closure);
+  
+      bool try_executing_one();
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred);
+
+    };
+  }
+
+[/////////////////////////////////////]
+[section:constructor Constructor `serial_executor_cont(Executor&)`]
+
+      template <class Executor>
+      serial_executor_cont(Executor& ex);
+
+[variablelist
+
+[[Effects:] [Constructs a serial_executor_cont. ]]
+
+[[Throws:] [Nothing. ]]
+
+]
+
+
+[endsect]
+[/////////////////////////////////////]
+[section:destructor Destructor `~serial_executor_cont()`]
+
+      ~serial_executor_cont();
+
+[variablelist
+
+[[Effects:] [Destroys the serial_executor.]]
+
+[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
+
+]
+
 [endsect]
 [/////////////////////////////////////]
 [section:underlying_executor Function member `underlying_executor()`]
@@ -1478,6 +1579,8 @@ A serial executor ensuring that there are no two work units that executes concur

 [[Return:] [The underlying executor instance. ]]

+[[Throws:] [Nothing.]]
+
 ]


@@ -1485,6 +1588,82 @@ A serial executor ensuring that there are no two work units that executes concur

 [endsect]

+[//////////////////////////////////////////////////////////]
+[section:generic_serial_cont_executor Class `generic_serial_cont_executor`]
+
+A serial executor ensuring that there are no two work units that executes concurrently.
+
+  #include <boost/thread/generic_serial_cont_executor.hpp>
+  namespace boost {
+    class generic_serial_cont_executor
+    {
+    public:
+      template <class Executor>
+      generic_serial_cont_executor(Executor& ex);
+ 
+      generic_executor& underlying_executor() noexcept;
+
+      void close();
+      bool closed();
+  
+      template <typename Closure>
+      void submit(Closure&& closure);
+  
+      bool try_executing_one();
+
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred);
+
+    };
+  }
+
+[/////////////////////////////////////]
+[section:constructor Constructor `generic_serial_cont_executor(Executor&)`]
+
+      template <class Executor>
+      generic_serial_cont_executor(Executor& ex);
+
+[variablelist
+
+[[Effects:] [Constructs a generic_serial_cont_executor. ]]
+
+[[Throws:] [Nothing. ]]
+
+]
+
+
+[endsect]
+[/////////////////////////////////////]
+[section:destructor Destructor `~generic_serial_cont_executor()`]
+
+      ~generic_serial_cont_executor();
+
+[variablelist
+
+[[Effects:] [Destroys the generic_serial_cont_executor.]]
+
+[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
+
+]
+
+[endsect]
+[/////////////////////////////////////]
+[section:underlying_executor Function member `underlying_executor()`]
+
+      generic_executor& underlying_executor() noexcept;
+
+[variablelist
+
+[[Return:] [The underlying executor instance. ]]
+
+]
+
+
+[endsect]
+
+[endsect]
+
+

 [//////////////////////////////////////////////////////////]
 [section:inline_executor Class `inline_executor`]
@@ -1496,10 +1675,8 @@ A serial executor ensuring that there are no two work units that executes concur
    class inline_executor
    {
    public:
-      inline_executor(inline_executor const&) = delete;
-      inline_executor& operator=(inline_executor const&) = delete;
-  
      inline_executor();
+      ~inline_executor();
 
      void close();
      bool closed();
@@ -1521,7 +1698,7 @@ A serial executor ensuring that there are no two work units that executes concur

 [variablelist

-[[Effects:] [Constructs an inline_executor. ]]
+[[Effects:] [Constructs a inline_executor. ]]

 [[Throws:] [Nothing. ]]

@@ -1560,9 +1737,6 @@ A thread pool with up to a fixed number of threads.
    class basic_thread_pool
    { 
    public:
- 
-      basic_thread_pool(basic_thread_pool const&) = delete;
-      basic_thread_pool& operator=(basic_thread_pool const&) = delete;
  
      basic_thread_pool(unsigned const thread_count = thread::hardware_concurrency());
      template <class AtThreadEntry>
@@ -1623,9 +1797,6 @@ A thread_executor with a threads for each task.
    { 
    public:
 
-      thread_executor(thread_executor const&) = delete;
-      thread_executor& operator=(thread_executor const&) = delete;
-  
      thread_executor();
      template <class AtThreadEntry>
      basic_thread_pool( unsigned const thread_count, AtThreadEntry at_thread_entry);
@@ -1680,9 +1851,6 @@ A user scheduled executor.
    class loop_executor
    { 
    public:
- 
-      loop_executor(loop_executor const&) = delete;
-      loop_executor& operator=(loop_executor const&) = delete;
  
      loop_executor();
      ~loop_executor();
@@ -1709,7 +1877,7 @@ A user scheduled executor.

 [variablelist

-[[Effects:] [creates an executor that runs closures using one of its closure-executing methods. ]]
+[[Effects:] [creates a executor that runs closures using one of its closure-executing methods. ]]

 [[Throws:] [Whatever exception is thrown while initializing the needed resources. ]]

@@ -1,6 +1,6 @@
 [/
  (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-17 Vicente J. Botet Escriba.
+  (C) Copyright 2011-15 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,125 +8,6 @@

 [section:changes History]

-[heading Version 4.8.0 - boost 1.66]
-
-[*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/10964 #10964] future<future<T>>::unwrap().then() Deadlocks
-
-
-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 master regression test] to see the last regression test snapshot.
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/12949 #12949] using sleep_for in a thread context without including boost/thread/thread.hpp yields incorrect behaviour when BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC is defined
-* [@http://svn.boost.org/trac/boost/ticket/13019 #13019] ABI compatibility for BOOST_THREAD_PROVIDES_INTERRUPTIONS incomplete
-* [@http://svn.boost.org/trac/boost/ticket/13163 #13163] boost::detail::heap_new does not have a variadic variant
-
-* [@https://github.com/boostorg/thread/issues/130 #130] windows: Bug in boost::condition_variable on Windows
-
-[heading Version 4.7.4 - boost 1.65]
-
-[*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/12519 #12519] boost::thread::try_join_for does not return after timeout
-* [@http://svn.boost.org/trac/boost/ticket/12874 #12874] future<> extension constructor must be under BOOST_THREAD_PROVIDES_FUTURE_UNWRAP
-* [@http://svn.boost.org/trac/boost/ticket/12888 #12888] Linking with boost thread does not work on mingw/gcc 4.4
-* [@http://svn.boost.org/trac/boost/ticket/12958 #12958] sync_bounded_queue::wait_pull_front( lve ) might throw
-* [@http://svn.boost.org/trac/boost/ticket/13077 #13077] Linking to static 64bit libboost_thread fails DLL initialization
-* [@http://svn.boost.org/trac/boost/ticket/13155 #13155] log doesn't build on a system with pthreads
-
-* [@https://github.com/boostorg/thread/issues/121 #121] on_tls_prepare is broken under VS2017
-
-[heading Version 4.7.3 - boost 1.64]
-
-[*Fixed Bugs:]
-
-* [@https://github.com/boostorg/thread/issues/113 #113] Add a Thread template on all the scoped thread and thread guard classes
-* [@https://github.com/boostorg/thread/issues/117 #117] loop_executor should block on it's work_queue instead of polling
-* [@https://github.com/boostorg/thread/issues/119 #119] basic_condition_variable::relocker::~relocker can throw an exception
-
-[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 master 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:]
@@ -142,16 +23,11 @@ Please take a look at [@http://www.boost.org/development/tests/master/developer/

 [*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/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
 * [@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
@@ -159,33 +35,23 @@ Please take a look at [@http://www.boost.org/development/tests/master/developer/
 * [@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/11158 #11158] Pthread thread deadlock when faketime used
 * [@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/11562 #11562] Timer (using steady_clock) 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]

@@ -81,7 +81,7 @@ When `BOOST_THREAD_VERSION>3`  && defined BOOST_THREAD_PLATFORM_PTHREAD define `

 [section:move  Boost.Atomic]

-Boost.Thread uses by default Boost.Atomic in POSIX platforms to implement call_once..
+Boost.Thread uses by default an Boost.Atomic in POSIX platforms to implement call_once..

 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.
@@ -267,7 +267,7 @@ The library provides un implicit conversion to an undefined type that can be use
        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:

@@ -29,11 +29,9 @@

    enum class launch
    {
-      none = unspecified,
      async = unspecified,
      deferred = unspecified,
      executor = unspecified,
-      inherit = unspecified,
      any = async | deferred
    };
    
@@ -127,10 +125,10 @@
      future<typename decay<T>::type> make_ready_future(T&& value);  // EXTENSION
    future<void> make_ready_future();  // EXTENSION

-    exceptional_ptr make_exceptional_future(exception_ptr ex);  // EXTENSION
+    exceptional_ptr make_exceptional(exception_ptr ex);  // EXTENSION
    template <typename E>
-      exceptional_ptr make_exceptional_future(E ex);  // EXTENSION
-    exceptional_ptr make_exceptional_future();  // EXTENSION
+      exceptional_ptr make_exceptional(E ex);  // EXTENSION
+    exceptional_ptr make_exceptional();  // EXTENSION

    
    template <typename T>
@@ -167,27 +165,14 @@

    enum class launch
    {
-      none = unspecified,
      async = unspecified,
      deferred = unspecified,
      executor = unspecified,
-      inherit = unspecified,
      any = async | deferred
    };

 The enum type launch is a bitmask type with launch::async and launch::deferred denoting individual bits. 

-A future created with `promise<>` or with a `packaged_task<>` or with `make_ready_future`/`make_exceptional_future` (has no associated launch policy), has an implicit a launch policy of `launch::none`.
-
-A future created by `async(launch::async, ...)` or `::then(launch::async, ...)` has associated a launch policy `launch::async`.
-A future created by `async(launch::deferred, ...)` or `::then(launch::deferred, ...)` has associated a launch policy `launch::deferred`.
-A future created by `async(Executor, ...)`  or `::then(Executor, ...)` or `::then(launch::executor, ...)` has associated a launch policy `launch::executor`.
-A future created by `async(...)`  or `::then(...)` has associated a launch policy `launch::none`.
-
-A future created by `::then(launch::inherit, ...)` has associated a launch policy parent future.
-
-The `executor` and the `inherit` launch policies have a sense only can be user only on `then()`.
-
 [endsect]
 [///////////////////////////////////////////////////////////////////////////]
 [section:is_error_code_enum Specialization `is_error_code_enum<future_errc>`]
@@ -349,7 +334,7 @@ The object's `name` virtual function returns a pointer to the string "future".]]

      // move support
      __unique_future__(__unique_future__ && other) noexcept;
-      explicit __unique_future__(__unique_future__<__unique_future__<R>>&& rhs);  // EXTENSION
+      __unique_future__(__unique_future__<__unique_future__<R>>&& rhs);  // EXTENSION
      __unique_future__& operator=(__unique_future__ && other) noexcept;
      
      // factories
@@ -358,7 +343,7 @@ The object's `name` virtual function returns a pointer to the string "future".]]
      template<typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(F&& func); // EXTENSION
-      template<typename Ex, typename F>
+      template<typename S, typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(Ex& executor, F&& func); // EXTENSION
      template<typename F>
@@ -453,7 +438,7 @@ associated with `*this`. `other` is not associated with any shared state.]]
 [///////////////////////////////////////////////////////////////////]
 [section:unwrap_move_constructor Unwrap Move Constructor - EXTENSION]

-      explicit __unique_future__(__unique_future__<__unique_future__<R>>&& other);  // EXTENSION
+      __unique_future__(__unique_future__<__unique_future__<R>>&& other);  // EXTENSION

 [warning This constructor is 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 :(] 
@@ -848,7 +833,7 @@ stored exception, `false` otherwise.]]
 [[Effects:] [If `*this` is associated with a shared state, waits until the result is ready. If the result is not ready on
 entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]

-[[Returns:] [an exception_ptr, storing or not an exception.]]
+[[Returns:] [a exception_ptr, storring or not an exception.]]

 [[Remarks:] [The result of this function is not stable and the future could lost its exception even if the function returned a valid `exception_ptr` or vice-versa.]]

@@ -898,7 +883,7 @@ associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
      template<typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(F&& func); // EXTENSION
-      template<typename Ex, typename F>
+      template<typename S, typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(Ex& executor, F&& func); // EXTENSION
      template<typename F>
@@ -913,41 +898,29 @@ There are not too much tests yet, so it is possible that you can find out some t
 [variablelist

 [[Notes:] [The three functions differ only by input parameters. The first only takes a callable object which accepts a 
-future object as a parameter. The second function takes an executor as the first parameter and a callable object as 
+future object as a parameter. The second function takes a executor as the first parameter and a callable object as 
 the second parameter. The third function takes a launch policy as the first parameter and a callable object as the 
 second parameter.]]

-[[Requires:] [`INVOKE(DECAY_COPY (std::forward<F>(func)), std::move(*this))` shall be a valid expression.]]
-
 [[Effects:] [

-All the functions create a shared state that is associated with the returned future object. Additionally,
+All the functions create a shared state that is associated with the returned future object. The further behavior of the functions is as follows. 

- When the object's shared state is ready, the continuation
-`INVOKE(DECAY_COPY(std::forward<F>(func)), std::move(*this))` is called depending on the overload (see below) with the call to DECAY_COPY() being evaluated in the thread that called then.
+- The continuation is called when the object's shared state is ready (has a value or exception stored).

- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. 
-Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
+- The continuation launches according to the specified policy or executor.

+- When the executor or launch policy is not provided the continuation inherits the
+parent's launch policy or executor.

-The continuation launches according to the specified policy or executor or noting.
+- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 

- When the launch policy is `launch::none` the continuation is called on an unspecified thread of execution.
+- If the parent was created with `promise<>` or with a `packaged_task<>` (has no associated launch policy), the 
+continuation behaves the same as the third overload with a policy argument of `launch::async | launch::deferred` and 
+the same argument for `func`.

- When the launch policy is `launch::async` the continuation is called on a new thread of execution.
-
- When the launch policy is `launch::deferred` the continuation is called on demand.
-
- When the launch policy is `launch::executor` the continuation is called on one of the thread of execution of the executor.
-
- When the launch policy is `launch::inherit` the continuation inherits the parent's launch policy or executor.
-
- When the executor or launch policy is not provided (first overload) is if as if launch::none was specified.
-
- When the executor is provided (second overload) the continuation is called on one of the thread of execution of the executor.
-
- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy
-executor, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
+- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy or 
+scheduler, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
 `launch::deferred`.

 ]]
@@ -1357,7 +1330,7 @@ stored exception, `false` otherwise.]]
 [[Effects:] [If `*this` is associated with a shared state, waits until the result is ready. If the result is not ready on
 entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]

-[[Returns:] [an exception_ptr, storing or not an exception.]]
+[[Returns:] [a exception_ptr, storring or not an exception.]]

 [[Throws:] [Whatever `mutex::lock()/mutex::unlock()` can throw.]]

@@ -1387,7 +1360,7 @@ associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
      template<typename F>
      __unique_future__<typename boost::result_of<F(shared_future)>::type> 
      then(F&& func) const; // EXTENSION
-      template<typename Ex, typename F>
+      template<typename S, typename F>
      __unique_future__<typename boost::result_of<F(shared_future)>::type> 
      then(Ex& executor, F&& func) const; // EXTENSION
      template<typename F>
@@ -1407,38 +1380,22 @@ shared_future object as a parameter. The second function takes an executor as th
 the second parameter. The third function takes a launch policy as the first parameter and a callable object as the 
 second parameter.]]

-[[Requires:] [`INVOKE(DECAY_COPY (std::forward<F>(func)), *this)` shall be a valid expression.]]
-
 [[Effects:] [

-All the functions create a shared state that is associated with the returned future object. Additionally,
+- The continuation is called when the object's shared state is ready (has a value or exception stored).

- When the object's shared state is ready, the continuation
-`INVOKE(DECAY_COPY(std::forward<F>(func)), *this)` is called depending on the overload (see below) with the call to DECAY_COPY() being evaluated in the thread that called then.
+- The continuation launches according to the specified policy or executor.

- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. 
-Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
+- When the executor or launch policy is not provided the continuation inherits the
+parent's launch policy or executor.

+- If the parent was created with `promise` or with a `packaged_task` (has no associated launch policy), the 
+continuation behaves the same as the third overload with a policy argument of `launch::async | launch::deferred` and 
+the same argument for func.

-The continuation launches according to the specified policy or executor or noting.
-
- When the launch policy is `launch::none` the continuation is called on an unspecified thread of execution.
-
- When the launch policy is `launch::async` the continuation is called on a new thread of execution.
-
- When the launch policy is `launch::deferred` the continuation is called on demand.
-
- When the launch policy is `launch::executor` the continuation is called on one of the thread of execution of the executor.
-
- When the launch policy is `launch::inherit` the continuation inherits the parent's launch policy or executor.
-
- When the executor or launch policy is not provided (first overload) is if as if launch::none was specified.
-
- When the executor is provided (second overload) the continuation is called on one of the thread of execution of the executor.
-
- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy
+- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy or 
 executor, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
-`launch::deferred`.
+`launch::deferred`

 ]]

@@ -2451,12 +2408,12 @@ Otherwise the value is copied to the shared state of the returned future.
    
 [endsect]
 [/////////////////////////////////////////////////////////////////////////////]
-[section:make_exceptional_future Non-member function `make_exceptional_future()` EXTENSION]
+[section:make_exceptional Non-member function `make_exceptional()` EXTENSION]

-    exceptional_ptr make_exceptional_future(exception_ptr ex);  // EXTENSION
+    exceptional_ptr make_exceptional(exception_ptr ex);  // EXTENSION
    template <typename E>
-      exceptional_ptr make_exceptional_future(E ex);  // EXTENSION
-    exceptional_ptr make_exceptional_future();  // EXTENSION
+      exceptional_ptr make_exceptional(E ex);  // EXTENSION
+    exceptional_ptr make_exceptional();  // EXTENSION

 [variablelist

@@ -326,7 +326,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 ) {
@@ -344,7 +344,7 @@ Here `share()` could be used to simplify the code
 
 [heading Writing 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,7 +365,7 @@ 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]
@@ -444,7 +444,7 @@ Input Parameters:
 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 
 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 
+* Executor: Providing an overload to `.then`, to take a executor 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.
@@ -240,9 +240,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]
@@ -869,7 +869,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 +893,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 +919,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()`). 
@@ -2150,7 +2150,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.
 

@@ -3034,8 +3034,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 +3062,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.]]
@@ -15,12 +15,11 @@
  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]
 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.
@@ -55,8 +54,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 +64,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 +79,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 +96,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,7 +105,7 @@ 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;
+    explicit strict_scoped_thread(thread&& t) noexcept;
    template <typename F&&, typename ...Args>
    explicit strict_scoped_thread(F&&, Args&&...);

@@ -134,7 +130,7 @@ This wrapper can be used to join the thread before destroying it.

 [section:default_constructor Constructor from a __thread]

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

 [variablelist

@@ -154,7 +150,7 @@ This wrapper can be used to join the thread before destroying it.

 [variablelist

-[[Effects:] [Construct an internal thread in place.]]
+[[Effects:] [Construct a internal thread in place.]]

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

@@ -184,7 +180,7 @@ This wrapper can be used to join the thread before destroying it.

    #include <boost/thread/scoped_thread.hpp>

-    template <class CallableThread, class Thread = thread>
+    template <class CallableThread>
    class scoped_thread
    {
      thread t_; // for exposition purposes only
@@ -234,8 +230,7 @@ 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.
@@ -296,14 +291,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]]

 ]

@@ -509,8 +506,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

@@ -110,10 +110,10 @@ where
 * `q` denotes a value of type `Q`, 
 * `e` denotes a value of type Q::value_type, 
 * `u` denotes a value of type Q::size_type, 
-* `lve` denotes an lvalue reference of type Q::value_type, 
-* `rve` denotes an rvalue reference of type Q::value_type:
+* `lve` denotes a lvalue referece of type Q::value_type, 
+* `rve` denotes a rvalue referece of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]
-* `qs` denotes a variable of of type `queue_op_status`, 
+* `qs` denotes a variable of of type `queus_op_status`, 


 [/////////////////////////////////////]
@@ -246,8 +246,8 @@ where
 * `e` denotes a value of type `Q::value_type`, 
 * `s` denotes a value of type `queue_status`, 
 * `u` denotes a value of type `Q::size_type`, 
-* `lve` denotes an lvalue reference of type Q::value_type, 
-* `rve` denotes an rvalue reference of type Q::value_type:
+* `lve` denotes a lvalue referece of type Q::value_type, 
+* `rve` denotes a rvalue referece of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]


@@ -357,8 +357,8 @@ where
 * `q` denotes a value of type `Q`, 
 * `e` denotes a value of type Q::value_type, 
 * `s` denotes a value of type `queue_status`, 
-* `lve` denotes an lvalue reference of type Q::value_type, 
-* `rve` denotes an rvalue reference of type Q::value_type:
+* `lve` denotes a lvalue referece of type Q::value_type, 
+* `rve` denotes a rvalue referece of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]


@@ -545,7 +545,7 @@ Closed queues add the following valid expressions

 [[Return:] [

- If the queue is closed return `queue_op_status::closed`,
+- If the queue is closed retun `queue_op_status::closed`,

 - otherwise, return `queue_op_status::success` if no exception is thrown.

@@ -769,14 +769,22 @@ Closed queues add the following valid expressions
      void push(const value_type& x);
      void push(BOOST_THREAD_RV_REF(value_type) x);
  
+      void pull(value_type& x);
+      value_type pull();
+  
      queue_op_status try_push(const value_type& x);
      queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x);
- 
+  
+      queue_op_status try_pull(value_type& x);
+  
      queue_op_status nonblocking_push(const value_type& x);
      queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x);
  
+      queue_op_status nonblocking_pull(value_type& x);
+  
      queue_op_status wait_push(const value_type& x);
      queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x);
+      queue_op_status wait_pull_front(value_type& x);
  
    };

@@ -804,13 +812,24 @@ Closed queues add the following valid expressions
      // Modifiers
      void close();
  
+      void push(const value_type& x);
+      void push(BOOST_THREAD_RV_REF(value_type) x);
+  
      void pull(value_type& x);
      value_type pull();
  
+      queue_op_status try_push(const value_type& x);
+      queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x);
+  
      queue_op_status try_pull(value_type& x);
  
+      queue_op_status nonblocking_push(const value_type& x);
+      queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x);
+  
      queue_op_status nonblocking_pull(value_type& x);
  
+      queue_op_status wait_push(const value_type& x);
+      queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x);
      queue_op_status wait_pull(value_type& x);
  
    };
@@ -156,7 +156,7 @@ object passed to the constructor.]]
    };
  }

-`externally_locked_stream` cloaks a reference to a stream of type `Stream`, and actually
+`externally_locked_stream` cloaks a reference to an 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.

@@ -63,7 +63,7 @@ Both forms of pointer dereference return a proxy object rather than a real refer

 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.
+By calling synchronize() you obtain an 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)
  {
@@ -8,10 +8,10 @@

 [library Thread
    [quickbook 1.5]
-    [version 4.8.0]
+    [version 4.5.0]
    [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
    [copyright 2007-11 Anthony Williams]
-    [copyright 2011-17 Vicente J. Botet Escriba]
+    [copyright 2011-15 Vicente J. Botet Escriba]
    [purpose C++ Library for launching threads and synchronizing data between them]
    [category text]
    [license
@@ -21,7 +21,7 @@
    {
      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>
@@ -255,7 +255,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 +264,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 +280,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 +289,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 +410,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]

@@ -713,7 +711,7 @@ are copied into internal storage for access by the new thread.]]]

 [[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:] [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 an scoped thread.]]

 ]

@@ -955,7 +953,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 +964,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

@@ -981,7 +979,7 @@ or 0 if this information is not available.]]

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

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

 [variablelist

@@ -1292,7 +1290,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 +1304,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.]]

@@ -1534,7 +1532,7 @@ do not throw exceptions. __thread_interrupted__ if the current thread of executi

 [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.]]
@@ -18,7 +18,7 @@
 #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/generic_serial_executor.hpp>
 #include <boost/thread/executors/inline_executor.hpp>
 #include <boost/thread/executors/thread_executor.hpp>
 #include <boost/thread/executors/executor.hpp>
@@ -73,7 +73,7 @@ void submit_some(boost::executor& tp)
 }


-void at_th_entry(boost::basic_thread_pool& )
+void at_th_entry(boost::basic_thread_pool )
 {

 }
@@ -84,66 +84,118 @@ int test_executor_adaptor()
  {
    try
    {
+//      {
+//        std::cout << BOOST_CONTEXTOF << std::endl;
+//        boost::basic_thread_pool e1;
+//        std::cout << BOOST_CONTEXTOF << std::endl;
+//        boost::basic_thread_pool e2 = e1;
+//        std::cout << BOOST_CONTEXTOF << std::endl;
+//      }
      {
+        std::cout << BOOST_CONTEXTOF << std::endl;
        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
+      {
+        std::cout << BOOST_CONTEXTOF << std::endl;
+        boost::executor_adaptor < boost::basic_thread_pool > ea(4);
      // 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;
-        }
+//        {
+//          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;
+//        {
+//          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;
+//        }
        std::cout << BOOST_CONTEXTOF << std::endl;
        submit_some(ea);
        std::cout << BOOST_CONTEXTOF << std::endl;
      }
+#endif
      std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::loop_executor e1;
+        boost::loop_executor e2 = e1;
+        boost::executor_adaptor < boost::loop_executor > ea2(e2);
+        submit_some( ea2);
+        ea2.underlying_executor().run_queued_closures();
+      }
      {
        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;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
      {
-        boost::executor_adaptor < boost::basic_thread_pool > ea1(4);
-        boost::executor_adaptor < boost::serial_executor > ea2(ea1);
+        boost::basic_thread_pool tp;
+        boost::generic_serial_executor e1(tp);
+        boost::generic_serial_executor e2 = e1;
+      }
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::generic_serial_executor ea2(ea1);
+        boost::executor_adaptor < boost::generic_serial_executor > ea3(ea2);
+        submit_some(ea3);
+      }
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::generic_serial_executor ea2(ea1);
+        boost::executor_adaptor < boost::generic_serial_executor > ea3(ea2);
+        submit_some(ea3);
+      }
+//#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::executor_adaptor < boost::generic_serial_executor > ea2(ea1);
+        submit_some(ea2);
+      }
+//#endif
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::inline_executor e1;
+        boost::inline_executor e2 = e1;
+        boost::executor_adaptor < boost::inline_executor > ea2(e2);
        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::thread_executor e1;
+        boost::thread_executor e2 = e1;
+      }
+      {
+        boost::thread_executor e1;
+        boost::executor_adaptor < boost::generic_executor > ea2(e1);
+        submit_some(ea2);
+      }
+
      {
        boost::executor_adaptor < boost::thread_executor > ea1;
        submit_some(ea1);
      }
      std::cout << BOOST_CONTEXTOF << std::endl;
-#if 1
+#if 0
      // fixme
      // ERROR= tr1::bad_weak_ptr
      {
@@ -156,7 +208,7 @@ int test_executor_adaptor()
      {
        boost::async(&f1);
      }
-#if 1
+#if 0
      // fixme
      // ERROR= tr1::bad_weak_ptr

@@ -17,7 +17,6 @@
 #include <boost/thread/future.hpp>
 #include <boost/assert.hpp>
 #include <string>
-#include <iostream>
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION

 int p1()
@@ -41,28 +41,10 @@ int main()
  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;
-    }
+    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)
  {
@@ -0,0 +1,184 @@
+// 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/generic_serial_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/executors/generic_executor.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 tp)
+{
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p2);
+  }
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p1);
+  }
+
+}
+
+template < class Executor>
+void submit_some2(Executor& tp)
+{
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p2);
+  }
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p1);
+  }
+
+}
+
+template <class Executor>
+void submit_some3(boost::serial_executor<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_generic_executor()
+{
+  // 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::generic_serial_executor ea2(ea1);
+//        submit_some(ea2);
+//      }
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::serial_executor<boost::basic_thread_pool> ea2(ea1);
+        submit_some3(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;
+//      }
+    }
+    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();
+
+
+}
@@ -17,11 +17,12 @@
 #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/generic_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/executors/generic_executor_ref.hpp>
 #include <boost/thread/executor.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/assert.hpp>
@@ -64,7 +65,7 @@ void submit_some(boost::generic_executor_ref tp)

 }

-void at_th_entry(boost::basic_thread_pool& )
+void at_th_entry(boost::basic_thread_pool)
 {

 }
@@ -80,22 +81,22 @@ int test_generic_executor_ref()
      {
        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;
-        }
+//        {
+//          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;
@@ -108,7 +109,7 @@ int test_generic_executor_ref()
      std::cout << BOOST_CONTEXTOF << std::endl;
      {
        boost::basic_thread_pool ea1(4);
-        boost::serial_executor ea2(ea1);
+        boost::generic_serial_executor ea2(ea1);
        submit_some(ea2);
      }
 #endif
@@ -122,18 +123,18 @@ int test_generic_executor_ref()
        //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::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;
@@ -0,0 +1,117 @@
+// 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/generic_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::generic_serial_executor& 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;
+  {
+     boost::basic_thread_pool tp;
+     boost::generic_serial_executor e1(tp);
+     boost::generic_serial_executor e2 = e1;
+  }
+  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::generic_serial_executor ea2(ea1);
+        submit_some(ea2);
+      }
+#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();
+}
@@ -0,0 +1,124 @@
+// 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/generic_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::generic_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;
+  {
+     boost::basic_thread_pool tp;
+     std::cout << BOOST_CONTEXTOF << std::endl;
+     boost::generic_serial_executor_cont e1(tp);
+     std::cout << BOOST_CONTEXTOF << std::endl;
+     boost::generic_serial_executor_cont e2 = e1;
+     std::cout << BOOST_CONTEXTOF << std::endl;
+  }
+   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);
+        std::cout << BOOST_CONTEXTOF << std::endl;
+        boost::generic_serial_executor_cont ea2(ea1);
+        std::cout << BOOST_CONTEXTOF << std::endl;
+        submit_some(ea2);
+        std::cout << BOOST_CONTEXTOF << std::endl;
+      }
+#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();
+}
@@ -39,23 +39,36 @@ 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;
+//    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));
+//  }
  {
-    int some_local_state=0;
+    int some_local_state;
    boost::scoped_thread<> t( (boost::thread(func(some_local_state))));

    if (t.joinable())
@@ -63,17 +76,14 @@ int main()
    else
      do_something_in_current_thread();
  }
-#if 0
  {
-    int some_local_state=0;
+    int some_local_state;
    boost::thread t(( func(some_local_state) ));
    boost::scoped_thread<> g( (boost::move(t)) );
-    if (g.joinable())
-      g.detach();
+    t.detach();

    do_something_in_current_thread();
  }
-#endif
  {
    boost::scoped_thread<> g( &f, 1, 2 );
    do_something_in_current_thread();
@@ -51,8 +51,8 @@ int f2(int i)
  boost::this_thread::sleep_for(boost::chrono::seconds(2));
  return i + 1;
 }
-
-void submit_some(boost::serial_executor& tp)
+template <class Executor>
+void submit_some(boost::serial_executor<Executor>& tp)
 {
  for (int i = 0; i < 3; ++i) {
    std::cout << BOOST_CONTEXTOF << std::endl;
@@ -80,9 +80,8 @@ int test_executor_adaptor()
 #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
      {
        boost::basic_thread_pool ea1(4);
-        boost::serial_executor ea2(ea1);
+        boost::serial_executor<boost::basic_thread_pool> ea2(ea1);
        submit_some(ea2);
-        boost::this_thread::sleep_for(boost::chrono::seconds(10));
      }
 #endif
    }
@@ -52,18 +52,19 @@ int f2(int i)
  return i + 1;
 }

-void submit_some(boost::serial_executor_cont& tp)
+template < class Executor>
+void submit_some(boost::serial_executor_cont<Executor>& tp)
 {
-  std::cout << BOOST_CONTEXTOF << std::endl;
+  //std::cout << BOOST_CONTEXTOF << std::endl;
  for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
+    //std::cout << BOOST_CONTEXTOF << std::endl;
    tp.submit(&p2);
  }
  for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
+    //std::cout << BOOST_CONTEXTOF << std::endl;
    tp.submit(&p1);
  }
-  std::cout << BOOST_CONTEXTOF << std::endl;
+  //std::cout << BOOST_CONTEXTOF << std::endl;

 }

@@ -84,9 +85,8 @@ int test_executor_adaptor()
      // std::cout << BOOST_CONTEXTOF << std::endl;
      {
        boost::basic_thread_pool ea1(4);
-        boost::serial_executor_cont ea2(ea1);
+        boost::serial_executor_cont<boost::basic_thread_pool> ea2(ea1);
        submit_some(ea2);
-        boost::this_thread::sleep_for(boost::chrono::seconds(10));
      }
 #endif
      // std::cout << BOOST_CONTEXTOF << std::endl;
@@ -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
@@ -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
@@ -145,7 +145,7 @@ namespace boost
        unsigned int count,
        BOOST_THREAD_RV_REF(F) funct,
        typename enable_if<
-        typename is_void<typename result_of<F()>::type>::type, dummy*
+        typename is_void<typename result_of<F>::type>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
@@ -160,7 +160,7 @@ namespace boost
        unsigned int count,
        F &funct,
        typename enable_if<
-        typename is_void<typename result_of<F()>::type>::type, dummy*
+        typename is_void<typename result_of<F>::type>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
@@ -176,7 +176,7 @@ namespace boost
        unsigned int count,
        BOOST_THREAD_RV_REF(F) funct,
        typename enable_if<
-        typename is_same<typename result_of<F()>::type, unsigned int>::type, dummy*
+        typename is_same<typename result_of<F>::type, unsigned int>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
@@ -189,7 +189,7 @@ namespace boost
        unsigned int count,
        F& funct,
        typename enable_if<
-        typename is_same<typename result_of<F()>::type, unsigned int>::type, dummy*
+        typename is_same<typename result_of<F>::type, unsigned int>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
@@ -225,7 +225,6 @@ namespace boost
        m_generation++;
        m_count = static_cast<unsigned int>(fct_());
        BOOST_ASSERT(m_count != 0);
-        lock.unlock();
        m_cond.notify_all();
        return true;
      }
@@ -96,6 +96,7 @@ namespace boost
    leavers_(0)
    {
    }
+    template <typename F>
    completion_latch(std::size_t count, void(*funct)()) :
      count_(count), funct_(funct), waiters_(0), leavers_(0)
    {
@@ -76,15 +76,26 @@ namespace concurrent
    // Modifiers
    void close() { queue->close(); }

+    void push(const value_type& x) { queue->push_front(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_front(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_front(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_front(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_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)); }

  };

@@ -127,7 +127,7 @@ namespace concurrent
    inline size_type size(lock_guard<mutex>& lk) const BOOST_NOEXCEPT
    {
      if (full(lk)) return capacity(lk);
-      return ((in_+capacity(lk)-out_) % capacity(lk));
+      return ((out_+capacity(lk)-in_) % capacity(lk));
    }

    inline void throw_if_closed(unique_lock<mutex>&);
@@ -484,9 +484,7 @@ namespace concurrent
  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;}
+      wait_until_not_empty(lk);
      pull_front(elem, lk);
      return queue_op_status::success;
  }
@@ -69,7 +69,7 @@ namespace detail
  class sync_timed_queue
    : private sync_priority_queue<detail::scheduled_type<T, Clock> >
  {
-    typedef detail::scheduled_type<T, Clock> stype;
+    typedef detail::scheduled_type<T> stype;
    typedef sync_priority_queue<stype> super;
  public:
    typedef T value_type;
@@ -229,8 +229,7 @@ namespace detail
      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);
+        super::not_empty_.wait_until(lk, super::data_.top().time);
        if (super::closed(lk)) return true;
      }
      if (super::closed(lk)) return true;
@@ -246,8 +245,7 @@ namespace detail
    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::not_empty_.wait_until(lk,super::data_.top().time);
      super::wait_until_not_empty(lk);
    }
    return pull(lk);
@@ -262,7 +260,7 @@ namespace detail
    while (time_not_reached(lk))
    {
      super::throw_if_closed(lk);
-      if (cv_status::timeout == super::not_empty_.wait_until(lk, tpmin)) {
+      if (queue_op_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;
      }
@@ -57,5 +57,6 @@ namespace boost
 // 20.8.2.4, class template enable_shared_from_this:
 // 20.8.2.5, shared_ptr atomic access:
 // 20.8.2.6 hash support
+#include <boost/thread/csbl/memory/shared_ptr.hpp>

 #endif // header
@@ -11,17 +11,30 @@

 #include <boost/thread/csbl/memory/config.hpp>

-#if defined BOOST_NO_CXX11_SMART_PTR
+//#if defined BOOST_NO_CXX11_SMART_PTR
+#if 1

 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
+#include <boost/enable_shared_from_this.hpp>

 namespace boost
 {
+  template<class T> bool atomic_compare_exchange_strong( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
+  {
+    return atomic_compare_exchange(p,v,w);
+  }
+
  namespace csbl
  {
    using ::boost::shared_ptr;
    using ::boost::make_shared;
+    using ::boost::static_pointer_cast;
+    using ::boost::dynamic_pointer_cast;
+    using ::boost::const_pointer_cast;
+    using ::boost::enable_shared_from_this;
+    using ::boost::atomic_load;
+    using ::boost::atomic_compare_exchange_strong;
  }
 }

@@ -35,6 +48,12 @@ namespace boost
  {
    using std::shared_ptr;
    using std::make_shared;
+    using std::dynamic_pointer_cast;
+    using std::static_pointer_cast;
+    using std::const_pointer_cast;
+    using std::enable_shared_from_this;
+    using std::atomic_load;
+    using std::atomic_compare_exchange_strong;
  }
 }

@@ -12,19 +12,19 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/thread/detail/platform.hpp>

-//#define BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
 //#define BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
 // ATTRIBUTE_MAY_ALIAS

-//#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#if !defined(BOOST_NO_MAY_ALIAS)
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)

-  // GCC since 3.3 and some other compilers have may_alias attribute that helps
-  // to alleviate optimizer issues with regard to violation of the strict aliasing rules.
+  // GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
+  // regard to violation of the strict aliasing rules.

  #define BOOST_THREAD_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
+#else
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS
 #endif
-#define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS BOOST_MAY_ALIAS


 #if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
@@ -100,8 +100,8 @@
 #if !defined BOOST_THREAD_VERSION
 #define BOOST_THREAD_VERSION 2
 #else
-#if BOOST_THREAD_VERSION!=2  && BOOST_THREAD_VERSION!=3 && BOOST_THREAD_VERSION!=4 && BOOST_THREAD_VERSION!=5
-#error "BOOST_THREAD_VERSION must be 2, 3, 4 or 5"
+#if BOOST_THREAD_VERSION!=2  && BOOST_THREAD_VERSION!=3 && BOOST_THREAD_VERSION!=4
+#error "BOOST_THREAD_VERSION must be 2, 3 or 4"
 #endif
 #endif

@@ -304,13 +304,6 @@

 #endif // BOOST_THREAD_VERSION>=4

-
-#if BOOST_THREAD_VERSION>=5
-//#define BOOST_THREAD_FUTURE_BLOCKING
-#else
-//#define BOOST_THREAD_FUTURE_BLOCKING
-#define BOOST_THREAD_ASYNC_FUTURE_WAITS
-#endif
 // INTERRUPTIONS
 #if ! defined BOOST_THREAD_PROVIDES_INTERRUPTIONS \
 && ! defined BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
@@ -72,21 +72,13 @@ namespace boost
      BOOST_SYMBOL_VISIBLE
      invoker& operator=(BOOST_THREAD_RV_REF(invoker) f)
      {
-        if (this != &f)
-        {
-          f_ = boost::move(BOOST_THREAD_RV(f).f_);
-        }
-        return *this;
+        f_ = boost::move(BOOST_THREAD_RV(f).f_);
      }

      BOOST_SYMBOL_VISIBLE
      invoker& operator=( BOOST_THREAD_COPY_ASSIGN_REF(invoker) f)
      {
-        if (this != &f)
-        {
-          f_ = f.f_;
-        }
-        return *this;
+        f_ = f.f_;
      }

      result_type operator()()
@@ -99,7 +91,7 @@ namespace boost
      result_type
      execute(tuple_indices<Indices...>)
      {
-        return detail::invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
+        return invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
      }
    };

@@ -136,7 +128,7 @@ namespace boost
      result_type
      execute(tuple_indices<Indices...>)
      {
-        return detail::invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
+        return invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
      }
    };
  //BOOST_THREAD_DCL_MOVABLE_BEG(X) invoker<Fp> BOOST_THREAD_DCL_MOVABLE_END
@@ -190,7 +182,7 @@ namespace boost
      {} \
      \
      result_type operator()() { \
-        return detail::invoke(boost::move(fp_) \
+        return invoke(boost::move(fp_) \
            BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL, ~) \
        ); \
      } \
@@ -315,7 +307,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
            , boost::move(v2_)
@@ -381,7 +373,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
            , boost::move(v2_)
@@ -442,7 +434,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
            , boost::move(v2_)
@@ -498,7 +490,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
            , boost::move(v2_)
@@ -549,7 +541,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
            , boost::move(v2_)
@@ -595,7 +587,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
            , boost::move(v2_)
@@ -636,7 +628,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
            , boost::move(v2_)
@@ -672,7 +664,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
            , boost::move(v1_)
        );
@@ -703,7 +695,7 @@ namespace boost

      result_type operator()()
      {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
            , boost::move(v0_)
        );
      }
@@ -72,7 +72,7 @@ namespace boost
          void run2(tuple_indices<Indices...>)
          {

-              detail::invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...);
+              invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...);
          }
          void run()
          {
@@ -155,15 +155,7 @@ namespace boost
        };
 #endif
    }
-namespace thread_detail {
-#ifdef BOOST_THREAD_USES_CHRONO
-#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC)
-        typedef chrono::steady_clock internal_clock_t;
-#else
-        typedef chrono::system_clock internal_clock_t;
-#endif
-#endif
-}
+
    class BOOST_THREAD_DECL thread
    {
    public:
@@ -299,7 +291,7 @@ namespace thread_detail {
        template <class F>
        explicit thread(F f
        , typename disable_if_c<
-        boost::thread_detail::is_rv<F>::value // todo as a thread_detail::is_rv
+        boost::thread_detail::is_rv<F>::value // todo ass a thread_detail::is_rv
        //boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value
            //|| is_same<typename decay<F>::type, thread>::value
           , dummy* >::type=0
@@ -362,8 +354,6 @@ namespace thread_detail {

 #if defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
            if (joinable()) std::terminate();
-#else
-            detach();
 #endif
            thread_info=BOOST_THREAD_RV(other).thread_info;
            BOOST_THREAD_RV(other).thread_info.reset();
@@ -490,14 +480,13 @@ namespace thread_detail {
          return try_join_until(chrono::steady_clock::now() + rel_time);
        }
 #endif
-
        template <class Clock, class Duration>
        bool try_join_until(const chrono::time_point<Clock, Duration>& t)
        {
          using namespace chrono;
          bool joined= false;
          do {
-            thread_detail::internal_clock_t::time_point     s_now = thread_detail::internal_clock_t::now();
+            system_clock::time_point     s_now = system_clock::now();
            typename Clock::duration   d = ceil<nanoseconds>(t-Clock::now());
            if (d <= Clock::duration::zero()) return false; // in case the Clock::time_point t is already reached
            joined = try_join_until(s_now + d);
@@ -505,10 +494,10 @@ namespace thread_detail {
          return true;
        }
        template <class Duration>
-        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, Duration>& t)
+        bool try_join_until(const chrono::time_point<chrono::system_clock, Duration>& t)
        {
          using namespace chrono;
-          typedef time_point<thread_detail::internal_clock_t, nanoseconds> nano_sys_tmpt;
+          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
          return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
        }
 #endif
@@ -523,7 +512,7 @@ namespace thread_detail {
        //}

 #ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, chrono::nanoseconds>& tp)
+        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
        {
          chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
          return do_try_join_until(rel_time.count());
@@ -544,7 +533,7 @@ namespace thread_detail {
        }
 #endif
 #ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, chrono::nanoseconds>& tp)
+        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
        {
          using namespace chrono;
          nanoseconds d = tp.time_since_epoch();
@@ -849,7 +838,7 @@ namespace thread_detail {
        void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
        struct shared_state_base;
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
-        inline void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
+        inline void make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as)
        {
          detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
          if(current_thread_data)
@@ -858,7 +847,7 @@ namespace thread_detail {
          }
        }
 #else
-        void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as);
+        void BOOST_THREAD_DECL make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as);
 #endif
    }

@@ -40,19 +40,19 @@ namespace boost
          typedef system::system_error base_type;
    public:
        thread_exception()
-          : base_type(0,system::generic_category())
+          : base_type(0,system::system_category())
        {}

        thread_exception(int sys_error_code)
-          : base_type(sys_error_code, system::generic_category())
+          : base_type(sys_error_code, system::system_category())
        {}

        thread_exception( int ev, const char * what_arg )
-        : base_type(system::error_code(ev, system::generic_category()), what_arg)
+        : base_type(system::error_code(ev, system::system_category()), what_arg)
        {
        }
        thread_exception( int ev, const std::string & what_arg )
-        : base_type(system::error_code(ev, system::generic_category()), what_arg)
+        : base_type(system::error_code(ev, system::system_category()), what_arg)
        {
        }

@@ -74,18 +74,18 @@ namespace boost
          typedef system::system_error base_type;
    public:
          condition_error()
-          : base_type(system::error_code(0, system::generic_category()), "Condition error")
+          : base_type(system::error_code(0, system::system_category()), "Condition error")
          {}
          condition_error( int ev )
-          : base_type(system::error_code(ev, system::generic_category()), "Condition error")
+          : base_type(system::error_code(ev, system::system_category()), "Condition error")
          {
          }
          condition_error( int ev, const char * what_arg )
-          : base_type(system::error_code(ev, system::generic_category()), what_arg)
+          : base_type(system::error_code(ev, system::system_category()), what_arg)
          {
          }
          condition_error( int ev, const std::string & what_arg )
-          : base_type(system::error_code(ev, system::generic_category()), what_arg)
+          : base_type(system::error_code(ev, system::system_category()), what_arg)
          {
          }
    };
@@ -1,4 +1,4 @@
-// Copyright (C) 2013-2014 Vicente J. Botet Escriba
+// Copyright (C) 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)
@@ -18,6 +18,11 @@
 #include <boost/thread/executors/work.hpp>
 #include <boost/thread/csbl/vector.hpp>

+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/smart_ptr/enable_shared_from_this.hpp>
+#include <boost/function.hpp>
+
 #include <boost/config/abi_prefix.hpp>

 namespace boost
@@ -30,133 +35,267 @@ namespace executors
    /// type-erasure to store the works to do
    typedef  executors::work work;
  private:
-    typedef thread thread_t;
-    /// A move aware vector type
-    typedef csbl::vector<thread_t> thread_vector;

-    /// A move aware vector
-    thread_vector threads;
-    /// the thread safe work queue
-    concurrent::sync_queue<work > work_queue;
+    struct shared_state : enable_shared_from_this<shared_state> {
+      typedef  executors::work work;
+      /// the kind of stored threads are scoped threads to ensure that the threads are joined.
+      /// A move aware vector type
+      //typedef scoped_thread<> thread_t;
+      typedef thread thread_t;
+      typedef csbl::vector<thread_t> thread_vector;

-  public:
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      try
-      {
-        work task;
-        if (work_queue.try_pull(task) == queue_op_status::success)
-        {
-          task();
-          return true;
-        }
-        return false;
-      }
-      catch (...)
-      {
-        std::terminate();
-        //return false;
-      }
-    }
-    /**
-     * Effects: schedule one task or yields
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    void schedule_one_or_yield()
-    {
-        if ( ! try_executing_one())
-        {
-          this_thread::yield();
-        }
-    }
-  private:
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;
+      /// A move aware vector
+      thread_vector threads;
+      unsigned const thread_count;
+      boost::function<void(basic_thread_pool)> at_thread_entry;
+      friend class basic_thread_pool;

-    /**
-     * The main loop of the worker threads
-     */
-    void worker_thread()
-    {
-      try
+
+    public:
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
      {
-        for(;;)
+        try
        {
          work task;
-          try
+          if (work_queue.try_pull(task) == queue_op_status::success)
          {
-            queue_op_status st = work_queue.wait_pull(task);
-            if (st == queue_op_status::closed) {
-              return;
-            }
            task();
+            return true;
          }
-          catch (boost::thread_interrupted&)
-          {
-            return;
-          }
+          return false;
+        }
+        catch (...)
+        {
+          std::terminate();
+          return false;
        }
      }
-      catch (...)
+      /**
+       * Effects: schedule one task or yields
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      void schedule_one_or_yield()
      {
-        std::terminate();
-        return;
+          if ( ! try_executing_one())
+          {
+            this_thread::yield();
+          }
      }
-    }
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <class AtThreadEntry>
-    void worker_thread1(AtThreadEntry& at_thread_entry)
-    {
-      at_thread_entry(*this);
-      worker_thread();
-    }
-#endif
-    void worker_thread2(void(*at_thread_entry)(basic_thread_pool&))
-    {
-      at_thread_entry(*this);
-      worker_thread();
-    }
-    template <class AtThreadEntry>
-    void worker_thread3(BOOST_THREAD_FWD_REF(AtThreadEntry) at_thread_entry)
-    {
-      at_thread_entry(*this);
-      worker_thread();
-    }
-    static void do_nothing_at_thread_entry(basic_thread_pool&) {}
+    private:

+      /**
+       * The main loop of the worker threads
+       */
+      void worker_thread()
+      {
+        // fixme: this call results on segmentation fault
+        //at_thread_entry(basic_thread_pool(this->shared_from_this()));
+        try
+        {
+          for(;;)
+          {
+            work task;
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) break;
+            task();
+          }
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+      static void do_nothing_at_thread_entry(basic_thread_pool) {}
+
+      void init()
+      {
+        try
+        {
+          threads.reserve(thread_count);
+          for (unsigned i = 0; i < thread_count; ++i)
+          {
+            thread th (&shared_state::worker_thread, this);
+            threads.push_back(thread_t(boost::move(th)));
+          }
+        }
+        catch (...)
+        {
+          close();
+          throw;
+        }
+      }
+
+    public:
+      /// basic_thread_pool is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures on \c thread_count threads.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      shared_state(unsigned const thread_count = thread::hardware_concurrency()+1)
+      : thread_count(thread_count),
+        at_thread_entry(do_nothing_at_thread_entry)
+      {
+      }
+      /**
+       * \b Effects: creates a thread pool that runs closures on \c thread_count threads
+       * and executes the at_thread_entry function at the entry of each created thread. .
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <class AtThreadEntry>
+      shared_state( unsigned const thread_count, AtThreadEntry& at_thread_entry)
+      : thread_count(thread_count),
+        at_thread_entry(at_thread_entry)
+      {
+      }
+  #endif
+      shared_state( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool))
+      : thread_count(thread_count),
+        at_thread_entry(at_thread_entry)
+      {
+      }
+      template <class AtThreadEntry>
+      shared_state( unsigned const thread_count, BOOST_THREAD_FWD_REF(AtThreadEntry) at_thread_entry)
+      : thread_count(thread_count),
+        at_thread_entry(boost::move(at_thread_entry))
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c basic_thread_pool destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker threads that there will be no more submissions.
+        close();
+        join();
+        // joins all the threads as the threads were scoped_threads
+      }
+
+      /**
+       * \b Effects: join all the threads.
+       */
+      void join()
+      {
+        for (unsigned i = 0; i < threads.size(); ++i)
+        {
+          if (this_thread::get_id() == threads[i].get_id()) continue;
+          threads[i].join();
+        }
+      }
+
+      /**
+       * \b Effects: close the \c basic_thread_pool for submissions.
+       * The worker threads will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c basic_thread_pool will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+      void submit(BOOST_THREAD_RV_REF(work) closure)  {
+        work_queue.push(boost::move(closure));
+      }
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        //work_queue.push(work(closure));
+        submit(work(closure));
+
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        //work_queue.push(work(closure));
+        submit(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+      {
+        //work_queue.push(work(boost::forward<Closure>(closure)));
+        work w((boost::forward<Closure>(closure)));
+        submit(boost::move(w));
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred)
+      {
+        do {
+          if ( ! try_executing_one())
+          {
+            return false;
+          }
+        } while (! pred());
+        return true;
+      }
+    };
+
+    /**
+     * \b Effects: creates a thread pool with this shared state.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    friend struct shared_state;
+    basic_thread_pool(shared_ptr<shared_state> ptr)
+    : pimpl(ptr)
+    {
+    }
  public:
-    /// basic_thread_pool is not copyable.
-    BOOST_THREAD_NO_COPYABLE(basic_thread_pool)
-
+    //basic_thread_pool(basic_thread_pool const&)=default;
+    //basic_thread_pool(basic_thread_pool &&)=default;
    /**
     * \b Effects: creates a thread pool that runs closures on \c thread_count threads.
     *
     * \b Throws: Whatever exception is thrown while initializing the needed resources.
     */
    basic_thread_pool(unsigned const thread_count = thread::hardware_concurrency()+1)
+    : pimpl(make_shared<shared_state>(thread_count))
    {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-#if 1
-          thread th (&basic_thread_pool::worker_thread, this);
-          threads.push_back(thread_t(boost::move(th)));
-#else
-          threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-#endif
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
    }
+
    /**
     * \b Effects: creates a thread pool that runs closures on \c thread_count threads
     * and executes the at_thread_entry function at the entry of each created thread. .
@@ -166,61 +305,24 @@ namespace executors
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    template <class AtThreadEntry>
    basic_thread_pool( unsigned const thread_count, AtThreadEntry& at_thread_entry)
+    : pimpl(make_shared<shared_state>(thread_count, at_thread_entry))
    {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-          thread th (&basic_thread_pool::worker_thread1<AtThreadEntry>, this, at_thread_entry);
-          threads.push_back(thread_t(boost::move(th)));
-          //threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
    }
 #endif
-    basic_thread_pool( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool&))
+
+    basic_thread_pool( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool))
+    : pimpl(make_shared<shared_state>(thread_count, at_thread_entry))
    {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-          thread th (&basic_thread_pool::worker_thread2, this, at_thread_entry);
-          threads.push_back(thread_t(boost::move(th)));
-          //threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
    }
    template <class AtThreadEntry>
    basic_thread_pool( unsigned const thread_count, BOOST_THREAD_FWD_REF(AtThreadEntry) at_thread_entry)
+    : pimpl(make_shared<shared_state>(thread_count, boost::forward<AtThreadEntry>(at_thread_entry)))
    {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-          thread th (&basic_thread_pool::worker_thread3<AtThreadEntry>, this, boost::forward<AtThreadEntry>(at_thread_entry));
-          threads.push_back(thread_t(boost::move(th)));
-          //threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
    }
+
    /**
     * \b Effects: Destroys the thread pool.
     *
@@ -228,10 +330,16 @@ namespace executors
     */
    ~basic_thread_pool()
    {
-      // signal to all the worker threads that there will be no more submissions.
-      close();
-      // joins all the threads before destroying the thread pool resources (e.g. the queue).
-      join();
+    }
+
+    /**
+     * Effects: try to execute one task.
+     * Returns: whether a task has been executed.
+     * Throws: whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one()
+    {
+      return pimpl->try_executing_one();
    }

    /**
@@ -239,11 +347,7 @@ namespace executors
     */
    void join()
    {
-      for (unsigned i = 0; i < threads.size(); ++i)
-      {
-        threads[i].interrupt();
-        threads[i].join();
-      }
+      pimpl->join();
    }

    /**
@@ -252,7 +356,7 @@ namespace executors
     */
    void close()
    {
-      work_queue.close();
+      pimpl->close();
    }

    /**
@@ -260,7 +364,7 @@ namespace executors
     */
    bool closed()
    {
-      return work_queue.closed();
+      return pimpl->closed();
    }

    /**
@@ -274,28 +378,26 @@ namespace executors
     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
     * Whatever exception that can be throw while storing the closure.
     */
-    void submit(BOOST_THREAD_RV_REF(work) closure)  {
-      work_queue.push(boost::move(closure));
-    }
+//    void submit(BOOST_THREAD_RV_REF(work) closure)  {
+//      work_queue.push(boost::move(closure));
+//    }

 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    template <typename Closure>
    void submit(Closure & closure)
    {
-      submit(work(closure));
+      pimpl->submit(closure);
    }
 #endif
    void submit(void (*closure)())
    {
-      submit(work(closure));
+      pimpl->submit(closure);
    }

    template <typename Closure>
    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
    {
-      //submit(work(boost::forward<Closure>(closure)));
-      work w((boost::forward<Closure>(closure)));
-      submit(boost::move(w));
+      pimpl->submit(boost::forward<Closure>(closure));
    }

    /**
@@ -306,15 +408,16 @@ namespace executors
    template <typename Pred>
    bool reschedule_until(Pred const& pred)
    {
-      do {
-        if ( ! try_executing_one())
-        {
-          return false;
-        }
-      } while (! pred());
-      return true;
+      return pimpl->reschedule_until(pred);
    }

+    void schedule_one_or_yield()
+    {
+      return pimpl->schedule_one_or_yield();
+    }
+
+  private:
+    shared_ptr<shared_state> pimpl;
  };
 }
 using executors::basic_thread_pool;
@@ -24,7 +24,6 @@ namespace detail
  class priority_executor_base
  {
  public:
-    //typedef boost::function<void()> work;
    typedef executors::work_pq work;
  protected:
    typedef Queue queue_type;
@@ -57,16 +56,10 @@ namespace detail
      {
        for(;;)
        {
-          try {
-            work task;
-            queue_op_status st = _workq.wait_pull(task);
-            if (st == queue_op_status::closed) return;
-            task();
-          }
-          catch (boost::thread_interrupted&)
-          {
-            return;
-          }
+          work task;
+          queue_op_status st = _workq.wait_pull(task);
+          if (st == queue_op_status::closed) return;
+          task();
        }
      }
      catch (...)
@@ -1,4 +1,4 @@
-// Copyright (C) 2013,2014 Vicente J. Botet Escriba
+// Copyright (C) 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)
@@ -27,8 +27,6 @@ namespace boost
    /// type-erasure to store the works to do
    typedef  executors::work work;

-    /// executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(executor)
    executor() {}

    /**
@@ -38,7 +36,7 @@ namespace boost
     * \par Synchronization
     * The completion of all the closures happen before the completion of the executor destructor.
     */
-    virtual ~executor() {}
+    virtual ~executor() {};

    /**
     * \par Effects
@@ -129,7 +127,6 @@ namespace boost
    bool reschedule_until(Pred const& pred)
    {
      do {
-        //schedule_one_or_yield();
        if ( ! try_executing_one())
        {
          return false;
@@ -1,4 +1,4 @@
-// Copyright (C) 2013,2014 Vicente J. Botet Escriba
+// Copyright (C) 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)
@@ -12,6 +12,7 @@
 #include <boost/thread/detail/config.hpp>

 #include <boost/thread/executors/executor.hpp>
+#include <boost/thread/detail/move.hpp>

 #include <boost/config/abi_prefix.hpp>

@@ -30,21 +31,52 @@ namespace executors
    /// type-erasure to store the works to do
    typedef  executor::work work;

-    /// executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(executor_adaptor)
-
    /**
     * executor_adaptor constructor
     */
+    //executor_adaptor(executor_adaptor const&) = default;
+    //executor_adaptor(executor_adaptor &&) = default;
+    BOOST_THREAD_COPYABLE_AND_MOVABLE(executor_adaptor)
+
+    executor_adaptor(executor_adaptor const& x) : ex(x.ex) {}
+    executor_adaptor(BOOST_THREAD_RV_REF(executor_adaptor) x)  : ex(boost::move(x.ex)) {}
+
+    executor_adaptor& operator=(BOOST_THREAD_COPY_ASSIGN_REF(executor_adaptor) x)
+    {
+      if (this != &ex)
+      {
+        ex = x.ex;
+      }
+      return *this;
+    }
+    executor_adaptor& operator=(BOOST_THREAD_RV_REF(executor_adaptor) x)
+    {
+      if (this != &ex)
+      {
+        ex = boost::move(x.ex);
+      }
+      return *this;
+    }
+
+    executor_adaptor(Executor const& ex) : ex(ex) {}
+    executor_adaptor(BOOST_THREAD_RV_REF(Executor) ex)  : ex(boost::move(ex)) {}
+
+    executor_adaptor() : ex() {}
+
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <typename ...Args>
-    executor_adaptor(BOOST_THREAD_RV_REF(Args) ... args) : ex(boost::forward<Args>(args)...) {}
+    template <typename Arg, typename ...Args>
+    executor_adaptor(BOOST_THREAD_FWD_REF(Arg) arg, BOOST_THREAD_FWD_REF(Args) ... args
+        , typename disable_if_c<
+          is_same<typename decay<Arg>::type, executor_adaptor>::value
+            ||
+          is_same<typename decay<Arg>::type, Executor>::value
+    , int* >::type=0
+        )
+    : ex(boost::forward<Arg>(arg), boost::forward<Args>(args)...) {}
 #else
    /**
     * executor_adaptor constructor
     */
-    executor_adaptor() : ex() {}
-
    template <typename A1>
    executor_adaptor(
        BOOST_THREAD_FWD_REF(A1) a1
@@ -129,6 +161,9 @@ namespace executors
  };
 }
 using executors::executor_adaptor;
+
+BOOST_THREAD_DCL_MOVABLE_BEG(T) executor_adaptor<T> BOOST_THREAD_DCL_MOVABLE_END
+
 }

 #include <boost/config/abi_suffix.hpp>
@@ -0,0 +1,150 @@
+// 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)
+//
+
+#ifndef BOOST_THREAD_EXECUTORS_GENERIC_EXECUTOR_HPP
+#define BOOST_THREAD_EXECUTORS_GENERIC_EXECUTOR_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/executors/executor_adaptor.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/type_traits/decay.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+  namespace executors
+  {
+
+  class generic_executor
+  {
+    shared_ptr<executor> ex;
+  public:
+    /// type-erasure to store the works to do
+    typedef executors::work work;
+
+    //generic_executor(generic_executor const&) = default;
+    //generic_executor(generic_executor &&) = default;
+
+    template<typename Executor>
+    generic_executor(Executor const& ex
+        , typename boost::disable_if<is_same<Executor, generic_executor>,
+          int* >::type =  (int*)0
+    )
+    //: ex(make_shared<executor_adaptor<Executor> >(ex)) // todo check why this doesn't work with C++03
+    : ex( new executor_adaptor<Executor>(ex) )
+    {
+    }
+
+    //generic_executor(generic_executor const& other) noexcept    {}
+    //generic_executor& operator=(generic_executor const& other) noexcept    {}
+
+
+    /**
+     * \par Effects
+     * Close the \c executor for submissions.
+     * The worker threads will work until there is no more closures to run.
+     */
+    void close() { ex->close(); }
+
+    /**
+     * \par Returns
+     * Whether the pool is closed for submissions.
+     */
+    bool closed() { return ex->closed(); }
+
+    void submit(BOOST_THREAD_RV_REF(work) closure)
+    {
+      ex->submit(boost::forward<work>(closure));
+    }
+
+    /**
+     * \par Requires
+     * \c Closure is a model of Callable(void()) and a model of CopyConstructible/MoveConstructible.
+     *
+     * \par Effects
+     * The specified closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the thread pool will call std::terminate, as is the case with threads.
+     *
+     * \par Synchronization
+     * Completion of closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \par Throws
+     * \c sync_queue_is_closed if the thread pool is closed.
+     * Whatever exception that can be throw while storing the closure.
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      work w ((closure));
+      submit(boost::move(w));
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      work w ((closure));
+      submit(boost::move(w));
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      work w = boost::move(closure);
+      submit(boost::move(w));
+    }
+
+//    size_t num_pending_closures() const
+//    {
+//      return ex->num_pending_closures();
+//    }
+
+    /**
+     * \par Effects
+     * Try to execute one task.
+     *
+     * \par Returns
+     * Whether a task has been executed.
+     *
+     * \par Throws
+     * Whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one() { return ex->try_executing_one(); }
+
+    /**
+     * \par Requires
+     * This must be called from an scheduled task.
+     *
+     * \par Effects
+     * reschedule functions until pred()
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      do {
+        //schedule_one_or_yield();
+        if ( ! try_executing_one())
+        {
+          return false;
+        }
+      } while (! pred());
+      return true;
+    }
+
+  };
+  }
+  using executors::generic_executor;
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif
@@ -13,7 +13,8 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/executors/executor.hpp>

-#include <boost/shared_ptr.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 #include <boost/config/abi_prefix.hpp>

@@ -32,7 +33,7 @@ namespace boost

    /// executor is not copyable.
    BOOST_THREAD_NO_COPYABLE(executor_ref)
-    executor_ref(Executor& ex_) : ex(ex_) {}
+    executor_ref(Executor& ex) : ex(ex) {}

    /**
     * \par Effects
@@ -41,7 +42,7 @@ namespace boost
     * \par Synchronization
     * The completion of all the closures happen before the completion of the executor destructor.
     */
-    ~executor_ref() {}
+    ~executor_ref() {};

    /**
     * \par Effects
@@ -98,9 +99,9 @@ namespace boost
    typedef executors::work work;

    template<typename Executor>
-    generic_executor_ref(Executor& ex_)
-    //: ex(make_shared<executor_ref<Executor> >(ex_)) // todo check why this doesn't works with C++03
-    : ex( new executor_ref<Executor>(ex_) )
+    generic_executor_ref(Executor& ex)
+    //: ex(make_shared<executor_ref<typename decay<Executor>::type> >(ex)) // todo check why this doesn't work with C++03
+    : ex( new executor_ref<typename decay<Executor>::type>(ex) )
    {
    }

@@ -0,0 +1,295 @@
+// Copyright (C) 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)
+//
+// 2013/11 Vicente J. Botet Escriba
+//    first implementation of a simple serial scheduler.
+
+#ifndef BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_HPP
+#define BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/concurrent_queues/sync_queue.hpp>
+#include <boost/thread/executors/work.hpp>
+#include <boost/thread/executors/generic_executor.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/thread/scoped_thread.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/decay.hpp>
+
+#include <boost/thread/caller_context.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+namespace executors
+{
+  class generic_serial_executor
+  {
+  public:
+    /// type-erasure to store the works to do
+    typedef  executors::work work;
+  private:
+
+    struct shared_state {
+      typedef  executors::work work;
+      typedef thread thread_t;
+      //typedef  scoped_thread<> thread_t;
+
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;
+      generic_executor ex;
+      thread_t thr;
+
+      struct try_executing_one_task {
+        work& task;
+        boost::promise<void> &p;
+        try_executing_one_task(work& task, boost::promise<void> &p)
+        : task(task), p(p) {}
+        void operator()() {
+          try {
+            task();
+            p.set_value();
+          } catch (...)
+          {
+            p.set_exception(current_exception());
+          }
+        }
+      };
+    public:
+      /**
+       * \par Returns
+       * The underlying executor wrapped on a generic executor reference.
+       */
+      generic_executor& underlying_executor() BOOST_NOEXCEPT { return ex; }
+
+    private:
+
+      /**
+       * The main loop of the worker thread
+       */
+      void worker_thread()
+      {
+        try
+        {
+          for(;;)
+          {
+            work task;
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) return;
+
+            boost::promise<void> p;
+            try_executing_one_task tmp(task,p);
+            ex.submit(tmp);
+            p.get_future().wait();
+          }
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+    public:
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      template <class Executor>
+      shared_state(Executor const& ex)
+      : ex(ex), thr(&shared_state::worker_thread, this)
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c shared_state destructor.
+       */
+      ~shared_state()
+      {
+        // signal to the worker thread that there will be no more submissions.
+        close();
+        join();
+      }
+
+      /**
+       * \b Effects: join all the threads.
+       */
+      void join()
+      {
+          if (this_thread::get_id() == thr.get_id()) return;
+          thr.join();
+      }
+
+      /**
+       * \b Effects: close the \c generic_serial_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c generic_serial_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        work_queue.push(work(closure));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        work_queue.push(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        work_queue.push(work(boost::forward<Closure>(closure)));
+      }
+
+    };
+
+  public:
+
+//    generic_serial_executor(generic_serial_executor const&) = default;
+//    generic_serial_executor(generic_serial_executor &&) = default;
+
+    /**
+     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    template <class Executor>
+    generic_serial_executor(Executor const& ex
+        , typename boost::disable_if<is_same<Executor, generic_serial_executor>,
+          int* >::type =  (int*)0)
+    : pimpl(make_shared<shared_state>(ex))
+    {
+    }
+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c generic_serial_executor destructor.
+     */
+    ~generic_serial_executor()
+    {
+    }
+
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    generic_executor& underlying_executor() BOOST_NOEXCEPT
+    {
+      return pimpl->underlying_executor();
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    bool try_executing_one()
+    {
+      return false;
+    }
+
+    /**
+     * \b Effects: close the \c generic_serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }
+
+    /**
+     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+     *
+     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the \c generic_serial_executor will call \c std::terminate, as is the case with threads.
+     *
+     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+     * Whatever exception that can be throw while storing the closure.
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      pimpl->submit(closure);
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      pimpl->submit(closure);
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      pimpl->submit(boost::forward<Closure>(closure));
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      return false;
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
+  };
+}
+using executors::generic_serial_executor;
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif
@@ -0,0 +1,265 @@
+// 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)
+//
+// 2013/11 Vicente J. Botet Escriba
+//    first implementation of a simple serial scheduler.
+
+#ifndef BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_CONT_HPP
+#define BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_CONT_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/executors/work.hpp>
+#include <boost/thread/executors/generic_executor.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/thread/scoped_thread.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/decay.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+namespace executors
+{
+  class generic_serial_executor_cont
+  {
+  public:
+    /// type-erasure to store the works to do
+    typedef  executors::work work;
+  private:
+
+    struct shared_state {
+      typedef  executors::work work;
+
+    generic_executor ex_;
+    future<void> fut_; // protected by mtx_
+    bool closed_; // protected by mtx_
+    mutex mtx_;
+
+    struct continuation {
+      work task;
+      template <class X>
+      struct result {
+        typedef void type;
+      };
+      continuation(BOOST_THREAD_RV_REF(work) tsk)
+      : task(boost::move(tsk)) {}
+      void operator()(future<void> f)
+      {
+        try {
+          task();
+        } catch (...)  {
+          std::terminate();
+        }
+      }
+    };
+
+    bool closed(lock_guard<mutex>&) const
+    {
+      return closed_;
+    }
+  public:
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    generic_executor& underlying_executor() BOOST_NOEXCEPT { return ex_; }
+
+    /// shared_state is not copyable.
+    BOOST_THREAD_NO_COPYABLE(shared_state)
+
+    /**
+     * \b Effects: creates a serial executor that runs closures in fifo order using one the associated executor.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     *
+     * \b Notes:
+     * * The lifetime of the associated executor must outlive the serial executor.
+     * * The current implementation doesn't support submission from synchronous continuation, that is,
+     *     - the executor must execute the continuation asynchronously or
+     *     - the continuation can not submit to this serial executor.
+     */
+    template <class Executor>
+    shared_state(Executor const& ex)
+    : ex_(ex), fut_(make_ready_future()), closed_(false)
+    {
+    }
+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c generic_serial_executor_cont destructor.
+     */
+    ~shared_state()
+    {
+      // signal to the worker thread that there will be no more submissions.
+      close();
+    }
+
+    /**
+     * \b Effects: close the \c generic_serial_executor_cont for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      lock_guard<mutex> lk(mtx_);
+      closed_ = true;;
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      lock_guard<mutex> lk(mtx_);
+      return closed(lk);
+    }
+
+    /**
+     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+     *
+     * \b Effects: The specified \c closure will be scheduled for execution after the last submitted closure finish.
+     * If the invoked closure throws an exception the \c generic_serial_executor_cont will call \c std::terminate, as is the case with threads.
+     *
+     * \b Throws: \c sync_queue_is_closed if the executor is closed.
+     * Whatever exception that can be throw while storing the closure.
+     *
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      lock_guard<mutex> lk(mtx_);
+      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+      fut_ = fut_.then(ex_, continuation(work(closure)));
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      lock_guard<mutex> lk(mtx_);
+      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+      fut_ = fut_.then(ex_, continuation(work(closure)));
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      lock_guard<mutex> lk(mtx_);
+      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+      fut_ = fut_.then(ex_, continuation(work(boost::forward<Closure>(closure))));
+    }
+    };
+  public:
+    /**
+     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    template <class Executor>
+    generic_serial_executor_cont(Executor const& ex
+                , typename boost::disable_if<is_same<Executor, generic_serial_executor_cont>,
+                  int* >::type =  (int*)0)
+    : pimpl(make_shared<shared_state>(ex))
+    {
+    }
+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor destructor.
+     */
+    ~generic_serial_executor_cont()
+    {
+    }
+
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    generic_executor& underlying_executor() BOOST_NOEXCEPT
+    {
+      return pimpl->underlying_executor();
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    bool try_executing_one()
+    {
+      return false;
+    }
+
+    /**
+     * \b Effects: close the \c serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }
+
+    /**
+     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+     *
+     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the \c serial_executor will call \c std::terminate, as is the case with threads.
+     *
+     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+     * Whatever exception that can be throw while storing the closure.
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      pimpl->submit(closure);
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      pimpl->submit(closure);
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      pimpl->submit(boost::forward<Closure>(closure));
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      return false;
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
+  };
+}
+using executors::generic_serial_executor_cont;
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif
@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-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)
@@ -14,6 +14,9 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/executors/work.hpp>

+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
 #include <boost/config/abi_prefix.hpp>

 namespace boost
@@ -25,142 +28,227 @@ namespace executors
  public:
    /// type-erasure to store the works to do
    typedef  executors::work work;
-    bool closed_;
-    mutable mutex mtx_;
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      return false;
-    }
+  private:

+    struct shared_state {
+      typedef  executors::work work;
+
+      bool closed_;
+      mutable mutex mtx_;
+
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
+      {
+        return false;
+      }
+
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a inline executor that runs closures immediately.
+       *
+       * \b Throws: Nothing.
+       */
+      shared_state()
+      : closed_(false)
+      {
+      }
+      /**
+       * \b Effects: Destroys the inline executor.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c inline_executor destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * \b Effects: close the \c inline_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        lock_guard<mutex> lk(mtx_);
+        closed_ = true;
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed(lock_guard<mutex>& )  const
+      {
+        return closed_;
+      }
+      bool closed() const
+      {
+        lock_guard<mutex> lk(mtx_);
+        return closed(lk);
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c inline_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        {
+          lock_guard<mutex> lk(mtx_);
+          if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        }
+        try
+        {
+          closure();
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        {
+          lock_guard<mutex> lk(mtx_);
+          if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        }
+        try
+        {
+          closure();
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+      {
+        {
+          lock_guard<mutex> lk(mtx_);
+          if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        }
+        try
+        {
+          closure();
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const& )
+      {
+        return false;
+      }
+  };
  public:
-    /// inline_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(inline_executor)
+  /**
+   * \b Effects: creates a inline executor that runs closures immediately.
+   *
+   * \b Throws: Nothing.
+   */
+  inline_executor()
+  : pimpl(make_shared<shared_state>())
+  {
+  }

-    /**
-     * \b Effects: creates a inline executor that runs closures immediately.
-     *
-     * \b Throws: Nothing.
-     */
-    inline_executor()
-    : closed_(false)
-    {
-    }
-    /**
-     * \b Effects: Destroys the inline executor.
-     *
-     * \b Synchronization: The completion of all the closures happen before the completion of the \c inline_executor destructor.
-     */
-    ~inline_executor()
-    {
-      // signal to all the worker thread that there will be no more submissions.
-      close();
-    }
+  /**
+   * \b Effects: close the \c inline_executor for submissions.
+   * The loop will work until there is no more closures to run.
+   */
+  void close()
+  {
+    pimpl->close();
+  }

-    /**
-     * \b Effects: close the \c inline_executor for submissions.
-     * The loop will work until there is no more closures to run.
-     */
-    void close()
-    {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;
-    }
+  /**
+   * \b Returns: whether the executor is closed for submissions.
+   */
+  bool closed() const
+  {
+    return pimpl->closed();
+  }

-    /**
-     * \b Returns: whether the pool is closed for submissions.
-     */
-    bool closed(lock_guard<mutex>& )
-    {
-      return closed_;
-    }
-    bool closed()
-    {
-      lock_guard<mutex> lk(mtx_);
-      return closed(lk);
-    }
-
-    /**
-     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
-     *
-     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
-     * If invoked closure throws an exception the \c inline_executor will call \c std::terminate, as is the case with threads.
-     *
-     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
-     *
-     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
-     * Whatever exception that can be throw while storing the closure.
-     */
+  /**
+   * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+   *
+   * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+   * If invoked closure throws an exception the \c inline_executor will call \c std::terminate, as is the case with threads.
+   *
+   * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+   *
+   * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+   * Whatever exception that can be throw while storing the closure.
+   */

 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename Closure>
-    void submit(Closure & closure)
-    {
-      {
-        lock_guard<mutex> lk(mtx_);
-        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      }
-      try
-      {
-        closure();
-      }
-      catch (...)
-      {
-        std::terminate();
-        return;
-      }
-    }
+  template <typename Closure>
+  void submit(Closure & closure)
+  {
+    pimpl->submit(closure);
+  }
 #endif
-    void submit(void (*closure)())
-    {
-      {
-        lock_guard<mutex> lk(mtx_);
-        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      }
-      try
-      {
-        closure();
-      }
-      catch (...)
-      {
-        std::terminate();
-        return;
-      }
-    }
+  void submit(void (*closure)())
+  {
+    pimpl->submit(closure);
+  }

-    template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
-    {
-      {
-        lock_guard<mutex> lk(mtx_);
-        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      }
-      try
-      {
-        closure();
-      }
-      catch (...)
-      {
-        std::terminate();
-        return;
-      }
-    }
+  template <typename Closure>
+  void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+  {
+    pimpl->submit(boost::forward<Closure>(closure));
+  }

-    /**
-     * \b Requires: This must be called from an scheduled task.
-     *
-     * \b Effects: reschedule functions until pred()
-     */
-    template <typename Pred>
-    bool reschedule_until(Pred const& )
-    {
-      return false;
-    }
+  /**
+   * Effects: try to execute one task.
+   * Returns: whether a task has been executed.
+   * Throws: whatever the current task constructor throws or the task() throws.
+   */
+  bool try_executing_one()
+  {
+    return pimpl->try_executing_one();
+  }

+  /**
+   * \b Requires: This must be called from an scheduled task.
+   *
+   * \b Effects: reschedule functions until pred()
+   */
+  template <typename Pred>
+  bool reschedule_until(Pred const& p)
+  {
+    return pimpl->reschedule_until(p);
+  }
+  private:
+    shared_ptr<shared_state> pimpl;
  };
 }
 using executors::inline_executor;
@@ -1,4 +1,4 @@
-// Copyright (C) 2013,2014 Vicente J. Botet Escriba
+// Copyright (C) 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)
@@ -16,7 +16,9 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
 #include <boost/thread/executors/work.hpp>
-#include <boost/assert.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 #include <boost/config/abi_prefix.hpp>

@@ -31,62 +33,178 @@ namespace executors
    /// type-erasure to store the works to do
    typedef  executors::work work;
  private:
-    /// the thread safe work queue
-    concurrent::sync_queue<work > work_queue;

-  public:
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      return execute_one(/*wait:*/false);
-    }
+    struct shared_state {
+      typedef  executors::work work;
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;

-  private:
-    /**
-     * Effects: Execute one task.
-     * Remark: If wait is true, waits until a task is available or the executor
-     *         is closed. If wait is false, returns false immediately if no
-     *         task is available.
-     * Returns: whether a task has been executed (if wait is true, only returns false if closed).
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool execute_one(bool wait)
-    {
-      work task;
-      try
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
      {
-        queue_op_status status = wait ?
-          work_queue.wait_pull(task) :
-          work_queue.try_pull(task);
-        if (status == queue_op_status::success)
+        work task;
+        try
        {
-          task();
-          return true;
+          if (work_queue.try_pull(task) == queue_op_status::success)
+          {
+            task();
+            return true;
+          }
+          return false;
+        }
+        catch (...)
+        {
+          std::terminate();
+          return false;
        }
-        BOOST_ASSERT(!wait || status == queue_op_status::closed);
-        return false;
      }
-      catch (...)
+      /**
+       * Effects: schedule one task or yields
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      void schedule_one_or_yield()
      {
-        std::terminate();
-        //return false;
+          if ( ! try_executing_one())
+          {
+            this_thread::yield();
+          }
      }
-    }

+      /// loop_executor is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      shared_state()
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c loop_executor destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * The main loop of the worker thread
+       */
+      void loop()
+      {
+        while (!closed())
+        {
+          schedule_one_or_yield();
+        }
+        while (try_executing_one())
+        {
+        }
+      }
+
+      /**
+       * \b Effects: close the \c loop_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c loop_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+      void submit(BOOST_THREAD_RV_REF(work) closure)  {
+        work_queue.push(boost::move(closure));
+      }
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        //work_queue.push(work(closure));
+        submit(work(closure));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        //work_queue.push(work(closure));
+        submit(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        //work_queue.push(work(boost::forward<Closure>(closure)));
+        work w((boost::forward<Closure>(closure)));
+        submit(boost::move(w));
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred)
+      {
+        do {
+          if ( ! try_executing_one())
+          {
+            return false;
+          }
+        } while (! pred());
+        return true;
+      }
+
+      /**
+       * run queued closures
+       */
+      void run_queued_closures()
+      {
+        sync_queue<work>::underlying_queue_type q = work_queue.underlying_queue();
+        while (! q.empty())
+        {
+          work& task = q.front();
+          task();
+          q.pop_front();
+        }
+      }
+
+    };
  public:
-    /// loop_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(loop_executor)
-
    /**
     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
     *
     * \b Throws: Whatever exception is thrown while initializing the needed resources.
     */
    loop_executor()
+    : pimpl(make_shared<shared_state>())
    {
    }
    /**
@@ -96,22 +214,33 @@ namespace executors
     */
    ~loop_executor()
    {
-      // signal to all the worker thread that there will be no more submissions.
-      close();
    }

+    /**
+     * Effects: try to execute one task.
+     * Returns: whether a task has been executed.
+     * Throws: whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one()
+    {
+      return pimpl->try_executing_one();
+    }
+//    /**
+//     * Effects: schedule one task or yields
+//     * Throws: whatever the current task constructor throws or the task() throws.
+//     */
+//    void schedule_one_or_yield()
+//    {
+//      return pimpl->schedule_one_or_yield();
+//    }
+
+
    /**
     * The main loop of the worker thread
     */
    void loop()
    {
-      while (execute_one(/*wait:*/true))
-      {
-      }
-      BOOST_ASSERT(closed());
-      while (try_executing_one())
-      {
-      }
+      pimpl->loop();
    }

    /**
@@ -120,7 +249,7 @@ namespace executors
     */
    void close()
    {
-      work_queue.close();
+      pimpl->close();
    }

    /**
@@ -128,7 +257,7 @@ namespace executors
     */
    bool closed()
    {
-      return work_queue.closed();
+      return pimpl->closed();
    }

    /**
@@ -142,29 +271,27 @@ namespace executors
     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
     * Whatever exception that can be throw while storing the closure.
     */
-    void submit(BOOST_THREAD_RV_REF(work) closure)  {
-      work_queue.push(boost::move(closure));
-    }
+//    void submit(BOOST_THREAD_RV_REF(work) closure)  {
+//      work_queue.push(boost::move(closure));
+//    }

 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    template <typename Closure>
    void submit(Closure & closure)
    {
-      submit(work(closure));
-   }
+      pimpl->submit(closure);
+    }
 #endif

    void submit(void (*closure)())
    {
-      submit(work(closure));
+      pimpl->submit(closure);
    }

    template <typename Closure>
    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
    {
-      //work_queue.push(work(boost::forward<Closure>(closure)));
-      work w((boost::forward<Closure>(closure)));
-      submit(boost::move(w));
+      pimpl->submit(boost::forward<Closure>(closure));
    }

    /**
@@ -175,13 +302,7 @@ namespace executors
    template <typename Pred>
    bool reschedule_until(Pred const& pred)
    {
-      do {
-        if ( ! try_executing_one())
-        {
-          return false;
-        }
-      } while (! pred());
-      return true;
+      return pimpl->reschedule_until(pred);
    }

    /**
@@ -189,15 +310,10 @@ namespace executors
     */
    void run_queued_closures()
    {
-      sync_queue<work>::underlying_queue_type q = work_queue.underlying_queue();
-      while (! q.empty())
-      {
-        work& task = q.front();
-        task();
-        q.pop_front();
-      }
+      pimpl->run_queued_closures();
    }
-
+  private:
+    shared_ptr<shared_state> pimpl;
  };
 }
 using executors::loop_executor;
@@ -9,37 +9,123 @@
 #define BOOST_THREAD_EXECUTORS_SCHEDULED_THREAD_POOL_HPP

 #include <boost/thread/executors/detail/scheduled_executor_base.hpp>
+#include <boost/thread/executors/work.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/scoped_thread.hpp>
+#include <boost/thread/csbl/vector.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 namespace boost
 {
 namespace executors
 {

-  class scheduled_thread_pool : public detail::scheduled_executor_base<>
+  template <class Clock = chrono::steady_clock>
+  class scheduled_thread_pool
  {
  private:
-    thread_group _workers;
-  public:

-    scheduled_thread_pool(size_t num_threads) : super()
-    {
-      for(size_t i = 0; i < num_threads; i++)
+    struct shared_state : public detail::scheduled_executor_base<> {
+
+      /// basic_thread_pool is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      typedef detail::scheduled_executor_base<> super;
+      typedef typename super::work work;
+
+      typedef scoped_thread<> thread_t;
+      typedef csbl::vector<thread_t> thread_vector;
+      thread_vector threads;
+
+      shared_state(unsigned const thread_count = thread::hardware_concurrency()+1) : super()
      {
-        _workers.create_thread(bind(&super::loop, this));
+
+        try
+        {
+          threads.reserve(thread_count);
+          for (unsigned i = 0; i < thread_count; ++i)
+          {
+  #if 1
+            thread th (&shared_state::loop, this);
+            threads.push_back(thread_t(boost::move(th)));
+  #else
+            threads.push_back(thread_t(&shared_state::loop, this)); // do not compile
+  #endif
+          }
+        }
+        catch (...)
+        {
+          close();
+          throw;
+        }
      }
+
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c basic_thread_pool destructor.
+       */
+      ~shared_state()
+      {
+        this->close();
+      }
+    }; //end class
+
+  public:
+    typedef typename shared_state::work work;
+    typedef Clock clock;
+    typedef typename clock::duration duration;
+    typedef typename clock::time_point time_point;
+
+
+    /**
+     * \b Effects: creates a thread pool that runs closures on \c thread_count threads.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    scheduled_thread_pool(unsigned const thread_count = thread::hardware_concurrency()+1)
+    : pimpl(make_shared<shared_state>(thread_count))
+    {
    }

+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c basic_thread_pool destructor.
+     */
    ~scheduled_thread_pool()
    {
-      this->close();
-      _workers.interrupt_all();
-      _workers.join_all();
+    }
+    /**
+     * \b Effects: close the \c serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
    }

-  private:
-    typedef detail::scheduled_executor_base<> super;
-  }; //end class
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }

+    void submit_at(work w, const time_point& tp)
+    {
+      return pimpl->submit_at(boost::move(w), tp);
+    }
+
+    void submit_after(work w, const duration& d)
+    {
+      return pimpl->submit_after(boost::move(w), d);
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
+  };
 } //end executors namespace

 using executors::scheduled_thread_pool;
@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-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)
@@ -13,6 +13,8 @@
 #include <boost/chrono/time_point.hpp>
 #include <boost/chrono/duration.hpp>
 #include <boost/chrono/system_clocks.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 #include <boost/config/abi_prefix.hpp>

@@ -36,7 +38,7 @@ namespace boost
      }

    private:
-      Executor&   ex;
+      Executor   ex;
      Function funct;
    };

@@ -100,8 +102,8 @@ namespace boost
      }

    private:
-      Scheduler&  sch;
-      Executor&   ex;
+      Scheduler   sch;
+      Executor   ex;
      typename clock::time_point  tp;
      bool  is_closed;
    };
@@ -150,8 +152,8 @@ namespace boost
      }

    private:
-      Scheduler& sch;
-      Executor& ex;
+      Scheduler sch;
+      Executor ex;
    }; //end class

    /// Wraps a reference to a @c Scheduler providing an @c Executor that
@@ -208,7 +210,7 @@ namespace boost
      }

    private:
-      Scheduler& sch;
+      Scheduler sch;
      time_point  tp;
      bool  is_closed;
    }; //end class
@@ -217,23 +219,71 @@ namespace boost
    /// It provides factory helper functions such as at/after that convert a @c Scheduler into an @c Executor
    /// that submit the work at/after a specific time/duration respectively.
    template <class Clock = chrono::steady_clock>
-    class scheduler : public detail::scheduled_executor_base<Clock>
+    class scheduler
    {
-    public:
-      typedef typename detail::scheduled_executor_base<Clock>::work work;
+    private:

+      struct shared_state : public detail::scheduled_executor_base<Clock> {
+        typedef detail::scheduled_executor_base<Clock> super;
+        typedef typename super::work work;
+        thread thr;
+
+        /// shared_state is not copyable.
+        BOOST_THREAD_NO_COPYABLE(shared_state)
+
+        shared_state()
+          : super(),
+            thr(&super::loop, this) {}
+
+        ~shared_state()
+        {
+          this->close();
+          thr.join();
+        }
+
+      };
+
+    public:
+      typedef typename shared_state::work work;
      typedef Clock clock;
+      typedef typename clock::duration duration;
+      typedef typename clock::time_point time_point;

      scheduler()
-        : super(),
-          thr(&super::loop, this) {}
+        : pimpl(make_shared<shared_state>())
+      {}

      ~scheduler()
      {
-        this->close();
-        thr.interrupt();
-        thr.join();
      }
+
+      /**
+       * \b Effects: close the \c serial_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        pimpl->close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return pimpl->closed();
+      }
+
+      void submit_at(work w, const time_point& tp)
+      {
+        return pimpl->submit_at(boost::move(w), tp);
+      }
+
+      void submit_after(work w, const duration& d)
+      {
+        return pimpl->submit_after(boost::move(w), d);
+      }
+
      template <class Ex>
      scheduler_executor_wrapper<scheduler, Ex> on(Ex& ex)
      {
@@ -251,13 +301,10 @@ namespace boost
      {
        return at_executor<scheduler>(*this, tp);
      }
-
    private:
-      typedef detail::scheduled_executor_base<Clock> super;
-      thread thr;
+      shared_ptr<shared_state> pimpl;
    };

-
  }
  using executors::resubmitter;
  using executors::resubmit;
@@ -19,7 +19,7 @@ namespace executors
  class scheduling_adpator : public detail::scheduled_executor_base<>
  {
  private:
-    Executor& _exec;
+    Executor _exec;
    thread _scheduler;
  public:

@@ -31,7 +31,6 @@ namespace executors
    ~scheduling_adpator()
    {
      this->close();
-      _scheduler.interrupt();
      _scheduler.join();
    }

@@ -1,4 +1,4 @@
-// Copyright (C) 2013 Vicente J. Botet Escriba
+// Copyright (C) 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)
@@ -14,116 +14,179 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
 #include <boost/thread/executors/work.hpp>
-#include <boost/thread/executors/generic_executor_ref.hpp>
+#include <boost/thread/executors/generic_executor.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/thread/scoped_thread.hpp>

+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
 namespace executors
 {
+  template <class Executor>
  class serial_executor
  {
  public:
    /// type-erasure to store the works to do
    typedef  executors::work work;
  private:
-    typedef  scoped_thread<> thread_t;

-    /// the thread safe work queue
-    concurrent::sync_queue<work > work_queue;
-    generic_executor_ref ex;
-    thread_t thr;
+    struct shared_state {
+      typedef  executors::work work;
+      //typedef  scoped_thread<> thread_t;
+      typedef thread thread_t;

-    struct try_executing_one_task {
-      work& task;
-      boost::promise<void> &p;
-      try_executing_one_task(work& task, boost::promise<void> &p)
-      : task(task), p(p) {}
-      void operator()() {
-        try {
-          task();
-          p.set_value();
-        } catch (...)
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;
+      Executor ex;
+      thread_t thr;
+
+      struct try_executing_one_task {
+        work& task;
+        boost::promise<void> &p;
+        try_executing_one_task(work& task, boost::promise<void> &p)
+        : task(task), p(p) {}
+        void operator()() {
+          try {
+            task();
+            p.set_value();
+          } catch (...)
+          {
+            p.set_exception(current_exception());
+          }
+        }
+      };
+    public:
+      /**
+       * \par Returns
+       * The underlying executor wrapped on a generic executor reference.
+       */
+      Executor& underlying_executor() BOOST_NOEXCEPT { return ex; }
+
+    private:
+
+      /**
+       * The main loop of the worker thread
+       */
+      void worker_thread()
+      {
+        try
        {
-          p.set_exception(current_exception());
+          for(;;)
+          {
+            work task;
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) return;
+
+            boost::promise<void> p;
+            try_executing_one_task tmp(task,p);
+            ex.submit(tmp);
+            p.get_future().wait();
+          }
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
        }
      }
+
+    public:
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      shared_state(Executor& ex)
+      : ex(ex), thr(&shared_state::worker_thread, this)
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c shared_state destructor.
+       */
+      ~shared_state()
+      {
+        // signal to the worker thread that there will be no more submissions.
+        close();
+        thr.join();
+      }
+
+      /**
+       * \b Effects: close the \c serial_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c serial_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+      void submit(BOOST_THREAD_RV_REF(work) closure)
+      {
+        work_queue.push(boost::move(closure));
+      }
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        //work_queue.push(work(closure));
+        submit(work(closure));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        //work_queue.push(work(closure));
+        submit(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+      {
+        //work_queue.push(work(boost::move(closure)));
+        work w((boost::forward<Closure>(closure)));
+        submit(boost::move(w));
+      }
+
    };
-  public:
-    /**
-     * \par Returns
-     * The underlying executor wrapped on a generic executor reference.
-     */
-    generic_executor_ref& underlying_executor() BOOST_NOEXCEPT { return ex; }
-
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      work task;
-      try
-      {
-        if (work_queue.try_pull(task) == queue_op_status::success)
-        {
-          boost::promise<void> p;
-          try_executing_one_task tmp(task,p);
-          ex.submit(tmp);
-          p.get_future().wait();
-          return true;
-        }
-        return false;
-      }
-      catch (...)
-      {
-        std::terminate();
-        //return false;
-      }
-    }
-  private:
-    /**
-     * Effects: schedule one task or yields
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    void schedule_one_or_yield()
-    {
-        if ( ! try_executing_one())
-        {
-          this_thread::yield();
-        }
-    }
-
-    /**
-     * The main loop of the worker thread
-     */
-    void worker_thread()
-    {
-      while (!closed())
-      {
-        schedule_one_or_yield();
-      }
-      while (try_executing_one())
-      {
-      }
-    }

  public:
-    /// serial_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(serial_executor)

    /**
     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
     *
     * \b Throws: Whatever exception is thrown while initializing the needed resources.
     */
-    template <class Executor>
    serial_executor(Executor& ex)
-    : ex(ex), thr(&serial_executor::worker_thread, this)
+    : pimpl(make_shared<shared_state>(ex))
    {
    }
    /**
@@ -133,8 +196,24 @@ namespace executors
     */
    ~serial_executor()
    {
-      // signal to the worker thread that there will be no more submissions.
-      close();
+    }
+
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    Executor& underlying_executor() BOOST_NOEXCEPT
+    {
+      return pimpl->underlying_executor();
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    bool try_executing_one()
+    {
+      return false;
    }

    /**
@@ -143,7 +222,7 @@ namespace executors
     */
    void close()
    {
-      work_queue.close();
+      pimpl->close();
    }

    /**
@@ -151,7 +230,7 @@ namespace executors
     */
    bool closed()
    {
-      return work_queue.closed();
+      return pimpl->closed();
    }

    /**
@@ -165,47 +244,40 @@ namespace executors
     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
     * Whatever exception that can be throw while storing the closure.
     */
-    void submit(BOOST_THREAD_RV_REF(work) closure)
-    {
-      work_queue.push(boost::move(closure));
-    }
+//    void submit(BOOST_THREAD_RV_REF(work) closure)
+//    {
+//      work_queue.push(boost::move(closure));
+//    }

 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    template <typename Closure>
    void submit(Closure & closure)
    {
-      submit(work(closure));
+      pimpl->submit(closure);
    }
 #endif
    void submit(void (*closure)())
    {
-      submit(work(closure));
+      pimpl->submit(closure);
    }

    template <typename Closure>
    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
    {
-      work w((boost::forward<Closure>(closure)));
-      submit(boost::move(w));
+      pimpl->submit(boost::forward<Closure>(closure));
    }

    /**
-     * \b Requires: This must be called from an scheduled task.
-     *
-     * \b Effects: reschedule functions until pred()
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
     */
    template <typename Pred>
    bool reschedule_until(Pred const& pred)
    {
-      do {
-        if ( ! try_executing_one())
-        {
-          return false;
-        }
-      } while (! pred());
-      return true;
+      return false;
    }
-
+  private:
+    shared_ptr<shared_state> pimpl;
  };
 }
 using executors::serial_executor;
@@ -12,18 +12,20 @@
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
-#include <boost/thread/concurrent_queues/sync_queue.hpp>
 #include <boost/thread/executors/work.hpp>
-#include <boost/thread/executors/generic_executor_ref.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/thread/scoped_thread.hpp>

+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
 namespace executors
 {
+  template <class Executor>
  class serial_executor_cont
  {
  public:
@@ -31,93 +33,156 @@ namespace executors
    typedef  executors::work work;
  private:

-    generic_executor_ref ex_;
-    future<void> fut_; // protected by mtx_
-    bool closed_; // protected by mtx_
-    mutex mtx_;
+    struct shared_state {
+      typedef  executors::work work;

-    struct continuation {
-      work task;
-      template <class X>
-      struct result {
-        typedef void type;
-      };
-      continuation(BOOST_THREAD_RV_REF(work) tsk)
-      : task(boost::move(tsk)) {}
-      void operator()(future<void> f)
-      {
-        try {
-          task();
-        } catch (...)  {
-          std::terminate();
+      Executor ex_;
+      future<void> fut_; // protected by mtx_
+      bool closed_; // protected by mtx_
+      mutex mtx_;
+
+      struct continuation {
+        work task;
+        template <class X>
+        struct result {
+          typedef void type;
+        };
+        continuation(BOOST_THREAD_RV_REF(work) tsk)
+        : task(boost::move(tsk)) {}
+        void operator()(future<void> f)
+        {
+          try {
+            task();
+          } catch (...)  {
+            std::terminate();
+          }
        }
+      };
+
+      bool closed(lock_guard<mutex>&) const
+      {
+        return closed_;
+      }
+    public:
+      /**
+       * \par Returns
+       * The underlying executor wrapped on a generic executor reference.
+       */
+      Executor& underlying_executor() BOOST_NOEXCEPT { return ex_; }
+
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a serial executor that runs closures in fifo order using one the associated executor.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       *
+       * \b Notes:
+       * * The lifetime of the associated executor must outlive the serial executor.
+       * * The current implementation doesn't support submission from synchronous continuation, that is,
+       *     - the executor must execute the continuation asynchronously or
+       *     - the continuation can not submit to this serial executor.
+       */
+      shared_state(Executor& ex)
+      : ex_(ex), fut_(make_ready_future()), closed_(false)
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor_cont destructor.
+       */
+      ~shared_state()
+      {
+        // signal to the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * \b Effects: close the \c serial_executor_cont for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        lock_guard<mutex> lk(mtx_);
+        closed_ = true;;
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        lock_guard<mutex> lk(mtx_);
+        return closed(lk);
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution after the last submitted closure finish.
+       * If the invoked closure throws an exception the \c serial_executor_cont will call \c std::terminate, as is the case with threads.
+       *
+       * \b Throws: \c sync_queue_is_closed if the executor is closed.
+       * Whatever exception that can be throw while storing the closure.
+       *
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        fut_ = fut_.then(ex_, continuation(work(closure)));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        fut_ = fut_.then(ex_, continuation(work(closure)));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        fut_ = fut_.then(ex_, continuation(work(boost::forward<Closure>(closure))));
      }
    };
-
-    bool closed(lock_guard<mutex>&) const
-    {
-      return closed_;
-    }
  public:
    /**
-     * \par Returns
-     * The underlying executor wrapped on a generic executor reference.
-     */
-    generic_executor_ref& underlying_executor() BOOST_NOEXCEPT { return ex_; }
-
-    /// serial_executor_cont is not copyable.
-    BOOST_THREAD_NO_COPYABLE(serial_executor_cont)
-
-    /**
-     * \b Effects: creates a serial executor that runs closures in fifo order using one the associated executor.
+     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
     *
     * \b Throws: Whatever exception is thrown while initializing the needed resources.
-     *
-     * \b Notes:
-     * * The lifetime of the associated executor must outlive the serial executor.
-     * * The current implementation doesn't support submission from synchronous continuation, that is,
-     *     - the executor must execute the continuation asynchronously or
-     *     - the continuation can not submit to this serial executor.
     */
-    template <class Executor>
    serial_executor_cont(Executor& ex)
-    : ex_(ex), fut_(make_ready_future()), closed_(false)
+    : pimpl(make_shared<shared_state>(ex))
    {
    }
    /**
     * \b Effects: Destroys the thread pool.
     *
-     * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor_cont destructor.
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor destructor.
     */
    ~serial_executor_cont()
    {
-      // signal to the worker thread that there will be no more submissions.
-      close();
    }

    /**
-     * \b Effects: close the \c serial_executor_cont for submissions.
-     * The loop will work until there is no more closures to run.
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
     */
-    void close()
+    Executor& underlying_executor() BOOST_NOEXCEPT
    {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;;
+      return pimpl->underlying_executor();
    }

    /**
-     * \b Returns: whether the pool is closed for submissions.
-     */
-    bool closed()
-    {
-      lock_guard<mutex> lk(mtx_);
-      return closed(lk);
-    }
-
-    /**
-     * Effects: none.
-     * Returns: always false.
-     * Throws: No.
+     * \b Returns: always false as a serial executor can not re-enter.
     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
     */
    bool try_executing_one()
@@ -125,41 +190,64 @@ namespace executors
      return false;
    }

+    /**
+     * \b Effects: close the \c serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }
+
    /**
     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
     *
-     * \b Effects: The specified \c closure will be scheduled for execution after the last submitted closure finish.
-     * If the invoked closure throws an exception the \c serial_executor_cont will call \c std::terminate, as is the case with threads.
+     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the \c serial_executor will call \c std::terminate, as is the case with threads.
     *
-     * \b Throws: \c sync_queue_is_closed if the executor is closed.
+     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
     * Whatever exception that can be throw while storing the closure.
-     *
     */

 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    template <typename Closure>
    void submit(Closure & closure)
    {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      fut_ = fut_.then(ex_, continuation(work(closure)));
+      pimpl->submit(closure);
    }
 #endif
    void submit(void (*closure)())
    {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      fut_ = fut_.then(ex_, continuation(work(closure)));
+      pimpl->submit(closure);
    }

    template <typename Closure>
    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
    {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      fut_ = fut_.then(ex_, continuation(work(boost::forward<Closure>(closure))));
+      pimpl->submit(boost::forward<Closure>(closure));
    }

+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      return false;
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
  };
 }
 using executors::serial_executor_cont;
@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-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)
@@ -17,7 +17,9 @@
 #include <boost/thread/thread_only.hpp>
 #include <boost/thread/scoped_thread.hpp>
 #include <boost/thread/csbl/vector.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 #include <boost/config/abi_prefix.hpp>

@@ -30,33 +32,148 @@ namespace executors
  public:
    /// type-erasure to store the works to do
    typedef  executors::work work;
-    bool closed_;
-    typedef scoped_thread<> thread_t;
-    typedef csbl::vector<thread_t> threads_type;
-    threads_type threads_;
-    mutable mutex mtx_;
+  private:

-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      return false;
-    }
+    struct shared_state {
+      typedef  executors::work work;
+      bool closed_;
+      //typedef scoped_thread<> thread_t;
+      typedef thread thread_t;
+      typedef csbl::vector<thread_t> threads_type;
+      threads_type threads_;
+      mutable mutex mtx_;

+      /// thread_executor::shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a inline executor that runs closures immediately.
+       *
+       * \b Throws: Nothing.
+       */
+      shared_state()
+      : closed_(false)
+      {
+      }
+      /**
+       * \b Effects: Waits for closures (if any) to complete, then joins and destroys the threads.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c thread_executor destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker thread that there will be no more submissions.
+        close();
+        // all the scoped threads will join before destroying
+        join();
+      }
+
+      /**
+       * \b Effects: join all the threads.
+       */
+      void join()
+      {
+        for (unsigned i = 0; i < threads_.size(); ++i)
+        {
+          if (this_thread::get_id() == threads_[i].get_id()) continue;
+          threads_[i].join();
+        }
+      }
+
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
+      {
+        return false;
+      }
+
+      /**
+       * \b Effects: close the \c thread_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        lock_guard<mutex> lk(mtx_);
+        closed_ = true;
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed(lock_guard<mutex>& )
+      {
+        return closed_;
+      }
+      bool closed()
+      {
+        lock_guard<mutex> lk(mtx_);
+        return closed(lk);
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c thread_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        threads_.reserve(threads_.size() + 1);
+        thread th(closure);
+        threads_.push_back(thread_t(boost::move(th)));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        threads_.reserve(threads_.size() + 1);
+        thread th(closure);
+        threads_.push_back(thread_t(boost::move(th)));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        threads_.reserve(threads_.size() + 1);
+        thread th(boost::forward<Closure>(closure));
+        threads_.push_back(thread_t(boost::move(th)));
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const&)
+      {
+        return false;
+      }
+    };
  public:
-    /// thread_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(thread_executor)
-
    /**
     * \b Effects: creates a inline executor that runs closures immediately.
     *
     * \b Throws: Nothing.
     */
    thread_executor()
-    : closed_(false)
+    : pimpl(make_shared<shared_state>())
    {
    }
    /**
@@ -66,9 +183,16 @@ namespace executors
     */
    ~thread_executor()
    {
-      // signal to all the worker thread that there will be no more submissions.
-      close();
-      // all the scoped threads will join before destroying
+    }
+
+    /**
+     * Effects: try to execute one task.
+     * Returns: whether a task has been executed.
+     * Throws: whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one()
+    {
+      return pimpl->try_executing_one();
    }

    /**
@@ -77,21 +201,15 @@ namespace executors
     */
    void close()
    {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;
+      pimpl->close();
    }

    /**
     * \b Returns: whether the pool is closed for submissions.
     */
-    bool closed(lock_guard<mutex>& )
-    {
-      return closed_;
-    }
    bool closed()
    {
-      lock_guard<mutex> lk(mtx_);
-      return closed(lk);
+      return pimpl->closed();
    }

    /**
@@ -110,30 +228,18 @@ namespace executors
    template <typename Closure>
    void submit(Closure & closure)
    {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      threads_.reserve(threads_.size() + 1);
-      thread th(closure);
-      threads_.push_back(thread_t(boost::move(th)));
+      pimpl->submit(closure);
    }
 #endif
    void submit(void (*closure)())
    {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      threads_.reserve(threads_.size() + 1);
-      thread th(closure);
-      threads_.push_back(thread_t(boost::move(th)));
+      pimpl->submit(closure);
    }

    template <typename Closure>
    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
    {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      threads_.reserve(threads_.size() + 1);
-      thread th(boost::forward<Closure>(closure));
-      threads_.push_back(thread_t(boost::move(th)));
+      pimpl->submit(boost::forward<Closure>(closure));
    }

    /**
@@ -142,12 +248,14 @@ namespace executors
     * \b Effects: reschedule functions until pred()
     */
    template <typename Pred>
-    bool reschedule_until(Pred const&)
+    bool reschedule_until(Pred const& p)
    {
-      return false;
+      return pimpl->reschedule_until(p);
    }
-
+  private:
+    shared_ptr<shared_state> pimpl;
  };
+
 }
 using executors::thread_executor;
 }
@@ -116,9 +116,9 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
    template<typename F>
    friend void task_region_final(BOOST_THREAD_FWD_REF(F) f);
    template <class Ex, typename F>
-    friend void task_region(Ex&, BOOST_THREAD_FWD_REF(F) f);
+    friend void task_region(Ex const&, BOOST_THREAD_FWD_REF(F) f);
    template<class Ex, typename F>
-    friend void task_region_final(Ex&, BOOST_THREAD_FWD_REF(F) f);
+    friend void task_region_final(Ex const&, BOOST_THREAD_FWD_REF(F) f);

    void wait_all()
    {
@@ -153,21 +153,20 @@ protected:
 #if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED && defined BOOST_THREAD_PROVIDES_EXECUTORS
    task_region_handle_gen()
    : canceled(false)
-    , ex(0)
    {}
-    task_region_handle_gen(Executor& ex)
+    task_region_handle_gen(Executor const& ex)
    : canceled(false)
-    , ex(&ex)
+    , ex(ex)
    {}

 #endif

 #if ! defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED && defined BOOST_THREAD_PROVIDES_EXECUTORS
    task_region_handle_gen()
-    : ex(0)
+    //: ex(0)
    {}
-    task_region_handle_gen(Executor& ex)
-    : ex(&ex)
+    task_region_handle_gen(Executor const& ex)
+    : ex(ex)
    {}
 #endif

@@ -188,7 +187,7 @@ protected:
    bool canceled;
 #endif
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-    Executor* ex;
+    Executor ex;
 #endif
    exception_list exs;
    typedef csbl::vector<future<void> > group_type;
@@ -211,13 +210,13 @@ protected:
        }
      }
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-      group.push_back(async(*ex, detail::wrapped<task_region_handle_gen<Executor>, F>(*this, forward<F>(f))));
+      group.push_back(async(ex, detail::wrapped<task_region_handle_gen<Executor>, F>(*this, forward<F>(f))));
 #else
      group.push_back(async(detail::wrapped<task_region_handle_gen<Executor>, F>(*this, forward<F>(f))));
 #endif
 #else
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-      group.push_back(async(*ex, forward<F>(f)));
+      group.push_back(async(ex, forward<F>(f)));
 #else
      group.push_back(async(forward<F>(f)));
 #endif
@@ -245,17 +244,18 @@ protected:
  class task_region_handle :
    public task_region_handle_gen<default_executor>
  {
-    default_executor tp;
+    //default_executor tp;
    template <typename F>
    friend void task_region(BOOST_THREAD_FWD_REF(F) f);
    template<typename F>
    friend void task_region_final(BOOST_THREAD_FWD_REF(F) f);

  protected:
-    task_region_handle() : task_region_handle_gen<default_executor>()
+    task_region_handle()
+    : task_region_handle_gen<default_executor>()
    {
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-      ex = &tp;
+      //ex = &tp;
 #endif
    }
    BOOST_DELETED_FUNCTION(task_region_handle(const task_region_handle&))
@@ -265,7 +265,7 @@ protected:
  };

  template <typename Executor, typename F>
-  void task_region_final(Executor& ex, BOOST_THREAD_FWD_REF(F) f)
+  void task_region_final(Executor const& ex, BOOST_THREAD_FWD_REF(F) f)
  {
    task_region_handle_gen<Executor> tr(ex);
    try
@@ -280,7 +280,7 @@ protected:
  }

  template <typename Executor, typename F>
-  void task_region(Executor& ex, BOOST_THREAD_FWD_REF(F) f)
+  void task_region(Executor const& ex, BOOST_THREAD_FWD_REF(F) f)
  {
    task_region_final(ex, forward<F>(f));
  }
@@ -22,8 +22,6 @@ namespace boost
 #ifdef BOOST_THREAD_PROVIDES_EXECUTORS
      executor = 4,
 #endif
-      inherit = 8,
-      sync = 16,
      any = async | deferred
  }
  BOOST_SCOPED_ENUM_DECLARE_END(launch)
@@ -60,7 +60,7 @@ namespace boost
    }
 #else
    template<typename F1, typename... Fs>
-    typename boost::enable_if<is_future_type<F1>,void>::type wait_for_all(F1& f1, Fs&... fs)
+    void wait_for_all(F1& f1, Fs&... fs)
    {
        bool dummy[] = { (f1.wait(), true), (fs.wait(), true)... };

@@ -934,7 +934,7 @@ namespace boost
      if (m == 0)
      {
        boost::throw_exception(
-            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
+            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if (owns_lock())
      {
@@ -949,7 +949,7 @@ namespace boost
      if (m == 0)
      {
        boost::throw_exception(
-            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
+            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if (owns_lock())
      {
@@ -964,7 +964,7 @@ namespace boost
      if (m == 0)
      {
        boost::throw_exception(
-            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
+            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if (!owns_lock())
      {
@@ -980,11 +980,11 @@ namespace boost
    {
      if(m==0)
      {
-        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
+        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
-        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost upgrade_lock owns already the mutex"));
+        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_upgrade_for(rel_time);
      return is_locked;
@@ -994,11 +994,11 @@ namespace boost
    {
      if(m==0)
      {
-        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
+        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
-        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost upgrade_lock owns already the mutex"));
+        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_upgrade_until(abs_time);
      return is_locked;
@@ -1080,7 +1080,7 @@ namespace boost
    //std-2104 unique_lock move-assignment should not be noexcept
    upgrade_to_unique_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_to_unique_lock<Mutex> BOOST_THREAD_RV_REF_END other) //BOOST_NOEXCEPT
    {
-      upgrade_to_unique_lock temp(::boost::move(other));
+      upgrade_to_unique_lock temp(other);
      swap(temp);
      return *this;
    }
@@ -1167,7 +1167,7 @@ private unique_lock<Mutex>
 #endif
    try_lock_wrapper& operator=(BOOST_THREAD_RV_REF_BEG try_lock_wrapper<Mutex> BOOST_THREAD_RV_REF_END other)
    {
-      try_lock_wrapper temp(::boost::move(other));
+      try_lock_wrapper temp(other);
      swap(temp);
      return *this;
    }
@@ -10,7 +10,6 @@
 #include <boost/thread/lock_algorithms.hpp>
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/lock_guard.hpp>
-#include <boost/thread/shared_lock_guard.hpp>
 #include <boost/thread/lockable_traits.hpp>
 #include <boost/thread/lock_options.hpp>

@@ -45,17 +45,9 @@ namespace boost
                m_.unlock();
                m=&m_;
            }
-            void deactivate()
+            ~lock_on_exit()
            {
-                if (m)
-                {
-                    m->lock();
-                }
-                m = 0;
-            }
-            ~lock_on_exit() BOOST_NOEXCEPT_IF(false)
-            {
-                if (m)
+                if(m)
                {
                    m->lock();
                }
@@ -76,20 +68,22 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
-            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
-            res = pthread_cond_wait(&cond,the_mutex);
-            check_for_interruption.check();
-            guard.deactivate();
+            do {
+              res = pthread_cond_wait(&cond,&internal_mutex);
+            } while (res == EINTR);
 #else
+            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-            res = pthread_cond_wait(&cond,the_mutex);
+            do {
+              res = pthread_cond_wait(&cond,the_mutex);
+            } while (res == EINTR);
 #endif
        }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        this_thread::interruption_point();
 #endif
-        if(res && res != EINTR)
+        if(res)
        {
            boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait"));
        }
@@ -105,17 +99,15 @@ namespace boost
            boost::throw_exception(condition_error(EPERM, "boost::condition_variable::do_wait_until() failed precondition mutex not owned"));
        }
 #endif
+        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
        int cond_res;
        {
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
-            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
-            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
-            check_for_interruption.check();
-            guard.deactivate();
+            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
 #else
+            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
 #endif
@@ -186,12 +178,10 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
 #else
-                boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
                guard.activate(m);
                res=pthread_cond_wait(&cond,&internal_mutex);
-                check_for_interruption.check();
-                guard.deactivate();
            }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            this_thread::interruption_point();
@@ -350,15 +340,14 @@ namespace boost
                                                   cv_status::timeout;
        }

-        template <class lock_type>
        inline cv_status wait_until(
-            lock_type& lock,
+            unique_lock<mutex>& lk,
            chrono::time_point<chrono::steady_clock, chrono::nanoseconds> tp)
        {
            using namespace chrono;
            nanoseconds d = tp.time_since_epoch();
            timespec ts = boost::detail::to_timespec(d);
-            if (do_wait_until(lock, ts)) return cv_status::no_timeout;
+            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
            else return cv_status::timeout;
        }

@@ -406,7 +395,7 @@ namespace boost
    private: // used by boost::thread::try_join_until

        template <class lock_type>
-        bool do_wait_until(
+        inline bool do_wait_until(
          lock_type& m,
          struct timespec const &timeout)
        {
@@ -416,12 +405,10 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
              detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
 #else
-              boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
              guard.activate(m);
              res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
-              check_for_interruption.check();
-              guard.deactivate();
          }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
          this_thread::interruption_point();
@@ -436,6 +423,8 @@ namespace boost
          }
          return true;
        }
+
+
    };

 }
@@ -17,7 +17,6 @@
 #if defined BOOST_THREAD_USES_DATETIME
 #include <boost/thread/xtime.hpp>
 #endif
-
 #ifdef BOOST_THREAD_USES_CHRONO
 #include <boost/chrono/system_clocks.hpp>
 #include <boost/chrono/ceil.hpp>
@@ -53,9 +52,9 @@ namespace boost
    class condition_variable
    {
    private:
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        pthread_mutex_t internal_mutex;
-//#endif
+#endif
        pthread_cond_t cond;

    public:
@@ -69,50 +68,38 @@ namespace boost
            unique_lock<mutex>& lock,
            struct timespec const &timeout)
        {
-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_monotonic()));
-#else
-            // old behavior was fine for monotonic
-            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_realtime()));
-#endif
+          return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now()));
        }

    public:
      BOOST_THREAD_NO_COPYABLE(condition_variable)
        condition_variable()
        {
-            int res;
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            // Even if it is not used, the internal_mutex exists (see
-            // above) and must be initialized (etc) in case some
-            // compilation units provide interruptions and others
-            // don't.
-            res=pthread_mutex_init(&internal_mutex,NULL);
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            int res=pthread_mutex_init(&internal_mutex,NULL);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
            }
-//#endif
+#endif
            res = detail::monotonic_pthread_cond_init(cond);
            if (res)
            {
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-                // ditto
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-//#endif
+#endif
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in detail::monotonic_pthread_cond_init"));
            }
        }
        ~condition_variable()
        {
            int ret;
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            // ditto
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            do {
              ret = pthread_mutex_destroy(&internal_mutex);
            } while (ret == EINTR);
            BOOST_ASSERT(!ret);
-//#endif
+#endif
            do {
              ret = pthread_cond_destroy(&cond);
            } while (ret == EINTR);
@@ -1,6 +1,6 @@
 #ifndef BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
 #define BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
-//  (C) Copyright 2007-8 Anthony Williams
+//  (C) Copyright 2007-8 Anthony Williams 
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -20,47 +20,41 @@ namespace boost
            pthread_mutex_t* m;
            bool locked;
        public:
-            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
+            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
                m(m_),locked(true)
            {
                BOOST_VERIFY(!pthread_mutex_lock(m));
            }
-            void unlock() BOOST_NOEXCEPT
+            void unlock()
            {
                BOOST_VERIFY(!pthread_mutex_unlock(m));
                locked=false;
            }
-            void check() BOOST_NOEXCEPT
-            {
-              if(locked)
-              {
-                  unlock();
-              }
-            }
-            ~pthread_mutex_scoped_lock() BOOST_NOEXCEPT
+            
+            ~pthread_mutex_scoped_lock()
            {
                if(locked)
                {
                    unlock();
                }
            }
-
+            
        };

        class pthread_mutex_scoped_unlock
        {
            pthread_mutex_t* m;
        public:
-            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
+            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
                m(m_)
            {
                BOOST_VERIFY(!pthread_mutex_unlock(m));
            }
-            ~pthread_mutex_scoped_unlock() BOOST_NOEXCEPT
+            ~pthread_mutex_scoped_unlock()
            {
                BOOST_VERIFY(!pthread_mutex_lock(m));
            }
-
+            
        };
    }
 }
@@ -20,6 +20,7 @@
 #include <boost/chrono/ceil.hpp>
 #endif
 #include <boost/thread/detail/delete.hpp>
+#include <boost/assert.hpp>

 #include <boost/config/abi_prefix.hpp>

@@ -268,13 +269,13 @@ namespace boost
                    // avoid other threads to lock, lock_upgrade or lock_shared, so only this thread is notified.
                    state.upgrade=false;
                    state.exclusive=true;
-                    //lk.unlock();
+                    lk.unlock();
                    upgrade_cond.notify_one();
                }
                else
                {
                    state.exclusive_waiting_blocked=false;
-                    //lk.unlock();
+                    lk.unlock();
                }
                release_waiters();
            }
@@ -13,7 +13,8 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/pthread/condition_variable_fwd.hpp>

-#include <boost/shared_ptr.hpp>
+//#include <boost/shared_ptr.hpp>
+#include <boost/thread/csbl/memory/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/assert.hpp>
 #ifdef BOOST_THREAD_USES_CHRONO
@@ -50,11 +51,7 @@ namespace boost
        // stack
        void set_stack_size(std::size_t size) BOOST_NOEXCEPT {
          if (size==0) return;
-#ifdef BOOST_THREAD_USES_GETPAGESIZE
          std::size_t page_size = getpagesize();
-#else
-          std::size_t page_size = ::sysconf( _SC_PAGESIZE);
-#endif
 #ifdef PTHREAD_STACK_MIN
          if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
 #endif
@@ -131,7 +128,7 @@ namespace boost
            > notify_list_t;
            notify_list_t notify;

-            typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
+            typedef std::vector<csbl::shared_ptr<shared_state_base> > async_states_t;
            async_states_t async_states_;

 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
@@ -166,7 +163,7 @@ namespace boost
              notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
            }

-            void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
+            void make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as)
            {
              async_states_.push_back(as);
            }
@@ -181,7 +178,6 @@ namespace boost
            thread_data_base* const thread_info;
            pthread_mutex_t* m;
            bool set;
-            bool done;

            void check_for_interruption()
            {
@@ -198,7 +194,7 @@ namespace boost
        public:
            explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
                thread_info(detail::get_current_thread_data()),m(cond_mutex),
-                set(thread_info && thread_info->interrupt_enabled), done(false)
+                set(thread_info && thread_info->interrupt_enabled)
            {
                if(set)
                {
@@ -213,10 +209,9 @@ namespace boost
                    BOOST_VERIFY(!pthread_mutex_lock(m));
                }
            }
-            void check()
+            ~interruption_checker()
            {
-              if ( ! done) {
-                if (set)
+                if(set)
                {
                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                    lock_guard<mutex> guard(thread_info->data_mutex);
@@ -227,13 +222,6 @@ namespace boost
                {
                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                }
-                done = true;
-              }
-            }
-
-            ~interruption_checker() BOOST_NOEXCEPT_IF(false)
-            {
-                check();
            }
        };
 #endif
@@ -241,42 +229,38 @@ namespace boost

    namespace this_thread
    {
-        namespace hidden
+        namespace hiden
        {
          void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-          void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts);
+          void BOOST_THREAD_DECL sleep_until(const timespec& ts);
        }

 #ifdef BOOST_THREAD_USES_CHRONO
-        template <class Rep, class Period>
-        void sleep_for(const chrono::duration<Rep, Period>& d);
 #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY

        inline
        void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
        {
-            return boost::this_thread::hidden::sleep_for(boost::detail::to_timespec(ns));
+            return boost::this_thread::hiden::sleep_for(boost::detail::to_timespec(ns));
        }
 #endif
 #endif // BOOST_THREAD_USES_CHRONO

        namespace no_interruption_point
        {
-          namespace hidden
+          namespace hiden
          {
            void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-            void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts);
+            void BOOST_THREAD_DECL sleep_until(const timespec& ts);
          }

    #ifdef BOOST_THREAD_USES_CHRONO
-          template <class Rep, class Period>
-          void sleep_for(const chrono::duration<Rep, Period>& d);
    #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY

          inline
          void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
          {
-              return boost::this_thread::no_interruption_point::hidden::sleep_for(boost::detail::to_timespec(ns));
+              return boost::this_thread::no_interruption_point::hiden::sleep_for(boost::detail::to_timespec(ns));
          }
    #endif
    #endif // BOOST_THREAD_USES_CHRONO
@@ -292,7 +276,7 @@ namespace boost
 #endif
        inline void sleep(system_time const& abs_time)
        {
-          return boost::this_thread::hidden::sleep_until_realtime(boost::detail::to_timespec(abs_time));
+          return boost::this_thread::hiden::sleep_until(boost::detail::to_timespec(abs_time));
        }

        template<typename TimeDuration>
@@ -16,13 +16,8 @@ namespace boost
        {
            return new T();
        }
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template<typename T,typename... Args>
-        inline T* heap_new(Args&&... args)
-        {
-            return new T(static_cast<Args&&>(args)...);
-        }
-#elif ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
        template<typename T,typename A1>
        inline T* heap_new(A1&& a1)
        {
@@ -66,31 +61,6 @@ namespace boost
        {
            return new T(a1,a2,a3,a4);
        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
-        {
-            return new T(a1,a2,a3,a4,a5);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
-        {
-            return new T(a1,a2,a3,a4,a5,a6);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
-        {
-            return new T(a1,a2,a3,a4,a5,a6,a7);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
-        {
-            return new T(a1,a2,a3,a4,a5,a6,a7,a8);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
-        {
-            return new T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
-        }

        template<typename T,typename A1>
        inline T* heap_new(A1 const& a1)
@@ -71,23 +71,7 @@ namespace boost
    {
      return (ts.tv_sec >= 0) || (ts.tv_nsec >= 0);
    }
-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
-    inline timespec timespec_now_monotonic()
-    {
-      timespec ts;
-
-      if ( ::clock_gettime( CLOCK_MONOTONIC, &ts ) )
-      {
-        ts.tv_sec = 0;
-        ts.tv_nsec = 0;
-        BOOST_ASSERT(0 && "Boost::Thread - Internal Error");
-      }
-      return ts;
-    }
-#endif
-
-    inline timespec timespec_now_realtime()
+    inline timespec timespec_now()
    {
      timespec ts;

@@ -99,8 +83,6 @@ namespace boost
 #else
      if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
      {
-        ts.tv_sec = 0;
-        ts.tv_nsec = 0;
        BOOST_ASSERT(0 && "Boost::Thread - Internal Error");
      }
 #endif
@@ -34,10 +34,10 @@ namespace boost
   *     boost::strict_scoped_thread<> t((boost::thread(F)));
   *
   */
-  template <class CallableThread = join_if_joinable, class Thread=::boost::thread>
+  template <class CallableThread = join_if_joinable>
  class strict_scoped_thread
  {
-    Thread t_;
+    thread t_;
    struct dummy;
  public:

@@ -47,13 +47,13 @@ namespace boost
     *
     */
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, Thread>, void* >::type>
+    template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type>
    explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args) :
      t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
 #else
    template <class F>
    explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f,
-        typename disable_if<is_same<typename decay<F>::type, Thread>, void* >::type=0) :
+        typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type=0) :
      t_(boost::forward<F>(f)) {}
    template <class F, class A1>
    strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
@@ -73,7 +73,7 @@ namespace boost
     *
     * Effects: move the thread to own @c t.
     */
-    explicit strict_scoped_thread(BOOST_THREAD_RV_REF(Thread) t) BOOST_NOEXCEPT :
+    explicit strict_scoped_thread(BOOST_THREAD_RV_REF(thread) t) BOOST_NOEXCEPT :
    t_(boost::move(t))
    {
    }
@@ -111,15 +111,14 @@ namespace boost
   *     t.interrupt();
   *
   */
-  template <class CallableThread = join_if_joinable, class Thread=::boost::thread>
+  template <class CallableThread = join_if_joinable>
  class scoped_thread
  {
-    Thread t_;
+    thread t_;
    struct dummy;
  public:

-    typedef typename Thread::id id;
-    typedef typename Thread::native_handle_type native_handle_type;
+    typedef thread::id id;

    BOOST_THREAD_MOVABLE_ONLY( scoped_thread) /// Movable only

@@ -138,13 +137,13 @@ namespace boost
     */

 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, Thread>, void* >::type>
+    template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type>
    explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args) :
      t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
 #else
    template <class F>
    explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f,
-        typename disable_if<is_same<typename decay<F>::type, Thread>, void* >::type=0) :
+        typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type=0) :
      t_(boost::forward<F>(f)) {}
    template <class F, class A1>
    scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
@@ -164,12 +163,12 @@ namespace boost
     *
     * Effects: move the thread to own @c t.
     */
-    explicit scoped_thread(BOOST_THREAD_RV_REF(Thread) t) BOOST_NOEXCEPT :
+    explicit scoped_thread(BOOST_THREAD_RV_REF(thread) t) BOOST_NOEXCEPT :
    t_(boost::move(t))
    {
    }

-//    explicit operator Thread()
+//    explicit operator thread()
 //    {
 //      return boost::move(t_);
 //    }
@@ -198,9 +197,6 @@ namespace boost
     */
    scoped_thread& operator=(BOOST_RV_REF(scoped_thread) x)
    {
-      CallableThread on_destructor;
-
-      on_destructor(t_);
      t_ = boost::move(BOOST_THREAD_RV(x).t_);
      return *this;
    }
@@ -214,7 +210,7 @@ namespace boost
    }

    // forwarded thread functions
-    inline id get_id() const BOOST_NOEXCEPT
+    inline thread::id get_id() const BOOST_NOEXCEPT
    {
      return t_.get_id();
    }
@@ -243,7 +239,7 @@ namespace boost
    }
 #endif

-    native_handle_type native_handle()BOOST_NOEXCEPT
+    thread::native_handle_type native_handle()BOOST_NOEXCEPT
    {
      return t_.native_handle();
    }
@@ -267,13 +263,13 @@ namespace boost

    static unsigned hardware_concurrency() BOOST_NOEXCEPT
    {
-      return Thread::hardware_concurrency();
+      return thread::hardware_concurrency();
    }

 #ifdef BOOST_THREAD_PROVIDES_PHYSICAL_CONCURRENCY
    static unsigned physical_concurrency() BOOST_NOEXCEPT
    {
-      return Thread::physical_concurrency();
+      return thread::physical_concurrency();
    }
 #endif
  };
@@ -281,13 +277,12 @@ namespace boost
  /**
   * Effects: swaps the contents of two scoped threads.
   */
-  template <class Destroyer, class Thread >
-  void swap(scoped_thread<Destroyer, Thread>& lhs, scoped_thread<Destroyer, Thread>& rhs)
+  template <class Destroyer>
+  void swap(scoped_thread<Destroyer>& lhs, scoped_thread<Destroyer>& rhs)
 BOOST_NOEXCEPT {
  return lhs.swap(rhs);
 }

-  typedef scoped_thread<> joining_thread;
 }
 #include <boost/config/abi_suffix.hpp>

@@ -827,7 +827,7 @@ namespace boost
     * @effects loads the value type from the input stream @c is.
     */
    template <typename IStream>
-    void load(IStream& is)
+    void load(IStream& is) const
    {
      strict_lock<mutex_type> lk(mtx_);
      is >> value_;
@@ -971,22 +971,22 @@ namespace boost
  template <typename T, typename L>
  bool operator<(T const& lhs, synchronized_value<T,L> const&rhs)
  {
-    return rhs>lhs;
+    return rhs>=lhs;
  }
  template <typename T, typename L>
  bool operator<=(T const& lhs, synchronized_value<T,L> const&rhs)
  {
-    return rhs>=lhs;
+    return rhs>lhs;
  }
  template <typename T, typename L>
  bool operator>(T const& lhs, synchronized_value<T,L> const&rhs)
  {
-    return rhs<lhs;
+    return rhs<=lhs;
  }
  template <typename T, typename L>
  bool operator>=(T const& lhs, synchronized_value<T,L> const&rhs)
  {
-    return rhs<=lhs;
+    return rhs<lhs;
  }

  /**
@@ -999,7 +999,7 @@ namespace boost
    return os;
  }
  template <typename IStream, typename T, typename L>
-  inline IStream& operator>>(IStream& is, synchronized_value<T,L>& rhs)
+  inline IStream& operator>>(IStream& is, synchronized_value<T,L> const& rhs)
  {
    rhs.load(is);
    return is;
@@ -21,29 +21,15 @@ namespace boost

  struct detach
  {
-    template <class Thread>
-    void operator()(Thread& t)
+    void operator()(thread& t)
    {
      t.detach();
    }
  };

-  struct detach_if_joinable
-  {
-    template <class Thread>
-    void operator()(Thread& t)
-    {
-      if (t.joinable())
-      {
-        t.detach();
-      }
-    }
-  };
-
  struct join_if_joinable
  {
-    template <class Thread>
-    void operator()(Thread& t)
+    void operator()(thread& t)
    {
      if (t.joinable())
      {
@@ -55,12 +41,11 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
  struct interrupt_and_join_if_joinable
  {
-    template <class Thread>
-    void operator()(Thread& t)
+    void operator()(thread& t)
    {
+      t.interrupt();
      if (t.joinable())
      {
-        t.interrupt();
        t.join();
      }
    }
@@ -21,14 +21,14 @@ namespace boost
  /**
   * Non-copyable RAII scoped thread guard joiner which join the thread if joinable when destroyed.
   */
-  template <class CallableThread = join_if_joinable, class Thread=::boost::thread>
+  template <class CallableThread = join_if_joinable>
  class thread_guard
  {
-    Thread& t_;
+    thread& t_;
  public:
    BOOST_THREAD_NO_COPYABLE( thread_guard)

-    explicit thread_guard(Thread& t) :
+    explicit thread_guard(thread& t) :
    t_(t)
    {
    }
@@ -23,7 +23,7 @@ namespace boost
  class user_scheduler
  {
    /// type-erasure to store the works to do
-    typedef  executors::work work;
+    typedef  thread_detail::work work;

    /// the thread safe work queue
    sync_queue<work > work_queue;
@@ -91,19 +91,7 @@ namespace boost
        cv.wait_until(lk, t);
    }

-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC && defined BOOST_CHRONO_HAS_CLOCK_STEADY
-    template <class Rep, class Period>
-    void sleep_for(const chrono::duration<Rep, Period>& d)
-    {
-      using namespace chrono;
-      if (d > duration<Rep, Period>::zero())
-      {
-        steady_clock::time_point c_timeout = steady_clock::now() + ceil<nanoseconds>(d);
-        sleep_until(c_timeout);
-      }
-    }
-
-#elif defined BOOST_THREAD_SLEEP_FOR_IS_STEADY
+#if defined BOOST_THREAD_SLEEP_FOR_IS_STEADY && ! defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC

    template <class Rep, class Period>
    void sleep_for(const chrono::duration<Rep, Period>& d)
@@ -139,8 +127,7 @@ namespace boost
      using namespace chrono;
      if (d > duration<Rep, Period>::zero())
      {
-        //system_clock::time_point c_timeout = time_point_cast<system_clock::duration>(system_clock::now() + ceil<nanoseconds>(d));
-        system_clock::time_point c_timeout = system_clock::now() + ceil<system_clock::duration>(d);
+        steady_clock::time_point c_timeout = steady_clock::now() + ceil<nanoseconds>(d);
        sleep_until(c_timeout);
      }
    }
@@ -44,13 +44,13 @@ namespace boost

            bool try_lock() BOOST_NOEXCEPT
            {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
            }

            void lock()
            {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                if(!try_recursive_lock(current_thread_id))
                {
                    mutex.lock();
@@ -61,7 +61,7 @@ namespace boost
 #if defined BOOST_THREAD_USES_DATETIME
            bool timed_lock(::boost::system_time const& target)
            {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
            }
            template<typename Duration>
@@ -75,13 +75,13 @@ namespace boost
        template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
        {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_timed_lock_for(current_thread_id,rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
        {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_timed_lock_until(current_thread_id,t);
        }
 #endif
@@ -55,7 +55,7 @@ namespace boost
 #endif
                if(old_event)
                {
-                    winapi::CloseHandle(old_event);
+                    win32::CloseHandle(old_event);
                }
            }

@@ -81,9 +81,9 @@ namespace boost

                    do
                    {
-                        unsigned const retval(winapi::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
+                        unsigned const retval(win32::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
                        BOOST_VERIFY(0 == retval || ::boost::detail::win32::wait_abandoned == retval);
-//                        BOOST_VERIFY(winapi::WaitForSingleObject(
+//                        BOOST_VERIFY(win32::WaitForSingleObject(
 //                                         sem,::boost::detail::win32::infinite)==0);
                        clear_waiting_and_try_lock(old_count);
                        lock_acquired=!(old_count&lock_flag_value);
@@ -142,7 +142,7 @@ namespace boost

                    do
                    {
-                        if(winapi::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
+                        if(win32::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
                        {
                            BOOST_INTERLOCKED_DECREMENT(&active_count);
                            return false;
@@ -210,7 +210,7 @@ namespace boost
                      }
                      chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-now);

-                      if(winapi::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
+                      if(win32::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
                      {
                          BOOST_INTERLOCKED_DECREMENT(&active_count);
                          return false;
@@ -232,7 +232,7 @@ namespace boost
                {
                    if(!win32::interlocked_bit_test_and_set(&active_count,event_set_flag_bit))
                    {
-                        winapi::SetEvent(get_event());
+                        win32::SetEvent(get_event());
                    }
                }
            }
@@ -256,7 +256,7 @@ namespace boost
 #endif
                    if(old_event!=0)
                    {
-                        winapi::CloseHandle(new_event);
+                        win32::CloseHandle(new_event);
                        return old_event;
                    }
                    else
@@ -76,7 +76,7 @@ namespace boost
            void release(unsigned count_to_release)
            {
                notified=true;
-                detail::winapi::ReleaseSemaphore(semaphore,count_to_release,0);
+                detail::win32::ReleaseSemaphore(semaphore,count_to_release,0);
            }

            void release_waiters()
@@ -96,7 +96,7 @@ namespace boost

            bool woken()
            {
-                unsigned long const woken_result=detail::winapi::WaitForSingleObjectEx(wake_sem,0,0);
+                unsigned long const woken_result=detail::win32::WaitForSingleObjectEx(wake_sem,0,0);
                BOOST_ASSERT((woken_result==detail::win32::timeout) || (woken_result==0));
                return woken_result==0;
            }
@@ -135,45 +135,39 @@ namespace boost
            void wake_waiters(long count_to_wake)
            {
                detail::interlocked_write_release(&total_count,total_count-count_to_wake);
-                detail::winapi::ReleaseSemaphore(wake_sem,count_to_wake,0);
+                detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
            }

            template<typename lock_type>
            struct relocker
            {
                BOOST_THREAD_NO_COPYABLE(relocker)
-                lock_type& _lock;
-                bool _unlocked;
+                lock_type& lock;
+                bool unlocked;

                relocker(lock_type& lock_):
-                    _lock(lock_), _unlocked(false)
+                    lock(lock_),unlocked(false)
                {}
                void unlock()
                {
-                  if ( ! _unlocked )
-                  {
-                    _lock.unlock();
-                    _unlocked=true;
-                  }
+                    lock.unlock();
+                    unlocked=true;
                }
-                void lock()
+                ~relocker()
                {
-                  if ( _unlocked )
-                  {
-                    _lock.lock();
-                    _unlocked=false;
-                  }
-                }
-                ~relocker() BOOST_NOEXCEPT_IF(false)
-                {
-                  lock();
+                    if(unlocked)
+                    {
+                        lock.lock();
+                    }
+
                }
            };


            entry_ptr get_wait_entry()
            {
-                boost::lock_guard<boost::mutex> lk(internal_mutex);
+                boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
+
                if(!wake_sem)
                {
                    wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
@@ -196,32 +190,18 @@ namespace boost

            struct entry_manager
            {
-                entry_ptr entry;
+                entry_ptr const entry;
                boost::mutex& internal_mutex;

-
                BOOST_THREAD_NO_COPYABLE(entry_manager)
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-                entry_manager(entry_ptr&& entry_, boost::mutex& mutex_):
-                    entry(static_cast< entry_ptr&& >(entry_)), internal_mutex(mutex_)
-                {}
-#else
                entry_manager(entry_ptr const& entry_, boost::mutex& mutex_):
                    entry(entry_), internal_mutex(mutex_)
                {}
-#endif

-                void remove_waiter_and_reset()
+                ~entry_manager()
                {
-                  if (entry) {
                    boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
                    entry->remove_waiter();
-                    entry.reset();
-                  }
-                }
-                ~entry_manager() BOOST_NOEXCEPT_IF(false)
-                {
-                  remove_waiter_and_reset();
                }

                list_entry* operator->()
@@ -235,24 +215,23 @@ namespace boost
            template<typename lock_type>
            bool do_wait(lock_type& lock,timeout abs_time)
            {
-              relocker<lock_type> locker(lock);
-              entry_manager entry(get_wait_entry(), internal_mutex);
-              locker.unlock();
+                relocker<lock_type> locker(lock);

-              bool woken=false;
-              while(!woken)
-              {
-                  if(!entry->wait(abs_time))
-                  {
-                      return false;
-                  }
+                entry_manager entry(get_wait_entry(), internal_mutex);

-                  woken=entry->woken();
-              }
-              // do it here to avoid throwing on the destructor
-              entry.remove_waiter_and_reset();
-              locker.lock();
-              return woken;
+                locker.unlock();
+
+                bool woken=false;
+                while(!woken)
+                {
+                    if(!entry->wait(abs_time))
+                    {
+                        return false;
+                    }
+
+                    woken=entry->woken();
+                }
+                return woken;
            }

            template<typename lock_type,typename predicate_type>
@@ -5,7 +5,6 @@
 //
 //  (C) Copyright 2005-8 Anthony Williams
 //  (C) Copyright 2012 Vicente J. Botet Escriba
-//  (C) Copyright 2017 Andrey Semashev
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -16,172 +15,36 @@

 #include <boost/config/abi_prefix.hpp>

-// Define compiler barriers
-#if defined(__INTEL_COMPILER)
-#define BOOST_THREAD_DETAIL_COMPILER_BARRIER() __memory_barrier()
-#elif defined(_MSC_VER) && !defined(_WIN32_WCE)
-extern "C" void _ReadWriteBarrier(void);
-#pragma intrinsic(_ReadWriteBarrier)
-#define BOOST_THREAD_DETAIL_COMPILER_BARRIER() _ReadWriteBarrier()
-#endif
-
-#ifndef BOOST_THREAD_DETAIL_COMPILER_BARRIER
-#define BOOST_THREAD_DETAIL_COMPILER_BARRIER()
-#endif
-
-#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
-
-// Since VS2005 and until VS2012 volatile reads always acquire and volatile writes are always release.
-// But VS2012 adds a compiler switch that can change behavior to the standard. On x86 though
-// the compiler generates a single instruction for the load/store, which is enough synchronization
-// as far as uarch is concerned. To prevent compiler reordering code around the load/store we add
-// compiler barriers.
+#ifdef BOOST_MSVC

 namespace boost
 {
    namespace detail
    {
+        // Since VS2005 volatile reads always acquire
        inline long interlocked_read_acquire(long volatile* x) BOOST_NOEXCEPT
        {
            long const res=*x;
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
            return res;
        }
        inline void* interlocked_read_acquire(void* volatile* x) BOOST_NOEXCEPT
        {
            void* const res=*x;
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
            return res;
        }

+        // Since VS2005 volatile writes always release
        inline void interlocked_write_release(long volatile* x,long value) BOOST_NOEXCEPT
        {
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
            *x=value;
        }
        inline void interlocked_write_release(void* volatile* x,void* value) BOOST_NOEXCEPT
        {
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
            *x=value;
        }
    }
 }

-#elif defined(_MSC_VER) && _MSC_VER >= 1700 && (defined(_M_ARM) || defined(_M_ARM64))
-
-#include <intrin.h>
-
-namespace boost
-{
-    namespace detail
-    {
-        inline long interlocked_read_acquire(long volatile* x) BOOST_NOEXCEPT
-        {
-            long const res=__iso_volatile_load32((const volatile __int32*)x);
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-            __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-            return res;
-        }
-        inline void* interlocked_read_acquire(void* volatile* x) BOOST_NOEXCEPT
-        {
-            void* const res=
-#if defined(_M_ARM64)
-                __iso_volatile_load64((const volatile __int64*)x);
-#else
-                __iso_volatile_load32((const volatile __int32*)x);
-#endif
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-            __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-            return res;
-        }
-
-        inline void interlocked_write_release(long volatile* x,long value) BOOST_NOEXCEPT
-        {
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-            __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-            __iso_volatile_store32((volatile __int32*)x, (__int32)value);
-        }
-        inline void interlocked_write_release(void* volatile* x,void* value) BOOST_NOEXCEPT
-        {
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-            __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later
-            BOOST_THREAD_DETAIL_COMPILER_BARRIER();
-#if defined(_M_ARM64)
-            __iso_volatile_store64((volatile __int64*)x, (__int64)value);
-#else
-            __iso_volatile_store32((volatile __int32*)x, (__int32)value);
-#endif
-        }
-    }
-}
-
-#elif defined(__GNUC__) && (((__GNUC__ * 100 + __GNUC_MINOR__) >= 407) || (defined(__clang__) && (__clang_major__ * 100 + __clang_minor__) >= 302))
-
-namespace boost
-{
-    namespace detail
-    {
-        inline long interlocked_read_acquire(long volatile* x) BOOST_NOEXCEPT
-        {
-            return __atomic_load_n((long*)x, __ATOMIC_ACQUIRE);
-        }
-        inline void* interlocked_read_acquire(void* volatile* x) BOOST_NOEXCEPT
-        {
-            return __atomic_load_n((void**)x, __ATOMIC_ACQUIRE);
-        }
-
-        inline void interlocked_write_release(long volatile* x,long value) BOOST_NOEXCEPT
-        {
-            __atomic_store_n((long*)x, value, __ATOMIC_RELEASE);
-        }
-        inline void interlocked_write_release(void* volatile* x,void* value) BOOST_NOEXCEPT
-        {
-            __atomic_store_n((void**)x, value, __ATOMIC_RELEASE);
-        }
-    }
-}
-
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-
-namespace boost
-{
-    namespace detail
-    {
-        inline long interlocked_read_acquire(long volatile* x) BOOST_NOEXCEPT
-        {
-            long res;
-            __asm__ __volatile__ ("movl %1, %0" : "=r" (res) : "m" (*x) : "memory");
-            return res;
-        }
-        inline void* interlocked_read_acquire(void* volatile* x) BOOST_NOEXCEPT
-        {
-            void* res;
-#if defined(__x86_64__)
-            __asm__ __volatile__ ("movq %1, %0" : "=r" (res) : "m" (*x) : "memory");
-#else
-            __asm__ __volatile__ ("movl %1, %0" : "=r" (res) : "m" (*x) : "memory");
-#endif
-            return res;
-        }
-
-        inline void interlocked_write_release(long volatile* x,long value) BOOST_NOEXCEPT
-        {
-            __asm__ __volatile__ ("movl %1, %0" : "=m" (*x) : "r" (value) : "memory");
-        }
-        inline void interlocked_write_release(void* volatile* x,void* value) BOOST_NOEXCEPT
-        {
-#if defined(__x86_64__)
-            __asm__ __volatile__ ("movq %1, %0" : "=m" (*x) : "r" (value) : "memory");
-#else
-            __asm__ __volatile__ ("movl %1, %0" : "=m" (*x) : "r" (value) : "memory");
-#endif
-        }
-    }
-}
-
 #else

 namespace boost
@@ -190,19 +53,19 @@ namespace boost
    {
        inline long interlocked_read_acquire(long volatile* x) BOOST_NOEXCEPT
        {
-            return BOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)x,0,0);
+            return BOOST_INTERLOCKED_COMPARE_EXCHANGE(x,0,0);
        }
        inline void* interlocked_read_acquire(void* volatile* x) BOOST_NOEXCEPT
        {
-            return BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER((void**)x,0,0);
+            return BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(x,0,0);
        }
        inline void interlocked_write_release(long volatile* x,long value) BOOST_NOEXCEPT
        {
-            BOOST_INTERLOCKED_EXCHANGE((long*)x,value);
+            BOOST_INTERLOCKED_EXCHANGE(x,value);
        }
        inline void interlocked_write_release(void* volatile* x,void* value) BOOST_NOEXCEPT
        {
-            BOOST_INTERLOCKED_EXCHANGE_POINTER((void**)x,value);
+            BOOST_INTERLOCKED_EXCHANGE_POINTER(x,value);
        }
    }
 }
@@ -124,7 +124,7 @@ namespace boost
            std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
            detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address),
                                  mutex_name + once_mutex_name_fixed_length);
-            detail::int_to_string(winapi::GetCurrentProcessId(),
+            detail::int_to_string(win32::GetCurrentProcessId(),
                                  mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
        }

@@ -136,9 +136,9 @@ namespace boost
            }

 #ifdef BOOST_NO_ANSI_APIS
-            return ::boost::detail::winapi::OpenEventW(
+            return ::boost::detail::win32::OpenEventW(
 #else
-            return ::boost::detail::winapi::OpenEventA(
+            return ::boost::detail::win32::OpenEventA(
 #endif
                ::boost::detail::win32::synchronize |
                ::boost::detail::win32::event_modify_state,
@@ -186,7 +186,7 @@ namespace boost
            }
            if(ctx.event_handle)
            {
-                ::boost::detail::winapi::ResetEvent(ctx.event_handle);
+                ::boost::detail::win32::ResetEvent(ctx.event_handle);
            }
            return true;
          }
@@ -207,7 +207,7 @@ namespace boost
          }
          if(ctx.event_handle)
          {
-              ::boost::detail::winapi::SetEvent(ctx.event_handle);
+              ::boost::detail::win32::SetEvent(ctx.event_handle);
          }
        }
        inline void rollback_once_region(once_flag& flag, once_context& ctx) BOOST_NOEXCEPT
@@ -219,7 +219,7 @@ namespace boost
          }
          if(ctx.event_handle)
          {
-              ::boost::detail::winapi::SetEvent(ctx.event_handle);
+              ::boost::detail::win32::SetEvent(ctx.event_handle);
          }
        }
    }
@@ -264,7 +264,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite, 0));
        }
    }
@@ -308,7 +308,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -355,7 +355,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -400,7 +400,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -443,7 +443,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -486,7 +486,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -529,7 +529,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -574,7 +574,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -617,7 +617,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -660,7 +660,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -703,7 +703,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -748,7 +748,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -793,7 +793,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -839,7 +839,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -886,7 +886,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -930,7 +930,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -977,7 +977,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -1024,7 +1024,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -1073,7 +1073,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -67,19 +67,19 @@ namespace boost
        {
            if(old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
            }

            if(old_state.shared_waiting || old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
            }
        }
        void release_shared_waiters(state_data old_state)
        {
            if(old_state.shared_waiting || old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
            }
        }

@@ -107,9 +107,9 @@ namespace boost

        ~shared_mutex()
        {
-            detail::winapi::CloseHandle(upgrade_sem);
-            detail::winapi::CloseHandle(semaphores[unlock_sem]);
-            detail::winapi::CloseHandle(semaphores[exclusive_sem]);
+            detail::win32::CloseHandle(upgrade_sem);
+            detail::win32::CloseHandle(semaphores[unlock_sem]);
+            detail::win32::CloseHandle(semaphores[exclusive_sem]);
        }

        bool try_lock_shared()
@@ -191,7 +191,7 @@ namespace boost
                    return true;
                }

-                unsigned long const res=detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
                if(res==detail::win32::timeout)
                {
                    for(;;)
@@ -296,7 +296,7 @@ namespace boost
            unsigned long res;
            if (tp>n) {
              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-n);
-              res=detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],
+              res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],
                static_cast<unsigned long>(rel_time.count()), 0);
            } else {
              res=detail::win32::timeout;
@@ -375,7 +375,7 @@ namespace boost
                    {
                        if(old_state.upgrade)
                        {
-                            BOOST_VERIFY(detail::winapi::ReleaseSemaphore(upgrade_sem,1,0)!=0);
+                            BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
                        }
                        else
                        {
@@ -474,7 +474,7 @@ namespace boost
                #else
                const bool wait_all = false;
                #endif
-                unsigned long const wait_res=detail::winapi::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
                if(wait_res==detail::win32::timeout)
                {
                    for(;;)
@@ -500,7 +500,7 @@ namespace boost
                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                        if (must_notify)
                        {
-                          BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                          BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
                        }

                        if(current_state==old_state)
@@ -586,7 +586,7 @@ namespace boost
            unsigned long wait_res;
            if (tp>n) {
              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
-              wait_res=detail::winapi::WaitForMultipleObjectsEx(2,semaphores,wait_all,
+              wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,
                  static_cast<unsigned long>(rel_time.count()), 0);
            } else {
              wait_res=detail::win32::timeout;
@@ -616,7 +616,7 @@ namespace boost
                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                if (must_notify)
                {
-                  BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                  BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
                }
                if(current_state==old_state)
                {
@@ -698,7 +698,7 @@ namespace boost
                    return;
                }

-                BOOST_VERIFY(!detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],detail::winapi::infinite, 0));
+                BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],detail::win32::infinite, 0));
            }
        }

@@ -790,7 +790,7 @@ namespace boost
                {
                    if(!last_reader)
                    {
-                        BOOST_VERIFY(!detail::winapi::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
+                        BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
                    }
                    break;
                }
@@ -153,7 +153,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            void interrupt()
            {
-                BOOST_VERIFY(detail::winapi::SetEvent(interruption_handle)!=0);
+                BOOST_VERIFY(detail::win32::SetEvent(interruption_handle)!=0);
            }
 #endif
            typedef detail::win32::handle native_handle_type;
@@ -12,7 +12,45 @@
 #include <boost/throw_exception.hpp>
 #include <boost/core/no_exceptions_support.hpp>

-#include <boost/detail/winapi/heap_memory.hpp>
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            using ::GetProcessHeap;
+            using ::HeapAlloc;
+            using ::HeapFree;
+        }
+    }
+}
+
+#else
+
+# ifdef HeapAlloc
+# undef HeapAlloc
+# endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            extern "C"
+            {
+                __declspec(dllimport) handle __stdcall GetProcessHeap();
+                __declspec(dllimport) void* __stdcall HeapAlloc(handle,unsigned long,ulong_ptr);
+                __declspec(dllimport) int __stdcall HeapFree(handle,unsigned long,void*);
+            }
+        }
+    }
+}
+
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -22,7 +60,7 @@ namespace boost
    {
        inline void* allocate_raw_heap_memory(unsigned size)
        {
-            void* const heap_memory=detail::winapi::HeapAlloc(detail::winapi::GetProcessHeap(),0,size);
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size);
            if(!heap_memory)
            {
                boost::throw_exception(std::bad_alloc());
@@ -32,26 +70,9 @@ namespace boost

        inline void free_raw_heap_memory(void* heap_memory)
        {
-            BOOST_VERIFY(detail::winapi::HeapFree(detail::winapi::GetProcessHeap(),0,heap_memory)!=0);
+            BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
        }
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template<typename T,typename... Args>
-        inline T* heap_new(Args&&... args)
-        {
-          void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-          BOOST_TRY
-          {
-              T* const data=new (heap_memory) T(static_cast<Args&&>(args)...);
-              return data;
-          }
-          BOOST_CATCH(...)
-          {
-              free_raw_heap_memory(heap_memory);
-              BOOST_RETHROW
-          }
-          BOOST_CATCH_END
-        }
-#else
+
        template<typename T>
        inline T* heap_new()
        {
@@ -204,86 +225,6 @@ namespace boost
            }
            BOOST_CATCH_END
        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }


        template<typename T,typename A1>
@@ -443,7 +384,6 @@ namespace boost
            return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
        }

-#endif
 #endif
        template<typename T>
        inline void heap_delete(T* data)
@@ -16,53 +16,207 @@
 #include <boost/assert.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/detail/interlocked.hpp>
-#include <boost/detail/winapi/config.hpp>
-
-#include <boost/detail/winapi/semaphore.hpp>
-#include <boost/detail/winapi/dll.hpp>
-#include <boost/detail/winapi/system.hpp>
-#include <boost/detail/winapi/time.hpp>
-#include <boost/detail/winapi/event.hpp>
-#include <boost/detail/winapi/thread.hpp>
-#include <boost/detail/winapi/get_current_thread.hpp>
-#include <boost/detail/winapi/get_current_thread_id.hpp>
-#include <boost/detail/winapi/get_current_process.hpp>
-#include <boost/detail/winapi/get_current_process_id.hpp>
-#include <boost/detail/winapi/wait.hpp>
-#include <boost/detail/winapi/handles.hpp>
-#include <boost/detail/winapi/access_rights.hpp>
-
 //#include <boost/detail/winapi/synchronization.hpp>
-#include <boost/thread/win32/interlocked_read.hpp>
 #include <algorithm>

 #if BOOST_PLAT_WINDOWS_RUNTIME
 #include <thread>
 #endif

+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            typedef HANDLE handle;
+            typedef SYSTEM_INFO system_info;
+            typedef unsigned __int64 ticks_type;
+            typedef FARPROC farproc_t;
+            unsigned const infinite=INFINITE;
+            unsigned const timeout=WAIT_TIMEOUT;
+            handle const invalid_handle_value=INVALID_HANDLE_VALUE;
+            unsigned const event_modify_state=EVENT_MODIFY_STATE;
+            unsigned const synchronize=SYNCHRONIZE;
+            unsigned const wait_abandoned=WAIT_ABANDONED;
+            unsigned const create_event_initial_set = 0x00000002;
+            unsigned const create_event_manual_reset = 0x00000001;
+            unsigned const event_all_access = EVENT_ALL_ACCESS;
+            unsigned const semaphore_all_access = SEMAPHORE_ALL_ACCESS;
+
+
+# ifdef BOOST_NO_ANSI_APIS
+# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+            using ::CreateMutexW;
+            using ::CreateEventW;
+            using ::CreateSemaphoreW;
+# else
+            using ::CreateMutexExW;
+            using ::CreateEventExW;
+            using ::CreateSemaphoreExW;
+# endif
+            using ::OpenEventW;
+            using ::GetModuleHandleW;
+# else
+            using ::CreateMutexA;
+            using ::CreateEventA;
+            using ::OpenEventA;
+            using ::CreateSemaphoreA;
+            using ::GetModuleHandleA;
+# endif
+#if BOOST_PLAT_WINDOWS_RUNTIME
+            using ::GetNativeSystemInfo;
+            using ::GetTickCount64;
+#else
+            using ::GetSystemInfo;
+            using ::GetTickCount;
+#endif
+            using ::CloseHandle;
+            using ::ReleaseMutex;
+            using ::ReleaseSemaphore;
+            using ::SetEvent;
+            using ::ResetEvent;
+            using ::WaitForMultipleObjectsEx;
+            using ::WaitForSingleObjectEx;
+            using ::GetCurrentProcessId;
+            using ::GetCurrentThreadId;
+            using ::GetCurrentThread;
+            using ::GetCurrentProcess;
+            using ::DuplicateHandle;
+#if !BOOST_PLAT_WINDOWS_RUNTIME
+            using ::SleepEx;
+            using ::Sleep;
+            using ::QueueUserAPC;
+            using ::GetProcAddress;
+#endif
+        }
+    }
+}
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+
+# ifdef UNDER_CE
+#  ifndef WINAPI
+#   ifndef _WIN32_WCE_EMULATION
+#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
+#   else
+#    define WINAPI  __stdcall
+#   endif
+#  endif
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+typedef int BOOL;
+typedef unsigned long DWORD;
+typedef void* HANDLE;
+#  include <kfuncs.h>
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+struct _SYSTEM_INFO;
+# ifdef __cplusplus
+}
+#endif
+
 namespace boost
 {
    namespace detail
    {
        namespace win32
        {
-            typedef ::boost::detail::winapi::HANDLE_ handle;
-            typedef ::boost::detail::winapi::SYSTEM_INFO_ system_info;
+# ifdef _WIN64
+            typedef unsigned __int64 ulong_ptr;
+# else
+            typedef unsigned long ulong_ptr;
+# endif
+            typedef void* handle;
+            typedef _SYSTEM_INFO system_info;
            typedef unsigned __int64 ticks_type;
-            typedef ::boost::detail::winapi::FARPROC_ farproc_t;
-            unsigned const infinite=::boost::detail::winapi::INFINITE_;
-            unsigned const timeout=::boost::detail::winapi::WAIT_TIMEOUT_;
-            handle const invalid_handle_value=::boost::detail::winapi::INVALID_HANDLE_VALUE_;
-            unsigned const event_modify_state=::boost::detail::winapi::EVENT_MODIFY_STATE_;
-            unsigned const synchronize=::boost::detail::winapi::SYNCHRONIZE_;
-            unsigned const wait_abandoned=::boost::detail::winapi::WAIT_ABANDONED_;
+            typedef int (__stdcall *farproc_t)();
+            unsigned const infinite=~0U;
+            unsigned const timeout=258U;
+            handle const invalid_handle_value=(handle)(-1);
+            unsigned const event_modify_state=2;
+            unsigned const synchronize=0x100000u;
+            unsigned const wait_abandoned=0x00000080u;
            unsigned const create_event_initial_set = 0x00000002;
            unsigned const create_event_manual_reset = 0x00000001;
-            unsigned const event_all_access = ::boost::detail::winapi::EVENT_ALL_ACCESS_;
-            unsigned const semaphore_all_access = boost::detail::winapi::SEMAPHORE_ALL_ACCESS_;
+            unsigned const event_all_access = 0x1F0003;
+            unsigned const semaphore_all_access = 0x1F0003;
+
+            extern "C"
+            {
+                struct _SECURITY_ATTRIBUTES;
+# ifdef BOOST_NO_ANSI_APIS
+# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+                __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+# else
+                __declspec(dllimport) void* __stdcall CreateMutexExW(_SECURITY_ATTRIBUTES*,wchar_t const*,unsigned long,unsigned long);
+                __declspec(dllimport) void* __stdcall CreateEventExW(_SECURITY_ATTRIBUTES*,wchar_t const*,unsigned long,unsigned long);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreExW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*,unsigned long,unsigned long);
+# endif
+                __declspec(dllimport) void* __stdcall OpenEventW(unsigned long,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall GetModuleHandleW(wchar_t const*);
+# else
+                __declspec(dllimport) void* __stdcall CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
+                __declspec(dllimport) void* __stdcall CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+                __declspec(dllimport) void* __stdcall OpenEventA(unsigned long,int,char const*);
+                __declspec(dllimport) void* __stdcall GetModuleHandleA(char const*);
+# endif
+#if BOOST_PLAT_WINDOWS_RUNTIME
+                __declspec(dllimport) void __stdcall GetNativeSystemInfo(_SYSTEM_INFO*);
+                __declspec(dllimport) ticks_type __stdcall GetTickCount64();
+#else
+                __declspec(dllimport) void __stdcall GetSystemInfo(_SYSTEM_INFO*);
+                __declspec(dllimport) unsigned long __stdcall GetTickCount();
+#endif
+                __declspec(dllimport) int __stdcall CloseHandle(void*);
+                __declspec(dllimport) int __stdcall ReleaseMutex(void*);
+                __declspec(dllimport) unsigned long __stdcall WaitForSingleObjectEx(void*,unsigned long,int);
+                __declspec(dllimport) unsigned long __stdcall WaitForMultipleObjectsEx(unsigned long nCount,void* const * lpHandles,int bWaitAll,unsigned long dwMilliseconds,int bAlertable);
+                __declspec(dllimport) int __stdcall ReleaseSemaphore(void*,long,long*);
+                __declspec(dllimport) int __stdcall DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long);
+#if !BOOST_PLAT_WINDOWS_RUNTIME
+                __declspec(dllimport) unsigned long __stdcall SleepEx(unsigned long,int);
+                __declspec(dllimport) void __stdcall Sleep(unsigned long);
+                typedef void (__stdcall *queue_user_apc_callback_function)(ulong_ptr);
+                __declspec(dllimport) unsigned long __stdcall QueueUserAPC(queue_user_apc_callback_function,void*,ulong_ptr);
+                __declspec(dllimport) farproc_t __stdcall GetProcAddress(void *, const char *);
+#endif
+
+# ifndef UNDER_CE
+                __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
+                __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
+                __declspec(dllimport) void* __stdcall GetCurrentThread();
+                __declspec(dllimport) void* __stdcall GetCurrentProcess();
+                __declspec(dllimport) int __stdcall SetEvent(void*);
+                __declspec(dllimport) int __stdcall ResetEvent(void*);
+# else
+                using ::GetCurrentProcessId;
+                using ::GetCurrentThreadId;
+                using ::GetCurrentThread;
+                using ::GetCurrentProcess;
+                using ::SetEvent;
+                using ::ResetEvent;
+# endif
+            }
        }
    }
 }
+#else
+# error "Win32 functions not available"
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -89,19 +243,19 @@ namespace boost
            // Borrowed from https://stackoverflow.com/questions/8211820/userland-interrupt-timer-access-such-as-via-kequeryinterrupttime-or-similar
            inline ticks_type __stdcall GetTickCount64emulation()
            {
-                static long count = -1l;
+                static volatile long count = 0xFFFFFFFF;
                unsigned long previous_count, current_tick32, previous_count_zone, current_tick32_zone;
                ticks_type current_tick64;

-                previous_count = (unsigned long) boost::detail::interlocked_read_acquire(&count);
-                current_tick32 = ::boost::detail::winapi::GetTickCount();
+                previous_count = (unsigned long) _InterlockedCompareExchange(&count, 0, 0);
+                current_tick32 = GetTickCount();

-                if(previous_count == (unsigned long)-1l)
+                if(previous_count == 0xFFFFFFFF)
                {
                    // count has never been written
                    unsigned long initial_count;
                    initial_count = current_tick32 >> 28;
-                    previous_count = (unsigned long) _InterlockedCompareExchange(&count, (long)initial_count, -1l);
+                    previous_count = (unsigned long) _InterlockedCompareExchange(&count, initial_count, 0xFFFFFFFF);

                    current_tick64 = initial_count;
                    current_tick64 <<= 28;
@@ -124,9 +278,8 @@ namespace boost
                if(current_tick32_zone == previous_count_zone + 1 || (current_tick32_zone == 0 && previous_count_zone == 15))
                {
                    // The top four bits of the 32-bit tick count have been incremented since count was last written.
-                    unsigned long new_count = previous_count + 1;
-                    _InterlockedCompareExchange(&count, (long)new_count, (long)previous_count);
-                    current_tick64 = new_count;
+                    _InterlockedCompareExchange(&count, previous_count + 1, previous_count);
+                    current_tick64 = previous_count + 1;
                    current_tick64 <<= 28;
                    current_tick64 += current_tick32 & 0x0FFFFFFF;
                    return current_tick64;
@@ -146,13 +299,13 @@ namespace boost
                // GetTickCount and GetModuleHandle are not allowed in the Windows Runtime,
                // and kernel32 isn't used in Windows Phone.
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                gettickcount64impl = &::boost::detail::winapi::GetTickCount64;
+                gettickcount64impl = &GetTickCount64;
 #else
                farproc_t addr=GetProcAddress(
 #if !defined(BOOST_NO_ANSI_APIS)
-                    ::boost::detail::winapi::GetModuleHandleA("KERNEL32.DLL"),
+                    GetModuleHandleA("KERNEL32.DLL"),
 #else
-                    ::boost::detail::winapi::GetModuleHandleW(L"KERNEL32.DLL"),
+                    GetModuleHandleW(L"KERNEL32.DLL"),
 #endif
                    "GetTickCount64");
                if(addr)
@@ -185,11 +338,11 @@ namespace boost
                initial_event_state state)
            {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res = ::boost::detail::winapi::CreateEventA(0, type, state, mutex_name);
+                handle const res = win32::CreateEventA(0, type, state, mutex_name);
 #elif BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res = ::boost::detail::winapi::CreateEventW(0, type, state, mutex_name);
+                handle const res = win32::CreateEventW(0, type, state, mutex_name);
 #else
-                handle const res = ::boost::detail::winapi::CreateEventExW(
+                handle const res = win32::CreateEventExW(
                    0,
                    mutex_name,
                    type ? create_event_manual_reset : 0 | state ? create_event_initial_set : 0,
@@ -211,12 +364,12 @@ namespace boost
            inline handle create_anonymous_semaphore_nothrow(long initial_count,long max_count)
            {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res=::boost::detail::winapi::CreateSemaphoreA(0,initial_count,max_count,0);
+                handle const res=win32::CreateSemaphoreA(0,initial_count,max_count,0);
 #else
 #if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res=::boost::detail::winapi::CreateSemaphoreEx(0,initial_count,max_count,0,0);
+                handle const res=win32::CreateSemaphoreEx(0,initial_count,max_count,0,0);
 #else
-                handle const res=::boost::detail::winapi::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
+                handle const res=win32::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
 #endif
 #endif
                return res;
@@ -234,10 +387,10 @@ namespace boost

            inline handle duplicate_handle(handle source)
            {
-                handle const current_process=::boost::detail::winapi::GetCurrentProcess();
+                handle const current_process=GetCurrentProcess();
                long const same_access_flag=2;
                handle new_handle=0;
-                bool const success=::boost::detail::winapi::DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
+                bool const success=DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
                if(!success)
                {
                    boost::throw_exception(thread_resource_error());
@@ -247,15 +400,15 @@ namespace boost

            inline void release_semaphore(handle semaphore,long count)
            {
-                BOOST_VERIFY(::boost::detail::winapi::ReleaseSemaphore(semaphore,count,0)!=0);
+                BOOST_VERIFY(ReleaseSemaphore(semaphore,count,0)!=0);
            }

            inline void get_system_info(system_info *info)
            {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                ::boost::detail::winapi::GetNativeSystemInfo(info);
+                win32::GetNativeSystemInfo(info);
 #else
-                ::boost::detail::winapi::GetSystemInfo(info);
+                win32::GetSystemInfo(info);
 #endif
            }

@@ -266,15 +419,15 @@ namespace boost
 #if BOOST_PLAT_WINDOWS_RUNTIME
                    std::this_thread::yield();
 #else
-                    ::boost::detail::winapi::Sleep(0);
+                    ::boost::detail::win32::Sleep(0);
 #endif
                }
                else
                {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                    ::boost::detail::winapi::WaitForSingleObjectEx(::boost::detail::winapi::GetCurrentThread(), milliseconds, 0);
+                    ::boost::detail::win32::WaitForSingleObjectEx(::boost::detail::win32::GetCurrentThread(), milliseconds, 0);
 #else
-                    ::boost::detail::winapi::Sleep(milliseconds);
+                    ::boost::detail::win32::Sleep(milliseconds);
 #endif
                }
            }
@@ -290,7 +443,7 @@ namespace boost
                {
                    if (m_completionHandle != ::boost::detail::win32::invalid_handle_value)
                    {
-                        ::boost::detail::winapi::CloseHandle(m_completionHandle);
+                        CloseHandle(m_completionHandle);
                    }
                }

@@ -318,7 +471,7 @@ namespace boost
                {
                    if(handle_to_manage && handle_to_manage!=invalid_handle_value)
                    {
-                        BOOST_VERIFY(::boost::detail::winapi::CloseHandle(handle_to_manage));
+                        BOOST_VERIFY(CloseHandle(handle_to_manage));
                    }
                }

@@ -42,7 +42,6 @@ namespace boost
                }
            }

-#if defined BOOST_THREAD_PATCH
            const pthread_once_t pthread_once_init_value=PTHREAD_ONCE_INIT;
            struct BOOST_THREAD_DECL delete_epoch_tss_key_on_dlclose_t
            {
@@ -53,15 +52,11 @@ namespace boost
                {
                    if(memcmp(&epoch_tss_key_flag, &pthread_once_init_value, sizeof(pthread_once_t)))
                    {
-                        void* data = pthread_getspecific(epoch_tss_key);
-                        if (data)
-                            delete_epoch_tss_data(data);
                        pthread_key_delete(epoch_tss_key);
                    }
                }
            };
            delete_epoch_tss_key_on_dlclose_t delete_epoch_tss_key_on_dlclose;
-#endif
        }

        uintmax_atomic_t& get_once_per_thread_epoch()
@@ -52,7 +52,7 @@ namespace boost
            for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                    i != e; ++i)
            {
-                (*i)->notify_deferred();
+                (*i)->make_ready();
            }
        }

@@ -80,8 +80,8 @@ namespace boost
            {
                static void tls_destructor(void* data)
                {
-                    //boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
-                    boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(data)->shared_from_this();
+                    boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
+                    //boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(data)->shared_from_this();

                    if(thread_info)
                    {
@@ -110,12 +110,14 @@ namespace boost
                                thread_info->tss_data.erase(current);
                            }
                        }
-                        thread_info->self.reset();
+                        if (thread_info) // fixme: should we test this?
+                        {
+                          thread_info->self.reset();
+                        }
                    }
                }
            }

-#if defined BOOST_THREAD_PATCH
            struct  delete_current_thread_tls_key_on_dlclose_t
            {
                delete_current_thread_tls_key_on_dlclose_t()
@@ -126,15 +128,12 @@ namespace boost
                    const boost::once_flag uninitialized = BOOST_ONCE_INIT;
                    if (memcmp(&current_thread_tls_init_flag, &uninitialized, sizeof(boost::once_flag)))
                    {
-                        void* data = pthread_getspecific(current_thread_tls_key);
-                        if (data)
-                            tls_destructor(data);
                        pthread_key_delete(current_thread_tls_key);
                    }
                }
            };
            delete_current_thread_tls_key_on_dlclose_t delete_current_thread_tls_key_on_dlclose;
-#endif
+
            void create_current_thread_tls_key()
            {
                BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,&tls_destructor));
@@ -430,7 +429,7 @@ namespace boost
    {
      namespace no_interruption_point
      {
-        namespace hidden
+        namespace hiden
        {
          void BOOST_THREAD_DECL sleep_for(const timespec& ts)
          {
@@ -457,9 +456,9 @@ namespace boost
                }
          }

-          void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts)
+          void BOOST_THREAD_DECL sleep_until(const timespec& ts)
          {
-                timespec now = boost::detail::timespec_now_realtime();
+                timespec now = boost::detail::timespec_now();
                if (boost::detail::timespec_gt(ts, now))
                {
                  for (int foo=0; foo < 5; ++foo)
@@ -479,7 +478,7 @@ namespace boost
                    condition_variable cond;
                    cond.do_wait_until(lock, ts);
    #   endif
-                    timespec now2 = boost::detail::timespec_now_realtime();
+                    timespec now2 = boost::detail::timespec_now();
                    if (boost::detail::timespec_ge(now2, ts))
                    {
                      return;
@@ -487,9 +486,10 @@ namespace boost
                  }
                }
          }
+
        }
      }
-      namespace hidden
+      namespace hiden
      {
        void BOOST_THREAD_DECL sleep_for(const timespec& ts)
        {
@@ -502,11 +502,11 @@ namespace boost
            }
            else
            {
-              boost::this_thread::no_interruption_point::hidden::sleep_for(ts);
+              boost::this_thread::no_interruption_point::hiden::sleep_for(ts);
            }
        }

-        void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts)
+        void BOOST_THREAD_DECL sleep_until(const timespec& ts)
        {
            boost::detail::thread_data_base* const thread_info=boost::detail::get_current_thread_data();

@@ -517,10 +517,10 @@ namespace boost
            }
            else
            {
-              boost::this_thread::no_interruption_point::hidden::sleep_until_realtime(ts);
+              boost::this_thread::no_interruption_point::hiden::sleep_until(ts);
            }
        }
-      } // hidden
+      } // hiden
    } // this_thread

    namespace this_thread
@@ -541,7 +541,7 @@ namespace boost
            timespec ts;
            ts.tv_sec= 0;
            ts.tv_nsec= 0;
-            hidden::sleep_for(ts);
+            hiden::sleep_for(ts);
 #   endif
        }
    }
@@ -830,7 +830,7 @@ namespace boost
    }
 namespace detail {

-    void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
+    void BOOST_THREAD_DECL make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as)
    {
      detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
      if(current_thread_data)
@@ -5,9 +5,15 @@
 // (C) Copyright 2007 David Deakins
 // (C) Copyright 2011-2013 Vicente J. Botet Escriba

+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x400
+#endif
+
+#ifndef WINVER
+#define WINVER 0x400
+#endif
 //#define BOOST_THREAD_VERSION 3

-#include <boost/detail/winapi/config.hpp>
 #include <boost/thread/thread_only.hpp>
 #include <boost/thread/once.hpp>
 #include <boost/thread/tss.hpp>
@@ -18,7 +24,6 @@
 #include <boost/cstdint.hpp>
 #if defined BOOST_THREAD_USES_DATETIME
 #include <boost/date_time/posix_time/conversion.hpp>
-#include <boost/thread/thread_time.hpp>
 #endif
 #include <boost/thread/csbl/memory/unique_ptr.hpp>
 #include <memory>
@@ -57,7 +62,7 @@ namespace boost
        for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                i != e; ++i)
        {
-            (*i)->notify_deferred();
+            (*i)->make_ready();
        }
    }
  }
@@ -462,7 +467,7 @@ namespace boost
 #if defined BOOST_THREAD_USES_DATETIME
    bool thread::timed_join(boost::system_time const& wait_until)
    {
-      return do_try_join_until(boost::detail::get_milliseconds_until(wait_until));
+      return do_try_join_until(get_milliseconds_until(wait_until));
    }
 #endif
    bool thread::do_try_join_until_noexcept(uintmax_t milli, bool& res)
@@ -508,7 +513,7 @@ namespace boost
    bool thread::interruption_requested() const BOOST_NOEXCEPT
    {
        detail::thread_data_ptr local_thread_info=(get_thread_info)();
-        return local_thread_info.get() && (detail::winapi::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
+        return local_thread_info.get() && (detail::win32::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
    }

 #endif
@@ -738,7 +743,7 @@ namespace boost

                if(handle_count)
                {
-                    unsigned long const notified_index=detail::winapi::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
                    if(notified_index<handle_count)
                    {
                        if(notified_index==wait_handle_index)
@@ -748,7 +753,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                        else if(notified_index==interruption_index)
                        {
-                            detail::winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                            detail::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
                            throw thread_interrupted();
                        }
 #endif
@@ -823,7 +828,7 @@ namespace boost

                if(handle_count)
                {
-                    unsigned long const notified_index=detail::winapi::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
                    if(notified_index<handle_count)
                    {
                        if(notified_index==wait_handle_index)
@@ -860,7 +865,7 @@ namespace boost
                return current_thread_data->id;
            }
 #endif
-            return detail::winapi::GetCurrentThreadId();
+            return detail::win32::GetCurrentThreadId();
 #else
            return thread::id(get_or_make_current_thread_data());
 #endif
@@ -871,7 +876,7 @@ namespace boost
        {
            if(interruption_enabled() && interruption_requested())
            {
-                detail::winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                detail::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
                throw thread_interrupted();
            }
        }
@@ -883,7 +888,7 @@ namespace boost

        bool interruption_requested() BOOST_NOEXCEPT
        {
-            return detail::get_current_thread_data() && (detail::winapi::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
+            return detail::get_current_thread_data() && (detail::win32::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
        }
 #endif

@@ -3,7 +3,6 @@
 // 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/detail/winapi/config.hpp>
 #include <boost/thread/detail/config.hpp>


@@ -11,6 +10,7 @@

    #include <boost/thread/detail/tss_hooks.hpp>

+    #define WIN32_LEAN_AND_MEAN
    #include <windows.h>

    #if defined(__BORLANDC__)
@@ -7,10 +7,9 @@
 // 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/detail/winapi/config.hpp>
 #include <boost/thread/detail/config.hpp>

-#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)
+#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) 

 #if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR)

@@ -39,7 +38,7 @@ namespace {
    }
 }

-#if defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR) || (__MINGW32__) || (__MINGW32_MAJOR_VERSION >3) ||   \
+#if defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR) || (__MINGW32_MAJOR_VERSION >3) ||             \
    ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
 extern "C"
 {
@@ -78,6 +77,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata

    #include <stdlib.h>

+    #define WIN32_LEAN_AND_MEAN
    #include <windows.h>


@@ -111,27 +111,15 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU


    //Definitions required by implementation
-    #if (_MSC_VER < 1300) || ((_MSC_VER > 1900) && (_MSC_VER < 1910)) // 1300 == VC++ 7.0, 1900 == VC++ 14.0, 1910 == VC++ 2017
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef void ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I void __cdecl
-    #elif (_MSC_VER >= 1910)
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef int ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I 0
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I int __cdecl
+
+    #if (_MSC_VER < 1300) // 1300 == VC++ 7.0
+        typedef void (__cdecl *_PVFV)();
+        #define INIRETSUCCESS
+        #define PVAPI void __cdecl
    #else
-        typedef int ( __cdecl *_PVFV_ )();
-        typedef int ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V 0
-        #define INIRETSUCCESS_I 0
-        #define PVAPI_V int __cdecl
-        #define PVAPI_I int __cdecl
+        typedef int (__cdecl *_PVFV)();
+        #define INIRETSUCCESS 0
+        #define PVAPI int __cdecl
    #endif

    typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
@@ -148,9 +136,9 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
    {
        //Forward declarations

-        static PVAPI_I on_tls_prepare();
-        static PVAPI_V on_process_init();
-        static PVAPI_V on_process_term();
+        static PVAPI on_tls_prepare();
+        static PVAPI on_process_init();
+        static PVAPI on_process_term();
        static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);

        //The .CRT$Xxx information is taken from Codeguru:
@@ -162,9 +150,9 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
 #pragma section(".CRT$XTU",long,read)
 #pragma section(".CRT$XLC",long,read)
        __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
-        __declspec(allocate(".CRT$XIU"))_PIFV_ p_tls_prepare = on_tls_prepare;
-        __declspec(allocate(".CRT$XCU"))_PVFV_ p_process_init = on_process_init;
-        __declspec(allocate(".CRT$XTU"))_PVFV_ p_process_term = on_process_term;
+        __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
+        __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
+        __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
 #else
        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
        #   pragma data_seg(push, old_seg)
@@ -176,13 +164,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
            //this could be changed easily if required.

            #pragma data_seg(".CRT$XIU")
-            static _PIFV_ p_tls_prepare = on_tls_prepare;
+            static _PVFV p_tls_prepare = on_tls_prepare;
            #pragma data_seg()

            //Callback after all global ctors.

            #pragma data_seg(".CRT$XCU")
-            static _PVFV_ p_process_init = on_process_init;
+            static _PVFV p_process_init = on_process_init;
            #pragma data_seg()

            //Callback for tls notifications.
@@ -193,7 +181,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
            //Callback for termination.

            #pragma data_seg(".CRT$XTU")
-            static _PVFV_ p_process_term = on_process_term;
+            static _PVFV p_process_term = on_process_term;
            #pragma data_seg()
        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
        #   pragma data_seg(pop, old_seg)
@@ -205,7 +193,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
 #pragma warning(disable:4189)
 #endif

-        PVAPI_I on_tls_prepare()
+        PVAPI on_tls_prepare()
        {
            //The following line has an important side effect:
            //if the TLS directory is not already there, it will
@@ -240,13 +228,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
                *pfdst = 0;
            #endif

-            return INIRETSUCCESS_I;
+            return INIRETSUCCESS;
        }
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif

-        PVAPI_V on_process_init()
+        PVAPI on_process_init()
        {
            //Schedule on_thread_exit() to be called for the main
            //thread before destructors of global objects have been
@@ -263,13 +251,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU

            boost::on_process_enter();

-            return INIRETSUCCESS_V;
+            return INIRETSUCCESS;
        }

-        PVAPI_V on_process_term()
+        PVAPI on_process_term()
        {
            boost::on_process_exit();
-            return INIRETSUCCESS_V;
+            return INIRETSUCCESS;
        }

        void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)
@@ -31,8 +31,7 @@ project
        <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>-Wno-variadic-macros
        #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
        <toolset>gcc:<cxxflags>-Wunused-function
        <toolset>gcc:<cxxflags>-Wno-unused-parameter
@@ -798,9 +797,7 @@ rule thread-compile ( sources : reqs * : name )
          [ thread-run2-noit ../example/synchronized_value.cpp : ex_synchronized_value ]
          [ thread-run2-noit ../example/synchronized_person.cpp : ex_synchronized_person ]
          [ thread-run2-noit ../example/thread_guard.cpp : ex_thread_guard ]
-          [ thread-run2-noit ../example/std_thread_guard.cpp : ex_std_thread_guard ]
          [ thread-run2-noit ../example/scoped_thread.cpp : ex_scoped_thread ]
-          [ thread-run2-noit ../example/std_scoped_thread.cpp : ex_std_scoped_thread ]
          [ thread-run2-noit ../example/strict_lock.cpp : ex_strict_lock ]
          [ thread-run2-noit ../example/ba_externallly_locked.cpp : ex_ba_externallly_locked ]
          [ thread-run2 ../example/producer_consumer_bounded.cpp : ex_producer_consumer_bounded ]
@@ -813,7 +810,10 @@ rule thread-compile ( sources : reqs * : name )
          [ thread-run2 ../example/user_scheduler.cpp : ex_user_scheduler ]
          [ thread-run2 ../example/executor.cpp : ex_executor ]
          [ thread-run2 ../example/generic_executor_ref.cpp : ex_generic_executor_ref ]
+          [ thread-run2 ../example/generic_executor.cpp : ex_generic_executor ]
+          [ thread-run2 ../example/generic_serial_executor.cpp : ex_generic_serial_executor ]
          [ thread-run2 ../example/serial_executor.cpp : ex_serial_executor ]
+          #[ thread-run2 ../example/generic_serial_executor_cont.cpp : ex_generic_serial_executor_cont ]
          #[ thread-run2 ../example/serial_executor_cont.cpp : ex_serial_executor_cont ]
          [ thread-run2 ../example/future_when_all.cpp : ex_future_when_all ]
          [ thread-run2 ../example/parallel_accumulate.cpp : ex_parallel_accumulate ]
@@ -962,13 +962,12 @@ rule thread-compile ( sources : reqs * : name )
    test-suite ts_
    :
          #[ thread-run test_11256.cpp ] 
+          #[ thread-run2 ../example/generic_serial_executor_cont.cpp : ex_generic_serial_executor_cont2 ]
+          #[ thread-run2 ../example/serial_executor_cont.cpp : ex_serial_executor_cont2 ]
          #[ thread-run test_11256.cpp ]
          #[ thread-run test_11499.cpp ]
          #[ thread-run test_11611.cpp ]
-          #[ thread-run test_11818.cpp ]
-          #[ thread-run test_11796.cpp ]
-          #[ thread-run test_12293.cpp ]
-          [ thread-run test_12949.cpp ]
+          #[ thread-run test_11633.cpp ]
          
    ;

@@ -12,7 +12,7 @@
 //  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)

-// <boost/thread/detail/invoker.hpp>
+// <boost/thread/detail/async_func.hpp>

 #include <boost/thread/detail/invoker.hpp>
 #include <boost/detail/lightweight_test.hpp>
@@ -12,9 +12,14 @@
 //  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)

+
 // <boost/thread/detail/invoker.hpp>

-#include <boost/thread/detail/invoker.hpp>
+#if ! defined  BOOST_NO_CXX11_DECLTYPE
+//#define BOOST_RESULT_OF_USE_DECLTYPE
+#endif
+
+#include <boost/thread/detail/async_func.hpp>
 #include <boost/detail/lightweight_test.hpp>

 int count = 0;
@@ -22,7 +22,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -36,39 +35,33 @@ int runs = 0;

 void f()
 {
-  try {
-    typedef boost::chrono::steady_clock Clock;
-    typedef boost::chrono::milliseconds milliseconds;
-    boost::unique_lock<boost::mutex> lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    int count=0;
-    while (test2 == 0 && cv.wait_for(lk, milliseconds(250)) == boost::cv_status::no_timeout)
-      count++;
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      assert(t1 - t0 < milliseconds(250));
-      assert(test2 != 0);
-    }
-    else
-    {
-      // This test is spurious as it depends on the time the thread system switches the threads
-      assert(t1 - t0 - milliseconds(250) < milliseconds(count*250+5+1000));
-      assert(test2 == 0);
-    }
-    ++runs;
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  typedef boost::chrono::steady_clock Clock;
+  typedef boost::chrono::milliseconds milliseconds;
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  int count=0;
+  while (test2 == 0 && cv.wait_for(lk, milliseconds(250)) == boost::cv_status::no_timeout)
+    count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < milliseconds(250));
+    BOOST_TEST(test2 != 0);
  }
+  else
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(count*250+5+1000));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -80,13 +73,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-      std::cout << "ERROR exception" << __LINE__ << std::endl;
-      BOOST_TEST(false);
  }
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -96,10 +85,8 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-      BOOST_TEST(false);
-      std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
+
  return boost::report_errors();
 }
 #else
@@ -21,8 +21,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
-#include <iostream>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -51,40 +49,34 @@ int runs = 0;

 void f()
 {
-  try {
-    typedef boost::chrono::system_clock Clock;
-    typedef boost::chrono::milliseconds milliseconds;
-    boost::unique_lock < boost::mutex > lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    int count=0;
-    //bool r =
-        (void)cv.wait_for(lk, milliseconds(250), Pred(test2));
-    count++;
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      // This test is spurious as it depends on the time the thread system switches the threads
-      assert(t1 - t0 < milliseconds(250+1000));
-      assert(test2 != 0);
-    }
-    else
-    {
-      assert(t1 - t0 - milliseconds(250) < milliseconds(count*250+2));
-      assert(test2 == 0);
-    }
-    ++runs;
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  typedef boost::chrono::system_clock Clock;
+  typedef boost::chrono::milliseconds milliseconds;
+  boost::unique_lock < boost::mutex > lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  int count=0;
+  //bool r =
+      (void)cv.wait_for(lk, milliseconds(250), Pred(test2));
+  count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 < milliseconds(250+1000));
+    BOOST_TEST(test2 != 0);
  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(count*250+2));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -96,13 +88,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -112,9 +100,6 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }

  return boost::report_errors();
@@ -17,13 +17,11 @@

 // void wait(unique_lock<mutex>& lock);

-
+#include <iostream>
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
-#include <iostream>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -37,40 +35,31 @@ int runs = 0;

 void f()
 {
-  try {
-    boost::unique_lock<boost::mutex> lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    while (test2 == 0) {
-        cv.wait(lk);
-    }
-    assert(test2 != 0);
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  while (test2 == 0) {
+      cv.wait(lk);
  }
+  BOOST_TEST(test2 != 0);
 }

 int main()
 {
-  try {
-    boost::unique_lock<boost::mutex>lk(mut);
-    boost::thread t(f);
-    BOOST_TEST(test1 == 0);
-    while (test1 == 0)
-    {
-        cv.wait(lk);
-    }
-    BOOST_TEST(test1 != 0);
-    test2 = 1;
-    lk.unlock();
-    cv.notify_one();
-    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
+  boost::unique_lock<boost::mutex>lk(mut);
+  boost::thread t(f);
+  BOOST_TEST(test1 == 0);
+  while (test1 == 0)
+  {
+      cv.wait(lk);
  }
+  BOOST_TEST(test1 != 0);
+  test2 = 1;
+  lk.unlock();
+  cv.notify_one();
+  t.join();
+
  return boost::report_errors();
 }
 #else
@@ -21,8 +21,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <iostream>
-#include <cassert>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -51,38 +49,32 @@ int runs = 0;

 void f()
 {
-  try {
-    boost::unique_lock < boost::mutex > lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    Clock::time_point t = t0 + Clock::duration(250);
-    int count=0;
-    while (test2 == 0 && cv.wait_until(lk, t) == boost::cv_status::no_timeout)
-      count++;
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      assert(t1 - t0 < Clock::duration(250));
-      assert(test2 != 0);
-    }
-    else
-    {
-      // This test is spurious as it depends on the time the thread system switches the threads
-      assert(t1 - t0 - Clock::duration(250) < Clock::duration(count*250+5+1000));
-      assert(test2 == 0);
-    }
-    ++runs;
-  } catch(...) {
-      assert(false);
-      std::cout << "ERROR exception" << __LINE__ << std::endl;
+  boost::unique_lock < boost::mutex > lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  int count=0;
+  while (test2 == 0 && cv.wait_until(lk, t) == boost::cv_status::no_timeout)
+    count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
  }
+  else
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(count*250+5+1000));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -94,14 +86,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
-
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -111,9 +98,6 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }

  return boost::report_errors();
@@ -21,8 +21,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
-#include <iostream>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -66,37 +64,31 @@ int runs = 0;

 void f()
 {
-  try {
-    boost::unique_lock<boost::mutex> lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    Clock::time_point t = t0 + Clock::duration(250);
-    bool r = cv.wait_until(lk, t, Pred(test2));
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      assert(t1 - t0 < Clock::duration(250));
-      assert(test2 != 0);
-      assert(r);
-    }
-    else
-    {
-      assert(t1 - t0 - Clock::duration(250) < Clock::duration(250+2));
-      assert(test2 == 0);
-      assert(!r);
-    }
-    ++runs;
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  bool r = cv.wait_until(lk, t, Pred(test2));
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
+    BOOST_TEST(r);
  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(250+2));
+    BOOST_TEST(test2 == 0);
+    BOOST_TEST(!r);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -108,13 +100,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -124,9 +112,6 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }

  return boost::report_errors();
@@ -89,15 +89,12 @@ int main()
  }
  {
    // empty queue push rvalue succeeds
-      boost::sync_bounded_queue<int> q(3);
+      boost::sync_bounded_queue<int> q(2);
      q.push(1);
-      BOOST_TEST_EQ(q.size(), 1u);
      q.push(2);
-      BOOST_TEST_EQ(q.size(), 2u);
-      q.push(2);
-      BOOST_TEST_EQ(q.size(), 3u);
      BOOST_TEST(! q.empty());
      BOOST_TEST( q.full());
+      BOOST_TEST_EQ(q.size(), 2u);
      BOOST_TEST(! q.closed());
  }
  {
@@ -320,15 +317,12 @@ int main()
  }
  {
    // empty queue push rvalue succeeds
-      boost::sync_bounded_queue<int> q(3);
+      boost::sync_bounded_queue<int> q(2);
      q.push_back(1);
-      BOOST_TEST_EQ(q.size(), 1u);
      q.push_back(2);
-      BOOST_TEST_EQ(q.size(), 2u);
-      q.push_back(3);
-      BOOST_TEST_EQ(q.size(), 3u);
      BOOST_TEST(! q.empty());
      BOOST_TEST( q.full());
+      BOOST_TEST_EQ(q.size(), 2u);
      BOOST_TEST(! q.closed());
  }
  {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vicente J. Botet Escriba	8961e8d593	go on with the future refactoring.	2015-10-14 03:04:26 +02:00
Vicente J. Botet Escriba	faca9512f6	minor fix on clang with executor forward declaration.	2015-10-13 23:55:38 +02:00
Vicente J. Botet Escriba	7df0d13763	minor fix on clang with executor forward declaration.	2015-10-13 19:15:18 +02:00
Vicente J. Botet Escriba	c3cd767ea4	make executor_adaptor copyable/movable.	2015-10-13 19:13:56 +02:00
Vicente J. Botet Escriba	5a57ab857b	comment serial_executor_cont test as not supported.	2015-10-13 03:08:59 +02:00
Vicente J. Botet Escriba	b80130759a	make executor_adaptor copy constructible.	2015-10-13 03:08:09 +02:00
Vicente J. Botet Escriba	ff9a1da3b2	Merge from develop.	2015-10-12 01:44:31 +02:00
Vicente J. Botet Escriba	51f68f4717	fix c++98 move emmulation.	2015-09-30 23:51:32 +02:00
Vicente J. Botet Escriba	50cca7429a	fix c++98 move emmulation.	2015-09-30 23:07:59 +02:00
Vicente J. Botet Escriba	6d533763a0	replace >> by > >.	2015-09-30 22:37:13 +02:00
Vicente J. Botet Escriba	f4c223662b	use init for unwraped future also.	2015-09-30 16:39:51 +02:00
Vicente J. Botet Escriba	011f9c80c0	merge from develop.	2015-09-30 07:12:50 +02:00
Vicente J. Botet Escriba	4fca45e58c	Merge branch 'develop' into feature/make_executors_copyable	2015-09-29 02:47:42 +02:00
Vicente J. Botet Escriba	02fab84a04	abstract common behavior on continuation_shared_state.	2015-09-29 02:11:27 +02:00
Vicente J. Botet Escriba	aebef44e64	Move post-construction initialization to init memberfunction.	2015-09-29 01:12:06 +02:00
Vicente J. Botet Escriba	5c1482a636	fix bad usage of share_from_this before the instance is ahared :(.	2015-09-28 23:48:20 +02:00
Vicente J. Botet Escriba	06179eda96	Merge branch 'develop' into feature/make_executors_copyable	2015-09-27 10:37:47 +02:00
Vicente J. Botet Escriba	5fccbf5dd1	merge from develop	2015-09-11 18:52:16 +02:00
Vicente J. Botet Escriba	7232c1c0ac	cleanup aftermerge fromdevelop.	2015-09-03 07:49:35 +02:00
Vicente J. Botet Escriba	7dee098bea	merge from develop.	2015-09-03 07:28:54 +02:00
Vicente J. Botet Escriba	6b6df268f5	merge make_executors_copyable.	2015-05-29 08:01:06 +02:00
Vicente J. Botet Escriba	bde5a1ef55	merge from develop.	2015-05-28 19:59:13 +02:00
Vicente J. Botet Escriba	a741bd1bba	Merge branch 'develop' into fix/make_executors_copyable	2015-04-18 07:11:12 +02:00
Vicente J. Botet Escriba	caaa7b4cc2	store executor by value.	2015-03-08 23:30:41 +01:00
Vicente J. Botet Escriba	9a05211faa	fix issue with c++03 compilers. Pass Executors by const& instead of by &.	2015-03-04 07:59:27 +01:00
Vicente J. Botet Escriba	7ffcec448c	uncomment more tests.	2015-03-03 19:29:50 +01:00
Vicente J. Botet Escriba	62bffed368	More fixes to make executor copyable.	2015-03-03 08:27:17 +01:00
Vicente J. Botet Escriba	5a1de7a722	ensure that generic executors are copyable.	2015-03-03 00:50:48 +01:00
Vicente J. Botet Escriba	33ee3445af	refactor basic_thread_pool. It doesn't works yet for at_thread_exit. Needs to replace function<void(basic_thread_pool)>.	2015-03-01 18:00:58 +01:00
Vicente J. Botet Escriba	8511771816	Merge branch 'develop' into fix/make_executors_copyable	2015-03-01 01:40:23 +01:00
Vicente J. Botet Escriba	7dbd04197d	Make scheduled_thread_pool copyable.	2015-02-28 19:01:45 +01:00
Vicente J. Botet Escriba	a53f31fb99	Store the Executor in scheduling_adaptor. This class must be finished as it doesn't make use of the executor :(.	2015-02-28 17:07:57 +01:00
Vicente J. Botet Escriba	b2b8684d0c	make scheduled_thread_pool design closer to basic_thread_pool.	2015-02-28 17:04:17 +01:00
Vicente J. Botet Escriba	df14c8ac18	fix the move(w) on scheduler and store copies of the Executors.	2015-02-28 16:29:00 +01:00
Vicente J. Botet Escriba	6e5a46c16f	merge from develop.	2015-02-28 15:32:18 +01:00
Vicente J. Botet Escriba	264ed4c308	move the work parameter.	2015-02-28 10:44:44 +01:00
Vicente J. Botet Escriba	65c4693c87	Add missing push(movable&&) and Run some failing tests that work when BOOST_NO_CXX11_RVALUE_REFERENCES is not defined.	2015-02-28 10:41:20 +01:00
Vicente J. Botet Escriba	05d6eca09d	Run some failing tests that work when BOOST_NO_CXX11_RVALUE_REFERENCES is not defined.	2015-02-28 10:38:15 +01:00
Vicente J. Botet Escriba	c192777aef	fix missing include in caller_context.hpp and let the possibility to dump function at compile time.	2015-02-28 09:53:09 +01:00
Vicente J. Botet Escriba	fdd1db970d	cleanup work and store by value scheduler.	2015-02-28 09:06:57 +01:00
Vicente J. Botet Escriba	3bc5fb1725	fix a lot of things for c++11 compilers. There is yet a lot to do :(	2015-02-26 08:16:11 +01:00
Vicente J. Botet Escriba	9481562b5c	update executors doc removing the move-only constraint.	2015-02-21 16:51:55 +01:00
Vicente J. Botet Escriba	e44b5309ae	rename serial_executors to generic_serial_executors and let serial_executor be the template form.	2015-02-21 16:17:11 +01:00
Vicente J. Botet Escriba	eecf8f6c36	Allow polymorphic executors to be copiable.	2015-02-21 14:29:51 +01:00
Vicente J. Botet Escriba	532d215de9	Make serial_executor_cont copyable, and fix it: reschedule_until and try_executing_one must return false, as a serial executor can not re-enter.	2015-02-21 12:26:40 +01:00
Vicente J. Botet Escriba	71bce54c71	fix serial_exeutor: reschedule_until and try_executing_one must return false, as a serial executor can not re-enter.	2015-02-21 12:25:29 +01:00
Vicente J. Botet Escriba	41bde57707	Make scheduler copyable.	2015-02-21 11:21:20 +01:00
Vicente J. Botet Escriba	ff7e394084	remove last sleep as now the tasks block the executors shared state lifetime as it is copied.	2015-02-21 11:20:42 +01:00
Vicente J. Botet Escriba	81f67eeb54	Change copyright date.	2015-02-21 11:18:08 +01:00
Vicente J. Botet Escriba	a4827a31f3	Change copyright date.	2015-02-21 11:16:19 +01:00
Vicente J. Botet Escriba	cd31e9c34f	Make executor_adaptor copyable.	2015-02-21 01:00:12 +01:00
Vicente J. Botet Escriba	9492bcd485	Make serial_executor copyable. Replace generic_executor_ref by generic_executor.	2015-02-20 22:26:12 +01:00
Vicente J. Botet Escriba	ff9457e79c	make basic_thread_pool copyable.	2015-02-20 20:47:30 +01:00
Vicente J. Botet Escriba	de580474a3	make inline_executor, loop_executor and thread_executor copyable.	2015-02-20 19:11:08 +01:00