---

WaitCallback.cpp

Go to the documentation of this file.

// WaitCallback.cpp: implementation of the WaitCallback class.


#include "stdafx.h"
#include "WaitCallback.h"

// Construction/Destruction

WaitCallback::WaitCallback()
{
    waitEvents[0] = CreateEvent(NULL, true, false, NULL);
    waitEvents[1] = INVALID_HANDLE_VALUE;   // Important, see hasWaitRegistered
}

WaitCallback::~WaitCallback()
{
    unregisterWait();
    CloseHandle(waitEvents[0]);
    CloseHandle(waitEvents[1]);
}

// Member Functions

bool WaitCallback::hasWaitRegistered() const
{
    return waitEvents[1] != INVALID_HANDLE_VALUE;
}

bool WaitCallback::registerWaitForSingleObject(
    HANDLE hEvent,      // handle to wait object (takes possesion)
    const WAITCALLBACK cB,  // callback function        
    const PVOID cBP,    // callback context 
    const DWORD tO,     // time-out interval
    const bool once)    // execute just once?
{
    if( hasWaitRegistered() )
        return false;

    hWaitThread = chBEGINTHREADEX(
        NULL,           // Default Security, non inheritable
        0,              // use default stack size  
        &waitThread,    // thread function
        this,           // thread argument
        CREATE_SUSPENDED,   // Create suspended
        NULL);          // don't need thread identifier

    if(hWaitThread == NULL)
        return false;

    // Take possesion of the event handle
    waitEvents[1] = hEvent;
    cBack = cB;
    cBackParam = cBP;
    timeOut = tO;
    justOnce = once;

    ResumeThread(hWaitThread);

    return true;
}

void WaitCallback::unregisterWait()
{
    if( hasWaitRegistered() ){
        SetEvent(waitEvents[0]);    // Signal waitThread to exit

        if( WaitForSingleObject(hWaitThread, 6000) == WAIT_TIMEOUT ){
            TerminateThread(hWaitThread, 0);
            chMB("Warning couldn't unregister a wait gracefully.\nCheck for Deadlock");
        }

        CloseHandle(waitEvents[1]);
        waitEvents[1] = INVALID_HANDLE_VALUE;
        CloseHandle(hWaitThread);
        ResetEvent(waitEvents[0]);
    }
}

DWORD WINAPI WaitCallback::waitThread(LPVOID param)
{
    WaitCallback* thisWait = (WaitCallback*) param;

    do{
        switch( WaitForMultipleObjects(2, thisWait->waitEvents, false, thisWait->timeOut) ) {
        case WAIT_OBJECT_0: // wait is being unregistered
            return true;
            break;
        case WAIT_FAILED:
            assert(WAIT_FAILED != WAIT_FAILED);
            return false;
            break;
        case WAIT_TIMEOUT:
            (*thisWait->cBack)(thisWait->cBackParam, true);
            break;
        default:
            (*thisWait->cBack)(thisWait->cBackParam, false);
            break;
        }

    } while ( !thisWait->justOnce );
    
    return true;
}

---