condition_variable.hpp

//
//  Created by herbert koelman on 13/03/2016.
//  Copyright © 2016 urbix-software. All rights reserved.
//

#ifndef pthread_condition_variable_hpp
#define pthread_condition_variable_hpp

// must be include as first hearder file of each source code file (see IBM's
// recommandation for more info p.285 �8.3.1).
#include <pthread.h>
#include <string>
#include <ctime>
#include <sys/time.h>

#include "pthread/config.h"

#include "pthread/exceptions.hpp"
#include "pthread/mutex.hpp"
#include "pthread/lock_guard.hpp"

namespace pthread {

  enum cv_status {
    no_timeout, 
    timedout    
  };

  class condition_variable {
  public:

    void wait ( mutex &mtx );

    void wait ( lock_guard<pthread::mutex> lck);

    template<class Lambda> bool wait( mutex &mtx, Lambda lambda);

    template<class Lambda> bool wait( lock_guard<pthread::mutex> &lck, Lambda lambda);

    cv_status wait_for (mutex &mtx, int millis );

    cv_status wait_for (lock_guard<pthread::mutex> &lck, int millis );

    template<class Lambda> bool wait_for( mutex &mtx, int millis, Lambda lambda);

    template<class Lambda> bool wait_for( lock_guard<pthread::mutex> &lck, int millis, Lambda lambda);

#if __cplusplus < 201103L
    void notify_one () throw() ;
#else
    void notify_one () noexcept;
#endif

#if __cplusplus < 201103L
    void notify_all () throw() ;
#else
    void notify_all () noexcept ;
#endif

    // constructor/destructor ------------------------------------------------

    condition_variable ();
    virtual ~condition_variable();

  private:
    void milliseconds( int milliseconds);

    timespec timeout;
    pthread_cond_t _condition;
  };

  // template implementation ----------------------

  template<class Lambda> bool condition_variable::wait( mutex &mtx, Lambda lambda){

    bool stop_waiting = lambda();

    while(!stop_waiting){
      wait(mtx);
      stop_waiting = lambda(); // handling spurious wakeups
    }

    return stop_waiting;
  };

  template<class Lambda> bool condition_variable::wait( lock_guard<pthread::mutex> &lck, Lambda lambda){

    //return wait( *(lck.mutex()), lambda);
    return wait( *(lck._mutex), lambda);
  };

  template<class Lambda> bool condition_variable::wait_for( mutex &mtx, int millis, Lambda lambda){
    int rc = 0;
    cv_status status = no_timeout;

    milliseconds(millis); // update timeou
    bool stop_waiting = lambda(); // returns ​false if the waiting should be continued.

    while((! stop_waiting) && (status == no_timeout)){

      rc  = pthread_cond_timedwait ( &_condition, &mtx._mutex, &timeout );

      switch (rc){

        case ETIMEDOUT:
          status = timedout;
          break;

        case EINVAL:
          throw condition_variable_exception("The value specified by abstime is invalid.", rc); // NOSONAR we use throw instead of return.
          break;

        case EPERM:
          throw condition_variable_exception("The mutex was not owned by the current thread at the time of the call.", rc); // NOSONAR we use throw instead of return.
          break;
        default:
          status = no_timeout ;
          break;
      }

      stop_waiting = lambda();
    }


    return stop_waiting ; //status == cv_status::no_timeout;
  };

  template<class Lambda> bool condition_variable::wait_for( lock_guard<pthread::mutex> &lck, int millis, Lambda lambda){

    // return wait_for(*(lck.mutex()),millis, lambda);
    return wait_for(*(lck._mutex),millis, lambda);
  };


} // namespace pthread


#endif