thread.hpp

/************************************************************************************
 *    This file is part of the MynahSA streaming and archiving toolkit              *
 *    Copyright (C) 2006 Mynah-Software Ltd. All Rights Reserved.                   *
 *                                                                                  *
 *    This program is free software; you can redistribute it and/or modify          *
 *    it under the terms of the GNU General Public License, version 2               *
 *    as published by the Free Software Foundation.                                 *
 *                                                                                  *
 *    This program 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 General Public License for more details.                                  *
 *                                                                                  *
 *    You should have received a copy of the GNU General Public License along       *
 *    with this program; if not, write to the Free Software Foundation, Inc.,       *
 *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.                   *
 *                                                                                  *
 ************************************************************************************/

#ifndef __thread_hpp
#define __thread_hpp

#ifdef MYNAHSA_USE_BOOST
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
namespace MynahSA { 
  typedef boost::mutex Mutex;
  typedef boost::mutex::scoped_lock Lock;
};

#else

#ifndef WIN32
#include <pthread.h>
#else
#include <windows.h>
#endif


#include <iostream>


namespace MynahSA { 
  class Mutex { 
    friend class Lock;
  public:
    Mutex();
    ~Mutex();
  
    inline static void lock(Mutex& m) { 
#ifdef WIN32
      WaitForSingleObject(m._mutex, INFINITE); // obtain lock
#else
      pthread_mutex_lock(&m._mutex); 
#endif
    }
    
    inline static void unlock(Mutex& m) { 
#ifdef WIN32
      ReleaseMutex(m._mutex);
#else
      pthread_mutex_unlock(&m._mutex); 
#endif
    }
  
  private:
    Mutex(const Mutex&) { }
#ifdef WIN32

    HANDLE _mutex;
#else
    // posix mutex (only available on posix machines)
    pthread_mutex_t _mutex;
#endif
  };

  class Lock { 
  public:
    Lock(Mutex& m);
    ~Lock();
  private:
    Lock(const Lock& l ) : _mutex(l._mutex) { }
    Mutex& _mutex;
  };
  

  template<class T>
  class Thread { 
  public:
    Thread(const T& startclass) {
      T* copy = new T(startclass);  // create a startclass copy on the heap
      
#ifndef WIN32
      pthread_create(&_thread,
                     0,
                     Thread<T>::startAddr,
                     copy);
#else 
      _hThread = CreateThread(0,                    // LPSECURITY_ATTRIBUTES
                              0,                    // dwStackSize - 0 means same as parent
                              (LPTHREAD_START_ROUTINE) Thread<T>::startAddr, // start address
                              copy,        // data (this ptr)
                                                0,
                                                &_thread);    
#endif
    }
    ~Thread() { 
#ifndef WIN32
      pthread_detach(_thread);
#endif
    }    
    void* join() { 
#ifdef WIN32
      WaitForSingleObject( _hThread, INFINITE );
      return 0;
#else
      void* vrtn;
      pthread_join(_thread,&vrtn);
      return vrtn;
#endif
    }
      
  private:
    static void* startAddr(void* args) {
      T* tptr = reinterpret_cast<T*>(args);
      (*tptr)();
      delete tptr;
      return 0;
    }
  
#ifdef WIN32

    HANDLE _hThread;
    DWORD _thread;
#else  

    pthread_t _thread;
#endif

  };
};
#endif

#endif