smtpthread/Thread.cc

// DOCUMENT:  Threading-Class
// VERSION:   $Revision: 1.6 $
// DATE:      $Date: 2007-10-26 23:09:19 $
// AUTHOR:    M.Beranek
// COPYRIGHT: M.Beranek

#include <pthread.h>
#include "Thread.h"

namespace SmtpThread
{
// --------------------------------------------------------------------------
    /**
     * Default-Constructor.
     */
    Thread::Thread()
    {
        // We are not running:
        _isRunning = false;
        
        // Initialize a mutex:
        pthread_mutex_init( &_mutex, 0L );
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Default-Destructor.
     */
    Thread::~Thread()
    {
        // If the thread is running:
        if( _isRunning )
        {
            // Stop the thread:
            Stop();
        }
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Starts threading.
     * Threading begins with static mebmer-function "EntryPoint".
     */
    int Thread::Start(void * arg)
    {
        // Store the argument in _arg:
        Arg( arg );
        
        /* The pthreads-library expects a standard C-function as entrypoint for
         * threading. As an argument to the entrypoint, we provide a pointer
         * to ourself. This way, we can call any member-function within the
         * static entrypoint.
         */
        int code = pthread_create(
                & _ThreadId,          // Thread-ID
                NULL,                 // Default-Attributes
                Thread::EntryPoint,   // Threading-function
                this                  // Argument of threading-function is "this"
                );
        
        return code;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Protected member-function.
     * Gets called after "EntryPoint"
     */
    int Thread::Run( void * arg )
    {
        // Do some initialization:
        Setup();
        
        // Execute main event-loop:
        Execute( arg );
        
        // Return success:
        return 0;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Static Member-Function, begin of threading.
     * @param void* this_p Must be a pointer to ourself.
     * @return void* a pointer to ourself.
     */
    void* Thread::EntryPoint( void* this_p )
    {
        // Pointer to the threading-object:
        Thread * pt = ( Thread * ) this_p;
        
        /* This method is static, so it does not know anything about
         * the object/class it is declared in. So we have no "this"-
         * pointer within here. To call a member-function of this
         * object/class, we use the provided pointer to ourself.
         * As the argument to "Run", we provide the previously
         * initialized argument by calling "pt->Arg()" which is
         * effectivly the same as "this->Arg()".
         */
        pt->Run( pt->Arg() );
        
        // Return a pointer to ourself.
        return this_p;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Setup some data for the thread.
     */
    void Thread::Setup()
    {
        // Set up a mutex.
        pthread_mutex_init( &_mutex, NULL );
        
        // We are now running.
        _isRunning = true;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Main execution of the thread goes here.
     * Must be overridden to do something usefull.
     */
    void Thread::Execute( void * arg )
    {
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Returns the thread-ID.
     * @return pthread_t thread-ID
     */
    pthread_t Thread::getThreadId()
    {
        return _ThreadId;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Determines whether thread is running or not.
     * @return bool true / false = thread is running / is not running.
     */
    bool Thread::isRunning()
    {
        return _isRunning;
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Stops threading.
     */
    void Thread::Stop()
    {
        // Toggle "_isRunning", so the "Execute"-function will stop whatever it
        // is doing.
        _isRunning = false;
        
        // Wait for thread to finish and synchronize with the main program.
        pthread_join( _ThreadId, NULL );
        
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Locks the mutex.
     */
    void Thread::getLock()
    {
        // Lock the mutex:
        pthread_mutex_lock( &_mutex );
    }
    
    
// --------------------------------------------------------------------------
    /**
     * Unlocks the mutex.
     */
    void Thread::releaseLock()
    {
        // Unlock the mutex:
        pthread_mutex_unlock( &_mutex );
    }
    
}

---