ithread.h

Go to the documentation of this file.

#ifndef ITHREAD_CLASS
#define ITHREAD_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : ithread / managed_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 "mechanisms_dll.h"

#include <basis/object_base.h>

// forward.
class time_stamp;
#ifdef __UNIX__
  typedef long unsigned int pthread_t;
#endif


class MECHANISMS_CLASS_STYLE ithread : public virtual object_base
{
public:
  ithread();

  enum timed_thread_types { TIGHT_INTERVAL, SLACK_INTERVAL };

  ithread(int sleep_timer, timed_thread_types how = SLACK_INTERVAL);

  virtual ~ithread();

  IMPLEMENT_CLASS_NAME("ithread");

  bool start(void *thread_data);

  void stop();

  inline 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);

  void reschedule();

  inline int sleep_time() const { return _sleep_time; }

  inline void sleep_time(int new_sleep) { _sleep_time = new_sleep; }

  // these functions report on the thread state.

  inline bool thread_started() const { return _thread_ready; }

  inline bool thread_finished() const { return !_thread_ready; }

  inline bool thread_active() const { return _thread_active; }

  inline bool should_stop() const { return _stop_thread; }

private:
  bool _thread_ready;  
  bool _thread_active;  
  bool _stop_thread;  
  void *_data;  
#ifdef __UNIX__
  pthread_t *_handle;  
#elif defined(__WIN32__)
  uintptr_t _handle;  
#endif
  int _sleep_time;  
  bool _periodic;  
  time_stamp *_next_activation;  
  timed_thread_types _how;  

  // the OS level thread functions.
#ifdef __UNIX__
  static void *periodic_thread_driver(void *hidden_pointer);
  static void *one_shot_thread_driver(void *hidden_pointer);
#elif defined(__WIN32__)
  static void periodic_thread_driver(void *hidden_pointer);
  static void one_shot_thread_driver(void *hidden_pointer);
#endif

  // forbidden.
  ithread(const ithread &);
  ithread &operator =(const ithread &);
};


// an older synonym for the ithread, used in legacy code.

class managed_thread : public ithread
{
public:
  inline managed_thread() : ithread() {}
  inline managed_thread(int st, timed_thread_types how = SLACK_INTERVAL)
      : ithread(st, how) {}

  virtual void perform_activity(void *thread_data) = 0;

private:
  // forbidden.
  managed_thread(const ithread &);
  managed_thread &operator =(const managed_thread &);
};

#endif

---