warsvrwin32eventthread.h

ftpserver very good sample

/** 

    Simple Win32 thread-pool to get around the
    64 socket limit in event-wait calls.

    Support class for WarSvrWin32NtEngine
*/

#ifndef WAR_SVR_WIN32_EVENT_THREAD_H
#define WAR_SVR_WIN32_EVENT_THREAD_H

/* SYSTEM INCLUDES */


/* PROJECT INCLUDES */

#ifndef WAR_SOCKET_H
#   include "WarSocket.h"
#endif

#ifndef WAR_SMART_POINTER_H
#   include "WarSmartPointer.h"
#endif


/* LOCAL INCLUDES */


/* FORWARD REFERENCES */



#ifdef __cplusplus
extern "C" 
{
#endif
/****************** BEGIN OLD STYLE C spesific ********/


/****************** END OLD STYLE C spesific **********/
#ifdef __cplusplus 
}
#endif

/****************** BEGIN C++ spesific ****************/

#ifdef __cplusplus

class WarSvrWin32EventThreadTask : public WarSmartPointer
{
public:
    enum EventTypesE
    {
        QUEUE_SOCKET,
        REMOVE_SOCKET,
        SHUTDOWN,
        INVALID
    };

    WarSvrWin32EventThreadTask()
        : mTask(INVALID),
        mSocket(WAR_INVALID_SOCKET),
        mCompletionPort(0),
        mNumberOfBytesTransferred(0),
        mCompletionKey(NULL),
        mpOverlapped(NULL),
        mEvent(NULL)
    {}

    ~WarSvrWin32EventThreadTask()
    {
        if (mEvent)
            ::CloseHandle(mEvent);
    }

    bool operator == (const WarSvrWin32EventThreadTask& from)
    {
        return mSocket == from.mSocket;
    }

    bool operator < (const WarSvrWin32EventThreadTask& from)
    {
        return mSocket < from.mSocket;
    }

    EventTypesE mTask; // Command to queue
    war_socket_t mSocket; // Socket to handle
    HANDLE mCompletionPort;            // handle to an I/O completion port
    DWORD mNumberOfBytesTransferred; // bytes transferred
    ULONG mCompletionKey;           // completion key 
    LPOVERLAPPED mpOverlapped;      // overlapped buffer
    HANDLE  mEvent;
};


class WarSvrWin32EventThread : public WarSmartPointer
{
public:
    enum ConstantsE
    {
        MAX_HANDLES = 64
    };
    typedef WarPtrWrapper<WarSvrWin32EventThreadTask> task_ptr_t;
    typedef std::set<task_ptr_t> task_set_t;
    
    // LIFECYCLE
    
    /**
    * Default constructor.
    */
    WarSvrWin32EventThread(void)
        throw(WarException);
   
    /**
    * Destructor.
    */
    ~WarSvrWin32EventThread(void);
    
    // OPERATORS   
    // OPERATIONS  
    
    void Create(); // Initialzies the object
    void QueueRequest(task_ptr_t& taskPtr);
    void RemoveRequest(const war_socket_t sck);
    void Shutdown();

    // ACCESS
    // INQUIRY

    size_t GetNumQueued(bool doLock = true);
    bool HasCapacity()
    {
        return GetNumQueued() < (MAX_HANDLES -1);
    }


protected:
    task_set_t mTasks; // Sockets in use by the thread
    HANDLE mEvent;
    bool bDone;
private:
    static DWORD WINAPI ThreadProc(LPVOID lpParameter);
    void Run();
    void Execute(task_ptr_t& taskPtr);
    
    WarCriticalSection mLock;
};

/* INLINE METHODS */

/* EXTERNAL REFERENCES */

#endif /* __cplusplus */

/****************** END C++ spesific ******************/

#endif  /* WAR_SVR_WIN32_EVENT_THREAD_H_ */