TnbCommunication.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbReportViewer.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
struct ICommunication
{
    enum EState
    {
        OPENNING,   
        CONNECTING, 
        CLOSED,     
    };
 
    struct TProperty
    {
        CStr        typeName;               
        DWORD       typeId;                 
        DWORD       receiveTimeout;         
        size_t      sendPacketSize;         
        size_t      receivePacketSize;      
        TProperty(LPCTSTR lpszName, DWORD id, DWORD to = 0, size_t sendSize = INVALID_SIZE, size_t recvSize = INVALID_SIZE)
            : typeName(lpszName), typeId(id), receiveTimeout(to), sendPacketSize(sendSize), receivePacketSize(INVALID_SIZE)
        {}//デフォルトは、受信待ち時間０ms、送受信パケットサイズ、なし。
    };
 
    virtual ~ICommunication(void) {}
 
    virtual const TProperty& GetProperty(void) const = 0;
 
    virtual bool SetReceiveTimeout(DWORD to) = 0;
 
    virtual bool Open(void) = 0;
 
    virtual void Close(void) = 0;
 
    virtual bool IsOpened(void) const = 0;
 
    virtual bool IsConnect(void) const { return IsOpened(); }
 
    virtual bool CanSend(void) const { return IsOpened(); }
 
    virtual bool CanReceive(void) const { return IsOpened(); }
 
    virtual size_t Send(size_t size, LPCVOID P) = 0;
 
    virtual size_t Receive(size_t size, LPVOID _P) = 0;
 
    virtual size_t GetReceivingDataSize(void) const { return INVALID_SIZE; }
 
    virtual EState Check(void) const { return IsOpened() ? (IsConnect() ? CONNECTING : OPENNING) : CLOSED; }
 
    virtual void Purge(void) {}
};
 
 
 
#ifndef _WIN32_WCE
 
inline size_t BlockingReadFile(HANDLE hFile, HANDLE hEvent, DWORD wait, size_t size, LPVOID _P)
{
    OVERLAPPED overLapped = { 0 }; 
    HANDLE hMyEvent = NULL;
    if ( hEvent == NULL )
    {
        hMyEvent = ::CreateEvent(NULL, FALSE, TRUE, NULL); 
        ::ResetEvent(hMyEvent);
        hEvent = hMyEvent;
    }
    overLapped.hEvent = hEvent; 
    DWORD dwRc = ULONG_MAX;
    DWORD work = ULONG_MAX;
    if ( ::ReadFile(hFile, _P, ToDword(size), &dwRc, &overLapped) )
    {
        // 成功
    }
    else if ( ::GetLastError() == ERROR_IO_PENDING )
    {
        // 非同期読み取り操作の結果をチェックする。
        ::Sleep(0);
        if( ::GetOverlappedResult(hFile, &overLapped, &work, FALSE) )
        {
            dwRc = work; // 成功
        }
        else if ( ::GetLastError() == ERROR_IO_INCOMPLETE )
        {
            switch ( ::WaitForSingleObject(overLapped.hEvent, wait) )
            {
            case WAIT_OBJECT_0:
                if ( ::GetOverlappedResult(hFile, &overLapped, &work, FALSE) )
                {
                    dwRc = work; // 成功
                }
                break;
            case WAIT_TIMEOUT:
                dwRc = 0;
                break;
            case WAIT_ABANDONED:
            case WAIT_FAILED:
            default:
                break;
            }
        }
    }
    ::CancelIo(hFile);
    if ( hMyEvent != NULL )
    {
        ::CloseHandle(hMyEvent);
    }
    return dwRc;
}
 
#else // _WIN32_WCE
 
inline size_t BlockingReadFile(HANDLE hFile, HANDLE hEvent, DWORD wait, size_t size, LPVOID _P)
{
    DWORD dwRc = ULONG_MAX;
    if ( ::ReadFile(hFile, _P, ToDword(size), &dwRc, NULL) )
    {
        return dwRc;
    }
    _GetLastError("ReadFile");
    return INVALID_SIZE;
}
 
#endif // _WIN32_WCE
 
 
 
 
}; // TNB