CThread.h

Go to the documentation of this file.

#pragma once
#ifndef AXPIPE_CTHREAD_H
#define AXPIPE_CTHREAD_H

#include "AxPipe.h"
#include "AxPipeAssert.h"

namespace AxPipe {
    using Assert::OutputDebugStringF;

class CNoThread {
protected:
    bool m_fExit;                           
    bool m_fAutoDeleteSink;                 
    
    virtual void WorkStart() {              
    }
    virtual void WorkSignal() {
        Work();
    }
    virtual void WorkEnd() {
    }
    virtual void WorkWait() {
    }
    virtual void WorkExitWait() {
    }
    virtual void Work() = 0;
public:
    CNoThread() {
        m_fAutoDeleteSink = m_fExit = false;
    }
    void WaitForIdle() {
        WorkStart();
        WorkEnd();
    }
    static void *ClassId() {
        static int i;
        return &i;
    }

    virtual void *RTClassId() {
        return ClassId();
    }
};

//static inline DWORD WINAPI CThreadProc(LPVOID lpParam);

#pragma warning (push)
// Disable 'this' : used in base member initializer list
#pragma warning (disable: 4355)
template <class T> class CThreadNoRun : public CThreadMain<T> {
    CThreadSync m_ThreadSync;               

public:
    
    virtual ~CThreadNoRun() {
        if (!m_fExit) {
            SetError(ERROR_CODE_INTERNAL, ERROR_MSG_INTERNAL, _T("CThread::~CThread Exit() not called"));
        }
    }

public:
    void WorkStart() {
        m_ThreadSync.WorkStart();
    }

    void WorkSignal() {
        m_ThreadSync.WorkSignal();
    }
    
    void WorkWait() {
        m_ThreadSync.WorkWait();
    }
    
    void WorkEnd() {
        m_ThreadSync.WorkEnd();
    }
    
    virtual void WorkExitWait() {
        Wait();
    }
};

template <class T> class CThread : public CThreadNoRun<T> {
public:
    CThread() {
        Run();
    }
private:
    virtual int Main() {
        OutputDebugStringF(_T("CThread()::Main() ID=%X\n"), GetCurrentThreadId());
        while (!m_fExit) {
            // Elesewhere WorkStart() and WorkSignal() will be called
            WorkWait();                     // Wait for more to do
            Work();
            WorkEnd();
        }
        OutputDebugStringF(_T("CThread()::Main() ID=%X WaitForIdle()...\n"), GetCurrentThreadId());
        WaitForIdle();                      // Ensure that the last work is done.
        // This is to handle a memory leak bug in Win32, where an exiting
        // thread being a fibre does not clean up after itself. See Q185231 or KB185231.
        // If we have successfully allocated a TLS index
        if (AxPipe::dwTlsIndex != TLS_OUT_OF_INDEXES) {
            // If we have converted this thread into a fiber
            if (TlsGetValue(AxPipe::dwTlsIndex) != NULL) {
                // Then we do the free to avoid the memory leak as per above.
                LocalFree(GetCurrentFiber());
            }
        }
        OutputDebugStringF(_T("CThread()::Main() ...exiting thread ID=%X\n"), GetCurrentThreadId());
        return 0;
    }

};

template <class T> class CThreadSource : public CThreadMain<T> {
private:
    virtual int Main() {
        Open()->Drain()->Close()->Plug();
        return 0;
    }
};

#pragma warning (pop)

}; // namespace AxPipe
#endif AXPIPE_CTHREAD_H

---