even simpler condvar vor C++/Win32

#include <windows.h>
#include <cassert>
#include <exception>

#if !defined(NDEBUG)
    #define ONDEBUG(expr) (expr)
#else
    #define ONDEBUG(expr) ((void)0)
#endif

class Exception : public std::exception
{
};

class ResourceException : Exception
{
};

template <typename TYPE>
inline
TYPE AutoThrowResourceException( TYPE t )
{
    if( !t )
        throw ResourceException();

    return t;
}

class XHANDLE
{
public:
         XHANDLE( HANDLE h = NULL );
         XHANDLE();
         ~XHANDLE();
    void CloseHandle();

public:
    HANDLE h;
};

inline
XHANDLE::XHANDLE( HANDLE h )
{
    this->h = h;
}

inline
XHANDLE::~XHANDLE()
{
    BOOL fClosed;

    if( h && h != INVALID_HANDLE_VALUE )
        fClosed = ::CloseHandle( h ),
        assert(fClosed);
}

inline
void XHANDLE::CloseHandle()
{
    ::CloseHandle( h );
    h = NULL;
}


class CondVar
{
public:
    CondVar();
    ~CondVar();
    void Enter();
    void Wait();
    void Release();
    void ReleaseAll();
    void Leave();

public:
    class Guard;
    class ReverseGuard;

private:
    LONG volatile     m_lOwnerCounter;
    DWORD volatile    m_dwWaitingForSignal;
#if !defined(NDEBUG)
    DWORD volatile    m_dwOwningThreadId;
#endif
    XHANDLE           m_xhEvtEnter,
                      m_xhSemRelease;
};


CondVar::CondVar() :
    m_xhEvtEnter(   AutoThrowResourceException( ::CreateEvent( NULL, FALSE, FALSE, NULL ) ) ),
    m_xhSemRelease( AutoThrowResourceException( ::CreateSemaphore( NULL, 0, 0x7FFFFFFF, NULL ) ) )
{
    ONDEBUG(m_dwOwningThreadId = 0);

    m_lOwnerCounter      = 0;
    m_dwWaitingForSignal = 0;
}

CondVar::~CondVar()
{
}

void CondVar::Enter()
{
    if( (DWORD)::InterlockedIncrement( &m_lOwnerCounter ) > 1 )
        for( ; ::WaitForSingleObject( m_xhEvtEnter.h, INFINITE ) != WAIT_OBJECT_0; assert(false) );

    assert(m_lOwnerCounter != 0 && m_dwOwningThreadId == 0);
    ONDEBUG(m_dwOwningThreadId = GetCurrentThreadId());
}

void CondVar::Wait()
{
    DWORD dwOwnerCounter     = (DWORD)m_lOwnerCounter,
        dwWaitingForSignal = ++m_dwWaitingForSignal;

    assert(dwOwnerCounter >= dwWaitingForSignal && m_dwOwningThreadId == GetCurrentThreadId());
    ONDEBUG(m_dwOwningThreadId = 0);

    if( dwOwnerCounter > dwWaitingForSignal )
        for( ; !::SetEvent( m_xhEvtEnter.h ); assert(false) );

    HANDLE ahWait[2] = { m_xhEvtEnter.h, m_xhSemRelease.h };

    for( ; ::WaitForMultipleObjects( 2, ahWait, TRUE, INFINITE ) != WAIT_OBJECT_0; assert(false) );
    assert((DWORD)m_lOwnerCounter > m_dwWaitingForSignal && m_dwOwningThreadId == 0);
    ONDEBUG(m_dwOwningThreadId = GetCurrentThreadId());
}

void CondVar::Release()
{
    assert((DWORD)m_lOwnerCounter > m_dwWaitingForSignal && m_dwOwningThreadId == GetCurrentThreadId());

    if( m_dwWaitingForSignal != 0 )
    {
        m_dwWaitingForSignal--;
        for( ; !::ReleaseSemaphore( m_xhSemRelease.h, 1, NULL ); assert(false) );
    }
}

void CondVar::ReleaseAll()
{
    DWORD dwWaitingForSignal;

    assert((DWORD)m_lOwnerCounter > m_dwWaitingForSignal && m_dwOwningThreadId == GetCurrentThreadId());

    if( (dwWaitingForSignal = m_dwWaitingForSignal) != 0 )
    {
        m_dwWaitingForSignal = 0;
        for( ; !::ReleaseSemaphore( m_xhSemRelease.h, (LONG)dwWaitingForSignal, NULL ); assert(false) );
    }
}

void CondVar::Leave()
{
    assert((DWORD)m_lOwnerCounter > m_dwWaitingForSignal && m_dwOwningThreadId == GetCurrentThreadId());
    ONDEBUG(m_dwOwningThreadId = 0);

    DWORD dwOwnerCounter = (DWORD)::InterlockedDecrement( &m_lOwnerCounter );

    if( dwOwnerCounter > m_dwWaitingForSignal )
        for( ; !::SetEvent( m_xhEvtEnter.h ); assert(false) );
}