Thread.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : Thread
 * Package    : Zeus.ZeusBase.System
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library 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 Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef ThreadH
#define ThreadH

#include <zeusbase/System/ZObject.h>
#include <zeusbase/System/Interfaces/IRunnable.hpp>
#include <zeusbase/System/Interfaces/IThread.hpp>

#if defined(ENABLE_LINUX_BINDING) || defined(ENABLE_OSX_BINDING)
  #include <pthread.h>
#elif defined(ENABLE_WIN32_BINDING)
  #if defined(USE_WINDOWS_H)
    #include <windows.h>
  #endif
#endif


BEGIN_NAMESPACE_Zeus

class TThreadMessageQueue;
class TCriticalSection;
class ISynchronizeObject;

/***************************************************************************/
/***************************************************************************/
zeusbase_class TThread : public TZObject, public IThread
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    enum EPriority
    {
      etNormal = 0,
      etLow = 1,
      etHigh = 2,
      etLower = 3,
      etHigher = 4,
      etTimeCritical = 5
    };

    TThread(EPriority ePriority = etNormal);
    TThread(IRunnable& rObj, EPriority ePriority = etNormal);


    EPriority getPriority() const;
    void setPriority(EPriority ePriority);
    static void sleep(const Float& rfDelay);

    virtual void kill(Float64 dTimeOut=0);
    virtual bool isAlive() const;
    virtual bool isDead() const;
    virtual void resume();
    virtual bool signalizeStop(Float64 dTimeOut=5.0);
    virtual bool start();
    virtual void suspend();
    virtual bool yield();
    virtual Retval postObject(ISynchronizeObject& rObject,
                              bool bWaitForCompletion);

    //Methods of IThread
    virtual bool MQUALIFIER isInterrupted() const;
    virtual Uint MQUALIFIER getThreadID() const;

    //Methods of IZUnknown
    MEMORY_MANAGER_DECL

  protected:
    bool m_bInterrupted;
    TThreadMessageQueue& m_rQueue;

    virtual ~TThread();
    virtual void execute();
    virtual void onTerminated() {}
    virtual void onStarted() {}

  private:
    void terminate_internal();
    void release_internal();

    bool m_bCreated;
    bool m_bTerminated;
    bool m_bSuspended;
    IRunnable* m_pRunObj;
    EPriority m_ePriority;
    Uint m_uiThreadID;
    //Lock for ThreadID
    TCriticalSection& m_rDataLock;


    #if defined(ENABLE_LINUX_BINDING) || defined(ENABLE_OSX_BINDING)
      pthread_t m_Thread;

      static void* createThread(void* pLife);
    #elif defined(ENABLE_WIN32_BINDING)
      //Thread handle
      HANDLE m_hHandle;
      static Uint32 __stdcall createThread(void* pLife);

      #if _WIN32_WINNT >= 0x0400
        static void CALLBACK doUserAPCProc(DWORD dwParam);
      #endif
    #endif
};

//INLINE

/***************************************************************************/
/***************************************************************************/
inline bool TThread::isAlive() const
{
  return !isDead();
}

/***************************************************************************/
/***************************************************************************/
inline bool TThread::isDead() const
{
  return (m_bTerminated || !m_bCreated);
}

/***************************************************************************/
/***************************************************************************/
inline bool MQUALIFIER TThread::isInterrupted() const
{
  return m_bInterrupted;
}

/***************************************************************************/
/***************************************************************************/
inline TThread::EPriority TThread::getPriority() const
{
  return m_ePriority;
}



END_NAMESPACE_Zeus

#endif