/***************************************************************************/
/* Name : PThread.hpp                                                      */
/* Uses : A class for pthreads                                             */
/* Date : 10/12/2007                                                       */
/* Author : Andrew Que (http://www.DrQue.net/)                             */
/* Revisions :                                                             */
/*  1.0 - 10/12/2007 - QUE - Creation                                      */
/*                                                                         */
/*                           (C) Copyright 2007                            */
/*                                   ≡|>                                   */
/***************************************************************************/
#ifndef PTHREAD_HPP
#define PTHREAD_HPP

#include <pthread.h>
#include <semaphore.h>
#include <list>
#include <unistd.h>


#include <iostream>

using namespace std;

//---------------------------------------------------------------------------
// Class basic class for POSIX threads
//---------------------------------------------------------------------------
class PThread
{
  private:
   void* Parameters;
   pthread_t Thread;
   pthread_attr_t ThreadAttributes;
   static sem_t* PThreadLock;
   sem_t ThreadInUse;
   bool _IsTimeToStart;
   bool _IsTimeToShutdown;
   static bool _IsFullShutdown;

   static list< PThread* >* ThreadList;

   //----------------------------------------------------------------
   // Update function
   // The thread always calls this function, which, in trun, calls
   // the thread's actual update function
   //----------------------------------------------------------------
   static void* InternalThreadUpdate( void* ThreadPointer )
   {
     // Cast the class pointer 
     PThread* Thread = (PThread*)ThreadPointer;

     // Wait for thread to start
     // NOTE: Wait at least once, since it is posible this function
     // could be called before the thread class has been completly 
     // constructed.
     do
     {
       usleep( 100000 );
     } while ( ! Thread->IsTimeToStart() );

     // Call and return data form the thread
     // NOTE: The parameters are stored in the class
     return Thread->UpdateThread( Thread->Parameters );
   }

  protected:
   //----------------------------------------------------------------
   // Constructor
   //----------------------------------------------------------------
   PThread( void* Arguments )
     : Parameters( Arguments )
   {
     // If the thread list hasn't yet been initilized
     if ( ! ThreadList )
     {
       ThreadList = new list< PThread* >;
       PThreadLock = new sem_t;
       sem_init( PThreadLock , 0 , 1 );
     }

     // Lock the thread list
     sem_wait( PThreadLock );

     // Initilize locals
     _IsTimeToStart    = false;
     _IsTimeToShutdown = false;
     _IsFullShutdown   = false;

     // Initilize semaphore
     sem_init( &ThreadInUse , 0 , 1 );

     // Lock this thread
     sem_wait( &ThreadInUse );

     // Create thread attributes
     pthread_attr_init( &ThreadAttributes );

     // Set thread as joinable
     pthread_attr_setdetachstate( 
       &ThreadAttributes , PTHREAD_CREATE_JOINABLE );

     // Create thread
     pthread_create( 
        &Thread  , 
        &ThreadAttributes ,
        PThread::InternalThreadUpdate , 
        (void *)this );

     // Detach thread
     pthread_detach( Thread );

     // Add thread to list
     ThreadList->push_back( this );

     // Unlock thread
     sem_post( &ThreadInUse );

     // Unlock thread list
     sem_post( PThreadLock );
   }
  public:
   //----------------------------------------------------------------
   // Signal thread to shutdown
   // NOTE: It is up to the thread to follow this request
   //----------------------------------------------------------------
   void ShutdownThread()
   {
     //_IsTimeToStart = true; // <- Just in case
     _IsTimeToShutdown = true;
   }

   //----------------------------------------------------------------
   // True if it is time to shutdown
   //----------------------------------------------------------------
   bool IsTimeToShutdown() const
   {
     return _IsTimeToShutdown;
   }

   //----------------------------------------------------------------
   // True if it's time to start the thread
   //----------------------------------------------------------------
   bool IsTimeToStart() const
   {
     return _IsTimeToStart;
   }

   //----------------------------------------------------------------
   // Signal thread to start
   //----------------------------------------------------------------
   void SetIsTimeToStart()
   {
     _IsTimeToStart = true;
   }

   //----------------------------------------------------------------
   // Destructor
   //----------------------------------------------------------------
   virtual ~PThread()
   {
     // Stop thread
     ShutdownThread();

     //pthread_join( Thread , NULL );

     pthread_attr_destroy( &ThreadAttributes );

     // Lock this thread
     // (we're about to destory it)
     sem_wait( &ThreadInUse );

     // Lock the list
     sem_wait( PThreadLock );

     // Remove this thread from the list
     ThreadList->remove( this );

     // Unlock list
     sem_post( PThreadLock );

     // Trash semaphore
     sem_destroy( &ThreadInUse );
   }

   //----------------------------------------------------------------
   // Signal all threads to shutdown
   //----------------------------------------------------------------
   static void SignalAllThreadShutdown()
   {
     // Signal all thread to stop
     list< PThread* >::iterator ThreadListIterator;
     for ( ThreadListIterator  = ThreadList->begin(); 
           ThreadListIterator != ThreadList->end(); 
           ThreadListIterator  ) 
     {
       (*ThreadListIterator)->ShutdownThread();
     }
   }

   //----------------------------------------------------------------
   // Signal all threads to shutdown and wait for them to finish
   //----------------------------------------------------------------
   static void ShutdownAllThreads()
   {
     SignalAllThreadShutdown();

     // Signal all thread to stop
     list< PThread* >::iterator ThreadListIterator;

     // Wait for all threads to stop
     for ( ThreadListIterator  = ThreadList->begin(); 
           ThreadListIterator != ThreadList->end(); 
           ThreadListIterator  ) 
     {
       pthread_join( (*ThreadListIterator)->Thread , NULL );
     }

     _IsFullShutdown = true;
   }

   //----------------------------------------------------------------
   // Returns true if all threads are being shutdown
   //----------------------------------------------------------------
   static bool IsFullShutdown()
   {
     return _IsFullShutdown;
   }

   //----------------------------------------------------------------
   // Thread function (pure virtual)
   //----------------------------------------------------------------
   virtual void* UpdateThread( void* ) = 0;
};

#endif // PTHREAD_HPP