//
// FILE: SynchExceptionMgr.h
//
// Copyright (c) 1997 by Aaron Michael Cohen and Mike Woodring
//
/////////////////////////////////////////////////////////////////////////

#ifndef __SynchExceptionMgr__
#define __SynchExceptionMgr__

#include "ExceptionMgr.h"

// Synchronous exception manager.  This deriviation of the exception
// manager schedules a procedure call to be executed in the context
// of the thread being notified of an exception.
//
class CSynchronousExceptionManager : public CExceptionManager
{
    public:
        virtual BOOL RegisterHandler( CExceptionHandler *pHandler );
        virtual void UnregisterHandler( CExceptionHandler *pHandler );

    protected:
        virtual void    NotifyExceptionHandler(
                            CExceptionHandler                       *pHandler,
                            CExceptionHandler::NOTIFICATION_CONTEXT Context,
                            DWORD                                   dwExceptionCode
                        );

    private:
        class CHandlerInfo
        {
            public:
                CHandlerInfo( CExceptionHandler *pHandler )
                    : m_pHandler(pHandler),
                      m_hThread(0),
                      m_dwThreadId(GetCurrentThreadId())
                {
                    DuplicateHandle(
                        GetCurrentProcess(),
                        GetCurrentThread(),
                        GetCurrentProcess(),
                        &m_hThread,
                        0,
                        FALSE,
                        DUPLICATE_SAME_ACCESS
                    );
                }

                ~CHandlerInfo()
                {
                    if( m_hThread )
                    {
                        CloseHandle(m_hThread);
                    }
                }

                CExceptionHandler *GetHandler( void )
                {
                    return(m_pHandler);
                }

                HANDLE GetThreadHandle( void )
                {
                    return(m_hThread);
                }

                DWORD GetThreadId( void )
                {
                    return(m_dwThreadId);
                }

            private:
                CExceptionHandler  *m_pHandler;
                HANDLE              m_hThread;
                DWORD               m_dwThreadId;
        };

        typedef BOOL (* PHANDLERINFO_ITERATOR)(
                    CHandlerInfo   *pHandlerInfo,
                    DWORD           dwArg1,
                    DWORD           dwArg2,
                    DWORD           dwArg3
                );

        void    ForEachHandler(
                    PHANDLERINFO_ITERATOR   pfxnIterator,
                    DWORD                   dwArg1 = 0,
                    DWORD                   dwArg2 = 0,
                    DWORD                   dwArg3 = 0
                );

        static BOOL RemoveHandlerInfo(
                        CHandlerInfo   *pHandler,
                        DWORD           dwArg1,
                        DWORD           dwArg2,
                        DWORD           dwARg3
                    );

        static BOOL ScheduleAPC(
                        CHandlerInfo   *pHandler,
                        DWORD           dwArg1,
                        DWORD           dwArg2,
                        DWORD           dwARg3
                    );

        static void APCCallback( void );

    private:
        static CExceptionHandler                       *s_APCHandler;
        static CExceptionHandler::NOTIFICATION_CONTEXT  s_APCContext;
        static DWORD                                    s_APCExceptionCode;

    private:
        CMclCritSec                     m_CritSec;
        CMclLinkedList<CHandlerInfo *>  m_HandlerInfo;
};

#endif // __SynchExceptionMgr__