wefts_thread.h

Go to the documentation of this file.

/*
   wefts_thread.h
   Main thread class

   $Id: wefts_thread.h,v 1.17 2004/03/13 16:10:18 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;

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

   OSPriority m_reqPriority;
   
   int m_reqBoost;
   
   Mutex m_guard;
   
   void *m_runReturn;
   
protected:
   OSThread    m_thread;
   bool        m_canCancel;
   void        *m_thread_data;
   bool        m_detached;
   bool m_stopped;
   bool m_wasCanceled;

   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(); }


public:
   Thread( OSPriority prio = PrioNormal, int boost = 0);

   virtual ~Thread();

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

   bool stop();

   void detach() { 
      m_guard.lock();
      m_detached = true; 
      m_guard.unlock();
   }
   
   bool detached() { 
      volatile bool ret;
      m_guard.lock();
      ret = m_detached; 
      m_guard.unlock();
      return ret;
   }

   virtual void *join() throw( NotJoinableError );

   bool running() { 
      bool ret;
      m_guard.lock();
      ret = m_running;
      m_guard.unlock();
      return ret;
   }

   OSThread *getThread() { return &m_thread; }

   inline void setData( void *data ) { 
      m_guard.lock();
      m_thread_data = data; 
      m_guard.unlock();
   }

   inline int sequence() const { return m_thSequence; }

   virtual void cleanup(); 

   bool pushCleanup( CleanupHandler *handler, int value=0 )
   {
      //avoid pushing a cleanup handler while the thread is diyng
      m_guard.lock();
      if ( m_stopped && ! m_running ) {
         m_guard.unlock();
         return false;
      }
      // don't push "this" as caller: we'll directly send "this" at cleanup.
      m_cleanupHandlers.push( CleanupItem( handler, value ) );
      m_guard.unlock();
      return true;
   }

   bool popCleanup( bool execute=false )
   {
      m_guard.lock();
      if ( m_stopped && ! m_running ) {
         m_guard.unlock();
         return false;
      }
      
      if ( m_cleanupHandlers.size() > 0 ) {
         if ( execute ) {
            m_cleanupHandlers.top().handler->
                  handleCleanup( m_cleanupHandlers.top().position, this );        
         }
         m_cleanupHandlers.pop();
         m_guard.unlock();
         return true;
      }
      m_guard.unlock();
      return false;
   }

   bool priority( OSPriority Prio, int boost = 0 );
   
   virtual void *run()=0;

   void *getRunReturn() { return m_runReturn; }
};

}

#endif
/* end of wefts_thread.h */

---