Search  

---

C:/temp/src/j2k/Posix/Basic_PThread.hpp

Go to the documentation of this file.

// Made by Fred, for Coen445.
// LGPL licensed.

#ifndef __J2K__Basic_PThread_HPP__
#define __J2K__Basic_PThread_HPP__

#include <j2k/Fred/Standard.hpp>
#include <j2k/Fred/Error/JErrorController.hpp>
#include <pthread.h>
#include <unistd.h>

#if defined( __sun ) || defined( __SUN__ )
#include <thread.h>
#endif
// #include <process.h>

#include <sched.h>

#include <time.h>
#include <signal.h>
#include <sys/types.h>

#define  pid_t   pthread_t

#define  INVALID_PID   ((unsigned)(-1))

/**************************************************************
***************************************************************
***  Attribute         Default Value                        ***
***  =========         =============                        *** 
***   detachstate       PTHREAD_CREATE_JOINABLE             *** 
***   schedpolicy       PTHREAD_INHERIT_SCHED               ***
***   schedparam        Inherited from parent thread        *** 
***   contentionscope   PTHREAD_SCOPE_SYSTEM                *** 
***   stacksize         4096                                *** 
***   stackaddr         NULL                                ***
***************************************************************
**************************************************************/

class Basic_PThread {
// MC_SerializeHeader()

public:

   // Default Constructor
   inline Basic_PThread( BOOL autostart = FALSE, BOOL autojoin = FALSE );

   // Destructor
   inline virtual ~Basic_PThread();

private:
   // Not implemented.
   inline Basic_PThread( const Basic_PThread& src );
   inline const Basic_PThread& operator=( const Basic_PThread& src );

public:
   // Get calling thread's ID
   inline pid_t getPID();
 
   // Implement this, when deriving the class.
   // It should be overriden by it's children...
   virtual void run() = 0;

   //  Callback can only call STATIC functions !
   //  =========================================
   //  This routine is a stub which will call
   //  the run() routine given the class instance
   //  as the void pointer argument.

   static void* Basic_PThread::Wrapper( void* ptrThis ) 
   {
     Basic_PThread* me = (Basic_PThread*)ptrThis;
 
     // Call the derived classes version, since the function
     // run is implemented by it's children
     me->run();  

     // run() should contain an Infinite Loop, i.e. for(;;) { ... }
     // Exit beautifully, just in case there is no infinite loop.
  
     me->pid = (unsigned)(-1); 
     pthread_exit( NULL );
 
     return NULL;
   }

   inline void start( int start_prio = 20 );

   inline void yield();

   inline void stop();
   inline void end();

   inline BOOL isStarted();

   // Join PThread
   inline void join( void** value_ptr = NULL );

   inline void detach();
    
protected:
  // So, children can access easily the PID
  pid_t  pid; 
  BOOL   isDetached;
  pthread_attr_t attr;
  sched_param    param;
};


#endif

---