ethread.h

Go to the documentation of this file.

#ifndef ETHREAD_CLASS
#define ETHREAD_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : ethread (easy thread)                                             *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1998-$now By Author.  This program 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 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include <basis/contracts.h>
#include <timely/time_stamp.h>
 
#include <signal.h>
 
namespace processes {
 
 
class ethread : public virtual basis::root_object
{
public:
  ethread();
 
  enum timed_thread_types { TIGHT_INTERVAL, SLACK_INTERVAL };
 
  ethread(int sleep_timer, timed_thread_types how = SLACK_INTERVAL);
 
  virtual ~ethread();
 
  DEFINE_CLASS_NAME("ethread");
 
  bool start(void *thread_data);
 
  void stop();
 
  void cancel() { _stop_thread = true; }
 
//  virtual void pre_thread();
 
//  virtual void post_thread();
 
  virtual void perform_activity(void *thread_data) = 0;
 
  void exempt_stop();
 
  void reschedule(int delay = 0);
 
  int sleep_time() const { return _sleep_time; }
 
  void sleep_time(int new_sleep) { _sleep_time = new_sleep; }
 
  // these functions report on the thread state.
 
  bool thread_started() const { return _thread_ready; }
 
  bool thread_finished() const { return !_thread_ready; }
 
  bool thread_active() const { return _thread_active; }
 
  bool should_stop() const { return _stop_thread; }
 
private:
  bool _thread_ready;  
  bool _thread_active;  
  bool _stop_thread;  
  void *_data;  
//#ifndef _MSC_VER
  pthread_t *_handle;  
//#else
  //uintptr_t _handle;  //!< thread handle for the active thread, or zero.
//#endif
  int _sleep_time;  
  bool _periodic;  
  timely::time_stamp *_next_activation;  
  timed_thread_types _how;  
 
  // the OS level thread functions.
//#ifndef _MSC_VER
  static void *periodic_thread_driver(void *hidden_pointer);
  static void *one_shot_thread_driver(void *hidden_pointer);
//#else
  //static void periodic_thread_driver(void *hidden_pointer);
  //static void one_shot_thread_driver(void *hidden_pointer);
//#endif
 
  // forbidden.
  ethread(const ethread &);
  ethread &operator =(const ethread &);
};
 
} //namespace.
 
#endif