vpThread.h

#ifndef __vpPthread_h_
#define __vpPthread_h_

#include <visp3/core/vpConfig.h>
#include <visp3/core/vpException.h>

#if defined(VISP_HAVE_PTHREAD) || (defined(_WIN32) && !defined(WINRT_8_0))

#if defined(VISP_HAVE_PTHREAD)
#include <pthread.h>
#include <string.h>
#elif defined(_WIN32)
// Include WinSock2.h before windows.h to ensure that winsock.h is not
// included by windows.h since winsock.h and winsock2.h are incompatible
#include <WinSock2.h>
#include <windows.h>
#endif

class vpThread
{
public:
#if defined(VISP_HAVE_PTHREAD)
  typedef void *Args;
  typedef void *Return;
  typedef void *(*Fn)(Args);
  typedef pthread_t Handle;
#elif defined(_WIN32)
  typedef LPVOID Args;
  typedef DWORD Return;
  typedef LPTHREAD_START_ROUTINE Fn;
  // typedef DWORD (*Fn)(Args);
  typedef HANDLE Handle;
#endif

  vpThread() : m_handle(), m_isCreated(false), m_isJoinable(false) {}

  vpThread(vpThread::Fn fn, vpThread::Args args = NULL) : m_handle(), m_isCreated(false), m_isJoinable(false)
  {
    create(fn, args);
  }

  void create(vpThread::Fn fn, vpThread::Args args = NULL)
  {
    if (m_isCreated)
      throw vpException(vpException::fatalError, "The thread is already created");
#if defined(VISP_HAVE_PTHREAD)
    int err = pthread_create(&m_handle, NULL, fn, args);
    if (err != 0) {
      throw vpException(vpException::cannotUseConstructorError, "Can't create thread : %s", strerror(err));
    }
#elif defined(_WIN32)
    DWORD dwThreadIdArray;
    m_handle = CreateThread(NULL,              // default security attributes
                            0,                 // use default stack size
                            fn,                // thread function name
                            args,              // argument to thread function
                            0,                 // use default creation flags
                            &dwThreadIdArray); // returns the thread identifier
#endif

    m_isJoinable = true;
  }

  virtual ~vpThread()
  {
    join();
#if defined(VISP_HAVE_PTHREAD)
#elif defined(_WIN32)
    CloseHandle(m_handle);
#endif
  }

  void join()
  {
    if (m_isJoinable) {
#if defined(VISP_HAVE_PTHREAD)
      pthread_join(m_handle, NULL);
#elif defined(_WIN32)
#if defined(WINRT_8_1)
      WaitForSingleObjectEx(m_handle, INFINITE, FALSE);
#else
      WaitForSingleObject(m_handle, INFINITE);
#endif
#endif
      m_isJoinable = false;
    }
  }

  Handle getHandle() { return m_handle; }

  bool joinable() { return m_isJoinable; }

protected:
  Handle m_handle;   
  bool m_isCreated;  
  bool m_isJoinable; 
};

#endif
#endif