Branch for adding initializer list support (only in the unreleased gcc 4.4 at the moment).

[SVN r48931]

CMakeLists.txt

@@ -1,22 +0,0 @@
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    thread.hpp
-    thread
-)
-
-# Add a library target to the build system
-boost_library_project(
-  thread
-  SRCDIRS  src 
-  TESTDIRS  test
-  HEADERS ${lib_headers}
-  #  DOCDIRS 
-  #  DESCRIPTION 
-  MODULARIZED 
-  #  AUTHORS 
-  #  MAINTAINERS 
-)
-
-

doc/Jamfile.v2

@@ -31,6 +31,25 @@ boostbook standalone
         # Use the main Boost stylesheet:
         <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
         
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        #<xsl:param>fop1.extensions=1
+        # Or enable this if you're using XEP:
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
     ;
 
-

example/condition.cpp

@@ -50,9 +50,8 @@ boost::mutex io_mutex;
 
 void sender() {
     int n = 0;
-    while (n < 1000000) {
+    while (n < 100) {
         buf.send(n);
-        if(!(n%10000))
         {
             boost::mutex::scoped_lock io_lock(io_mutex);
             std::cout << "sent: " << n << std::endl;
@@ -66,24 +65,18 @@ void receiver() {
     int n;
     do {
         n = buf.receive();
-        if(!(n%10000))
         {
             boost::mutex::scoped_lock io_lock(io_mutex);
             std::cout << "received: " << n << std::endl;
         }
     } while (n != -1); // -1 indicates end of buffer
-    buf.send(-1);
 }
 
 int main(int, char*[])
 {
     boost::thread thrd1(&sender);
     boost::thread thrd2(&receiver);
-    boost::thread thrd3(&receiver);
-    boost::thread thrd4(&receiver);
     thrd1.join();
     thrd2.join();
-    thrd3.join();
-    thrd4.join();
     return 0;
 }

example/tennis.cpp

@@ -112,7 +112,7 @@ int main(int argc, char* argv[])
         std::cout << "---Noise ON..." << std::endl;
     }
 
-    for (int i = 0; i < 1000000000; ++i)
+    for (int i = 0; i < 1000000; ++i)
         cond.notify_all();
 
     {

include/boost/thread/detail/move.hpp

@@ -41,9 +41,9 @@ namespace boost
 
 #ifndef BOOST_NO_SFINAE
     template<typename T>
-    typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, T >::type move(T& t)
+    typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, detail::thread_move_t<T> >::type move(T& t)
     {
-        return T(detail::thread_move_t<T>(t));
+        return t;
     }
 #endif
     

include/boost/thread/detail/thread.hpp

@@ -339,9 +339,9 @@ namespace boost
         return t;
     }
 #else
-    inline thread move(detail::thread_move_t<thread> t)
+    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
     {
-        return thread(t);
+        return t;
     }
 #endif
 

include/boost/thread/pthread/recursive_mutex.hpp

@@ -177,7 +177,7 @@ namespace boost
         {
             struct timespec const timeout=detail::get_timespec(abs_time);
             int const res=pthread_mutex_timedlock(&m,&timeout);
-            BOOST_ASSERT(!res || res==ETIMEDOUT);
+            BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }
 

include/boost/thread/pthread/shared_mutex.hpp

@@ -57,18 +57,18 @@ namespace boost
         void lock_shared()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             while(state.exclusive || state.exclusive_waiting_blocked)
             {
-                shared_cond.wait(lk);
+                shared_cond.wait(lock);
             }
             ++state.shared_count;
         }
 
         bool try_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             if(state.exclusive || state.exclusive_waiting_blocked)
             {
@@ -84,11 +84,11 @@ namespace boost
         bool timed_lock_shared(system_time const& timeout)
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             while(state.exclusive || state.exclusive_waiting_blocked)
             {
-                if(!shared_cond.timed_wait(lk,timeout))
+                if(!shared_cond.timed_wait(lock,timeout))
                 {
                     return false;
                 }
@@ -105,7 +105,7 @@ namespace boost
 
         void unlock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             bool const last_reader=!--state.shared_count;
                 
             if(last_reader)
@@ -127,12 +127,12 @@ namespace boost
         void lock()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             while(state.shared_count || state.exclusive)
             {
                 state.exclusive_waiting_blocked=true;
-                exclusive_cond.wait(lk);
+                exclusive_cond.wait(lock);
             }
             state.exclusive=true;
         }
@@ -140,12 +140,12 @@ namespace boost
         bool timed_lock(system_time const& timeout)
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
 
             while(state.shared_count || state.exclusive)
             {
                 state.exclusive_waiting_blocked=true;
-                if(!exclusive_cond.timed_wait(lk,timeout))
+                if(!exclusive_cond.timed_wait(lock,timeout))
                 {
                     if(state.shared_count || state.exclusive)
                     {
@@ -168,7 +168,7 @@ namespace boost
 
         bool try_lock()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             if(state.shared_count || state.exclusive)
             {
@@ -184,7 +184,7 @@ namespace boost
 
         void unlock()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.exclusive=false;
             state.exclusive_waiting_blocked=false;
             release_waiters();
@@ -193,10 +193,10 @@ namespace boost
         void lock_upgrade()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
-                shared_cond.wait(lk);
+                shared_cond.wait(lock);
             }
             ++state.shared_count;
             state.upgrade=true;
@@ -205,10 +205,10 @@ namespace boost
         bool timed_lock_upgrade(system_time const& timeout)
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
-                if(!shared_cond.timed_wait(lk,timeout))
+                if(!shared_cond.timed_wait(lock,timeout))
                 {
                     if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
                     {
@@ -230,7 +230,7 @@ namespace boost
 
         bool try_lock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
                 return false;
@@ -245,7 +245,7 @@ namespace boost
 
         void unlock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.upgrade=false;
             bool const last_reader=!--state.shared_count;
                 
@@ -259,11 +259,11 @@ namespace boost
         void unlock_upgrade_and_lock()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             --state.shared_count;
             while(state.shared_count)
             {
-                upgrade_cond.wait(lk);
+                upgrade_cond.wait(lock);
             }
             state.upgrade=false;
             state.exclusive=true;
@@ -271,7 +271,7 @@ namespace boost
 
         void unlock_and_lock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.exclusive=false;
             state.upgrade=true;
             ++state.shared_count;
@@ -281,7 +281,7 @@ namespace boost
         
         void unlock_and_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.exclusive=false;
             ++state.shared_count;
             state.exclusive_waiting_blocked=false;
@@ -290,7 +290,7 @@ namespace boost
         
         void unlock_upgrade_and_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.upgrade=false;
             state.exclusive_waiting_blocked=false;
             release_waiters();

module.cmake

@@ -1 +0,0 @@
-boost_module(thread DEPENDS date_time bind optional range)

src/CMakeLists.txt

@@ -1,15 +0,0 @@
-if (WIN32)
-  set(THREAD_SOURCES win32/thread.cpp win32/exceptions.cpp win32/tss_dll.cpp
-                     win32/tss_pe.cpp)
-else (WIN32)
-  set(THREAD_SOURCES pthread/thread.cpp pthread/exceptions.cpp pthread/once.cpp)
-endif (WIN32)
-
-boost_add_library(
-  boost_thread
-  ${THREAD_SOURCES}
-  SHARED_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_DLL=1"
-  STATIC_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_LIB=1"
-  NO_SINGLE_THREADED
-  )
-

src/pthread/thread.cpp

@@ -132,12 +132,10 @@ namespace boost
                 catch(thread_interrupted const&)
                 {
                 }
-// Removed as it stops the debugger identifying the cause of the exception
-// Unhandled exceptions still cause the application to terminate
-//                 catch(...)
-//                 {
-//                     std::terminate();
-//                 }
+                catch(...)
+                {
+                    std::terminate();
+                }
 
                 detail::tls_destructor(thread_info.get());
                 detail::set_current_thread_data(0);

src/win32/thread.cpp

@@ -169,12 +169,10 @@ namespace boost
             catch(thread_interrupted const&)
             {
             }
-// Removed as it stops the debugger identifying the cause of the exception
-// Unhandled exceptions still cause the application to terminate
-//             catch(...)
-//             {
-//                 std::terminate();
-//             }
+            catch(...)
+            {
+                std::terminate();
+            }
             run_thread_exit_callbacks();
             return 0;
         }

test/CMakeLists.txt

@@ -1,33 +0,0 @@
-boost_additional_test_dependencies(thread BOOST_DEPENDS test )
-
-
-
-set(TESTS 
-test_thread
-test_thread_id
-test_hardware_concurrency
-test_thread_move
-test_thread_launching
-test_thread_mf
-test_move_function
-test_mutex
-test_condition_notify_one
-test_condition_timed_wait_times_out
-test_condition_notify_all
-test_condition
-test_tss
-test_once
-test_xtime
-test_barrier
-test_shared_mutex
-test_shared_mutex_part_2
-test_shared_mutex_timed_locks
-test_lock_concept
-test_generic_locks)
-
-foreach (TEST ${TESTS})
-  boost_test_run(${TEST} MULTI_THREADED DEPENDS boost_thread boost_unit_test_framework)
-endforeach (TEST ${TESTS})
-
-boost_test_compile_fail(no_implicit_move_from_lvalue_thread)
-boost_test_compile_fail(no_implicit_assign_from_lvalue_thread)

test/test_thread_move.cpp

@@ -5,59 +5,26 @@
 #include <boost/thread/thread.hpp>
 #include <boost/test/unit_test.hpp>
 
-void do_nothing(boost::thread::id* my_id)
-{
-    *my_id=boost::this_thread::get_id();
-}
+void do_nothing()
+{}
 
 void test_move_on_construction()
 {
-    boost::thread::id the_id;
-    boost::thread x=boost::thread(do_nothing,&the_id);
-    boost::thread::id x_id=x.get_id();
+    boost::thread x=boost::thread(do_nothing);
     x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
 }
 
-boost::thread make_thread(boost::thread::id* the_id)
+boost::thread make_thread()
 {
-    return boost::thread(do_nothing,the_id);
+    return boost::thread(do_nothing);
 }
 
 void test_move_from_function_return()
 {
-    boost::thread::id the_id;
-    boost::thread x=make_thread(&the_id);
-    boost::thread::id x_id=x.get_id();
+    boost::thread x=make_thread();
     x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
 }
 
-boost::thread make_thread_return_lvalue(boost::thread::id* the_id)
-{
-    boost::thread t(do_nothing,the_id);
-    return boost::move(t);
-}
-
-void test_move_from_function_return_lvalue()
-{
-    boost::thread::id the_id;
-    boost::thread x=make_thread_return_lvalue(&the_id);
-    boost::thread::id x_id=x.get_id();
-    x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
-}
-
-void test_move_assign()
-{
-    boost::thread::id the_id;
-    boost::thread x(do_nothing,&the_id);
-    boost::thread y;
-    y=boost::move(x);
-    boost::thread::id y_id=y.get_id();
-    y.join();
-    BOOST_CHECK_EQUAL(the_id,y_id);
-}
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
@@ -66,7 +33,5 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 
     test->add(BOOST_TEST_CASE(test_move_on_construction));
     test->add(BOOST_TEST_CASE(test_move_from_function_return));
-    test->add(BOOST_TEST_CASE(test_move_from_function_return_lvalue));
-    test->add(BOOST_TEST_CASE(test_move_assign));
     return test;
 }