Merge branch 'iss-28' into develop

Author: Herbert Koelman

include/pthread/config.h.in

@@ -27,14 +27,8 @@
 
 #ifdef __IBMCPP__
 
-#define __NOEXCEPT__ throw()
-#define __OVERRIDE__ 
-
 #else
 
-#define __NOEXCEPT__ noexcept
-#define __OVERRIDE__ override
-
 #endif
 
 #undef CPP_PTHREAD_VERSION

include/pthread/pthread_exception.hpp

@@ -32,8 +32,11 @@ namespace pthread {
     virtual ~pthread_exception(){};
 
     /** @return the exception's error message. */
-    virtual const char *what() const __NOEXCEPT__ __OVERRIDE__ { return _message.c_str();};
-    
+#if __cplusplus < 201103L
+    virtual const char *what() const throw() { return _message.c_str();};
+#else
+    virtual const char *what() const noexcept override{ return _message.c_str();};
+#endif    
     /** @return pthread error code that was at the orgin of the error */
     virtual int pthread_errno(){ return _pthread_errno ;};
 

include/pthread/thread.hpp

@@ -48,7 +48,11 @@ namespace pthread {
     /**
      * This method must be overriden
      */
-    virtual void run () __NOEXCEPT__ = 0 ;
+#if __cplusplus < 201103L
+    virtual void run () throw() = 0 ;
+#else
+    virtual void run () noexcept = 0 ;
+#endif
   };
 
   /**
@@ -166,57 +170,57 @@ namespace pthread {
    * 
    * utility class, that wraps a thread.
    * <pre><code>
-   class worker: public pthread::abstract_thread {
-   public:
-   
-     worker(const std::string m = "anonymous worker", int sleep = 2*1000): msg(m), _sleep(sleep){
-     };
-     
-     ~worker(){
-     };
-     
-     void run() __NOEXCEPT__ __OVERRIDE__ {
-       { // critical section scope
-         pthread::lock_guard<pthread::mutex> lck(mtx);
-   
-         bool stop_waiting = true; // if lambda syntax is not availbale then use this kind of implementation
-         auto delay = _sleep; // use sleep seconds to calculate point in time timeout
-         while ( ! (stop_waiting = (counter >= 10000)) && (condition.wait_for(mtx, delay) == pthread::cv_status::no_timeout)){
-           delay = -1 ; // if timeout millis is negatif, then we keep last timeout calculation.
-         }
-     
-         if ( counter >= 10000 ) {
-           message("worker class, counter >= 10000");
-         } else {
-           message("worker class, counter < 10000");
-         }
-       } // end of critical section
-   
-       pthread::this_thread::sleep(200);
-     };
-   
-   private:
-     std::string    msg ;
-     int            _sleep;
-   };
-
-   int main(int argc, const char * argv[]) {
-   
-     pthread::thread_group threads(true); // indicate that we want to join referenced threads when deallocating this instance.
-     for (auto x = 10 ; x > 0 ; x--){
-       threads.add( new worker("herbert"));
-     }
-     
-     threads.start(); // start running all threads
-   
-     for ( auto x = 20000 ; x > 0 ; x--){
-       pthread::lock_guard<pthread::mutex> lck(mtx);
-       counter++ ;
-     }
-   
-     condition.notify_all();
-   }
-
+   * class worker: public pthread::abstract_thread {
+   * public:
+   * 
+   *   worker(const std::string m = "anonymous worker", int sleep = 2*1000): msg(m), _sleep(sleep){
+   *   };
+   *   
+   *   ~worker(){
+   *   };
+   *   
+   *   void run() noexcept override {
+   *     { // critical section scope
+   *       pthread::lock_guard<pthread::mutex> lck(mtx);
+   * 
+   *       bool stop_waiting = true; // if lambda syntax is not availbale then use this kind of implementation
+   *       auto delay = _sleep; // use sleep seconds to calculate point in time timeout
+   *       while ( ! (stop_waiting = (counter >= 10000)) && (condition.wait_for(mtx, delay) == pthread::cv_status::no_timeout)){
+   *         delay = -1 ; // if timeout millis is negatif, then we keep last timeout calculation.
+   *       }
+   *   
+   *       if ( counter >= 10000 ) {
+   *         message("worker class, counter >= 10000");
+   *       } else {
+   *         message("worker class, counter < 10000");
+   *       }
+   *     } // end of critical section
+   * 
+   *     pthread::this_thread::sleep(200);
+   *   };
+   * 
+   * private:
+   *   std::string    msg ;
+   *   int            _sleep;
+   * };
+   *
+   * int main(int argc, const char * argv[]) {
+   * 
+   *   pthread::thread_group threads(true); // indicate that we want to join referenced threads when deallocating this instance.
+   *   for (auto x = 10 ; x > 0 ; x--){
+   *     threads.add( new worker("herbert"));
+   *   }
+   *   
+   *   threads.start(); // start running all threads
+   * 
+   *   for ( auto x = 20000 ; x > 0 ; x--){
+   *     pthread::lock_guard<pthread::mutex> lck(mtx);
+   *     counter++ ;
+   *   }
+   * 
+   *   condition.notify_all();
+   * }
+   *
    * </code></pre>
    */
   class abstract_thread: public runnable {
@@ -243,19 +247,19 @@ namespace pthread {
    *
    * **A thread_group deletes the thread that were registered/added to it.**
    *
-   <pre><code>
-   int main(int argc, const char * argv[]) {
-   
-     pthread::thread_group threads; // this instance will free any registered thread when it will get out of scope
-   
-     for (auto x = 10 ; x > 0 ; x--){
-       threads.add( new worker("herbert")); // register threads, they will run when start() is called
-     }
-   
-     threads.start(); // start running all threads
-     threads.join(); // wait for registered threads to join
-   } // scope end
-   
+   * <pre><code>
+   * int main(int argc, const char * argv[]) {
+   * 
+   *   pthread::thread_group threads; // this instance will free any registered thread when it will get out of scope
+   * 
+   *   for (auto x = 10 ; x > 0 ; x--){
+   *     threads.add( new worker("herbert")); // register threads, they will run when start() is called
+   *   }
+   * 
+   *   threads.start(); // start running all threads
+   *   threads.join(); // wait for registered threads to join
+   * } // scope end
+   * 
    * </code></pre>
    */
   class thread_group{
@@ -264,7 +268,11 @@ namespace pthread {
      *
      * @param destructor_joins_first if true then destructor tries to wait for all registered threads to join the calling one before deleting thread instances.
      */
-    thread_group( bool destructor_joins_first = false ) __NOEXCEPT__;
+#if __cplusplus < 201103L
+    thread_group( bool destructor_joins_first = false ) throw();
+#else
+    thread_group( bool destructor_joins_first = false ) noexcept;
+#endif
 
     /** delete all abstract_thread referenced by the thread_group.
      *

src/condition_variable.cpp

@@ -48,11 +48,19 @@ namespace pthread {
     return status;
   }
 
-  void condition_variable::notify_one() __NOEXCEPT__ {
+#if __cplusplus < 201103L
+  void condition_variable::notify_one() throw() {
+#else
+  void condition_variable::notify_one() noexcept {
+#endif
     pthread_cond_signal ( &_condition );
   }
 
-  void condition_variable::notify_all () __NOEXCEPT__{
+#if __cplusplus < 201103L
+  void condition_variable::notify_all () throw(){
+#else
+  void condition_variable::notify_all () noexcept{
+#endif
     pthread_cond_broadcast ( &_condition );
 
   }

src/thread.cpp

@@ -113,7 +113,11 @@ namespace pthread {
     _thread = new pthread::thread(*this);
   }
 
-  thread_group::thread_group(bool destructor_joins_first ) __NOEXCEPT__: _destructor_joins_first(destructor_joins_first){
+#if __cplusplus < 201103L
+  thread_group::thread_group(bool destructor_joins_first ) throw(): _destructor_joins_first(destructor_joins_first){
+#else
+  thread_group::thread_group(bool destructor_joins_first ) noexcept: _destructor_joins_first(destructor_joins_first){
+#endif
 
   }
 

tests/without-cpp11-pthread-tests.cpp

@@ -13,7 +13,6 @@
 #include <utility>
 #include <memory>
 #include "pthread/pthread.hpp"
-// workaround  - #include "ibm.hpp"
 
 pthread::condition_variable condition;
 pthread::mutex mtx;
@@ -36,7 +35,11 @@ class worker: public pthread::abstract_thread {
     message("deallocating worker");
   };
 
-  void run() __NOEXCEPT__ __OVERRIDE__ {
+#if __cplusplus < 201103L
+  void run() throw()  {
+#else
+  void run() noexcept override {
+#endif
     message("worker: " + msg);
     {
       pthread::lock_guard<pthread::mutex> lck(mtx);
@@ -70,20 +73,6 @@ int main(int argc, const char * argv[]) {
 
   pthread::string dummy;
 
-  {
-    worker w1("herbert", 2);
-    w1.start();
-    w1.join();
-  }
-//  worker w("laura");
-//  pthread::thread t0;
-//  pthread::thread t2(w);
-//  t0 = ibm::move(t2) ;
-//  t0.join();
-//  
-//  std::auto_ptr<pthread::thread> pt0(new pthread::thread(worker("laura")));
-//  pt0->join();
-
   pthread::thread_group threads(true);
   for (auto x = 10 ; x > 0 ; x--){
     threads.add( new worker("herbert"));
@@ -98,7 +87,7 @@ int main(int argc, const char * argv[]) {
   }
   condition.notify_all();
 
-//  message("main is waiting for threads to finish");
+  message("main is waiting for threads to finish");
   threads.join();
   message( "end reached");