Thread.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



#ifndef __THREAD_H_
#define __THREAD_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <stdio.h>
#include <math.h>
#include <vector>
#include <iostream>
#include <string>
#include <sstream>
#include <sys/time.h>
#include <sys/select.h>
#include <assert.h>
#include <pthread.h>


#include <Types.h>
#include <Time.h>


/* @{ */


using namespace std;


namespace MipBaselib {
class Thread{
 protected:
  pthread_t _tid; 
  bool _live;  
  bool _doWork; 
  bool _stopWork;
  bool _dirty;  
//  TimeUtilities _tu; /**< time utilitities for the usleep */
  Time _sleepTime;  
  static const int THREAD_SLEEP_USECS = 100000;
  
  void* _workObject;   
  void (*_work)(void*); 
  void (*_workClean)(void*); 
 public:
  Thread();
  
   ~Thread();
  void setWorkObject(void* wO){
   _workObject = wO;
  }
  void setWork(void (*w)(void*)){
   _work = w;
  }
  void setWorkClean(void (*wC)(void*)){
   _workClean = wC;
  }
  
  void setSleepTime(Time sleepT){
   _sleepTime = sleepT;
  }

  
  void work(){
   if(_workObject!=0){
    if(_work!=0){
     (*_work)(_workObject);
    }
   }
  }
  
  void workClean(){
   if(_workObject!=0){
    if(_workClean!=0){
     (*_workClean)(_workObject);
    }
   }
  }
  
  void startWork(){
   _doWork = true;
  }
  
  void stopWork(){
   _doWork  = false;
   _stopWork = true;
  }
  
  void liveCycle();
};



class EnhancedMutEx{
 private:
  pthread_mutex_t _mutex;    
  pthread_t    _enabledTid; 

  int _trylock() {
   return pthread_mutex_trylock(&_mutex);
  }
  int _unlock(){
   return pthread_mutex_unlock(&_mutex);
  }
  
  bool _threadAllowed();
  
  bool _threadAllowedPrompt();
  
  void _threadEnable();
  
 public:
  EnhancedMutEx();
  
  bool askExclusiveAccess(Time timeout);
  
  void leaveExclusiveAccess();
  
  bool allowed(void){
   return _threadAllowedPrompt();
  }
  
  string print();
};


}; // end of namespace

#endif

/* @} */