---

wefts_thread.h

Go to the documentation of this file.

/*
   wefts_thread.h
   Main thread class

   $Id: wefts_thread.h,v 1.7 2003/08/15 18:03:11 jonnymind Exp $
---------------------------------------------
   Begin      : 2003-08-02 23:45
   Author     : Giancarlo Niccolai

   Last modified because:
   Implementing OS independent base threading
*/

/**************************************************************************
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Library General Public License as       *
*   published by the Free Software Foundation; either version 2.1 of the  *
*   License, or (at your option) any later version.                       *
***************************************************************************/

#ifndef WT_THREAD_H
#define WT_THREAD_H

#include <wefts_os.h>
#include <wefts_counter.h>
#include <wefts_cleanup.h>
#include <stack>

namespace Wefts {

extern Counter runningThreads;

extern Counter startedThreads;



class Thread
{
private:
   inline virtual void executionEnd() { m_running = false; }

   void setCancel() { setCancel( m_canCancel ); }

   CleanupList m_cleanupHandlers;

   friend void s_ThreadCleanupper( void *);
   friend void s_ThreadRunner( void *);
   friend void *s_ThreadRunFunc( void *);

protected:
   void *m_runReturnValue;
   OSThread    m_thread;
   bool        m_canCancel;
   void        *m_thread_data;
   bool        m_detached;
   volatile bool m_stopped;

   volatile bool m_running;

   int m_thSequence;

   void testCancel() { m_thread.testCancel(); if ( m_stopped ) m_thread.exit(0); }

   void setCancel( bool cando );

   void doDetach() { m_thread.detach(); }

   void setReturn( void *ret ) { m_runReturnValue = ret; }

public:
   Thread();

   virtual ~Thread();

   bool start( bool detachable = false, bool cancelable = true );

   bool stop();

   void detach() { m_detached = true; }
   bool detached() const { return m_detached; }

   virtual void *join() throw( NotJoinableError );

   bool running() const { return m_running; }

   OSThread *getThread() { return &m_thread; }

   inline void setData( void *data ) { m_thread_data = data; }

   inline int  sequence() const { return m_thSequence; }

   virtual void cleanup() {
      m_stopped = true; // force this to avoid races.
      while( m_cleanupHandlers.size() > 0 ) {
            m_cleanupHandlers.top().first->
                  handleCleanup( m_cleanupHandlers.top().second );
         m_cleanupHandlers.pop();
      }
   };

   bool pushCleanupHandler( CleanupHandler *handler, int value=0 )
   {
      //avoid pushing a cleanup handler while the thread is diyng
      if ( m_stopped ) return false;
      m_cleanupHandlers.push( CleanupItem( handler, value ) );
      return true;
   }

   bool popCleanupHandler( bool execute=false )
   {
      if ( m_stopped )
         return false;
      if ( m_cleanupHandlers.size() > 0 ) {
         if ( execute )
            m_cleanupHandlers.top().first->
                  handleCleanup( m_cleanupHandlers.top().second );
         m_cleanupHandlers.pop();
         return true;
      }
      return false;
   }

   virtual void *run()=0;

};

}

#endif
/* end of wefts_thread.h */

---