sprint/thread/thread.h

Go to the documentation of this file.

/******************************************************************************
*   SPRINT::thread
*
*   Copyright (C) 2003-2011  Paolo Medici <www.pmx.it>
*
*  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 Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _THREAD_H
#define _THREAD_H

#include <sprint/thread/detail/platform.h>
#include <sprint/thread/detail/function.h>

#if defined SPRINT_THREAD_WIN32

namespace sprint {

class thread {
  HANDLE hThread;
  DWORD dwThreadId;
  
  private:
  thread(const thread & src) { }

  public:
                
  thread() : hThread(INVALID_HANDLE_VALUE), dwThreadId(0) {} 

  ~thread()
  {
  if(hThread != INVALID_HANDLE_VALUE)
   ::CloseHandle(hThread);
  } 


  inline bool create_thread(const sprint::thread_function & p)
  {
        hThread = ::CreateThread(NULL, 
                0,
                p.proc, 
                p.param, 
                0, 
                &dwThreadId);
                return hThread != INVALID_HANDLE_VALUE;
  }
  

  inline bool get_exit_code(LPDWORD lpdwExitCode)
    {
      return ::GetExitCodeThread(hThread, lpdwExitCode)!=0;
    }
  
  inline bool is_terminated() const
    {
      if(hThread==INVALID_HANDLE_VALUE) return true;
          return ::WaitForSingleObject(hThread, 0) == WAIT_OBJECT_0     ;
    }
    
  inline bool is_running() const
        {
      if(hThread==INVALID_HANDLE_VALUE) return false;
      return ::WaitForSingleObject(hThread, 0) != WAIT_OBJECT_0 ;
    }

  inline bool kill()
        {
                return ::TerminateThread(hThread, 0)!=0;
        }

  bool join(unsigned int timeout = INFINITE)
    {
      return ::WaitForSingleObject(hThread, timeout) == WAIT_OBJECT_0   ;
    }
    
};

class runnable: public thread {
   
   // jump method
   static DWORD __stdcall CALLBACK _thread_proc(void *p)
    {
    return (DWORD) (reinterpret_cast<runnable*>(p))->the_thread();
    }
    
    public:

    virtual void * the_thread() = 0;
    
    virtual ~runnable() { }

    void run()
    {
        thread::create_thread(sprint::thread_function(_thread_proc, reinterpret_cast<void*>(this)) );
    }
    
};


} // sprint

#elif defined SPRINT_THREAD_POSIX

#include <pthread.h>

namespace sprint {

class thread {
  pthread_t m_thread;
  private:
  thread(const thread & src) { }
  public:
                
  public:
                
  thread()  {} 

  ~thread()
  {
  } 

  inline bool create_thread(const sprint::thread_function & p)
  {
        int ret = pthread_create(&m_thread, 0, 
                                 p.proc, 
                                 p.param);
  }
  
  inline bool kill() const
        {
        // TODO
        return false;
        }

  bool join() const
    {
      return pthread_join(m_thread, 0);
    }
    
};

class runnable: public thread {
   
   static void * _thread_proc(void *p)
    {
    return (void *) (reinterpret_cast<runnable*>(p))->the_thread();
    }
    
    public:
    virtual void * the_thread() = 0;
    
    virtual ~runnable() { }

    void run()
    {
        thread::create_thread(sprint::thread_function(_thread_proc, reinterpret_cast<void*>(this)) );
    }
};

}

#endif



#endif