TnbOverlapReader.h

[詳解]

#pragma once
#include "TnbSync.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class COverlapReader : CCopyImpossible
{
public:
 
    COverlapReader(void) : m_hFile(INVALID_HANDLE_VALUE), m_hEvent(NULL), m_isOverLapping(false)
    {
        Zero(m_overLapped);
    }
 
    ~COverlapReader(void)
    {
        Detach();
        if ( m_hEvent != NULL )
        {
            ::CloseHandle(m_hEvent);
            m_hEvent = NULL; 
        }
    }
 
    void Attach(HANDLE hFile, size_t size)
    {
        EXCLUSIVE( &m_sync );
        m_Cancel();
        m_hFile = hFile;
        m_work.Resize(size);
    }
 
    void Detach(void)
    {
        EXCLUSIVE( &m_sync );
        m_Cancel();
        m_hFile = INVALID_HANDLE_VALUE;
        m_work.Free();
    }
 
    size_t Read(LPVOID _P, DWORD wait = 0)
    {
        EXCLUSIVE( &m_sync );
        size_t r = 0;
        if ( m_hFile != INVALID_HANDLE_VALUE && m_work.GetSize() > 0 )
        {
            if ( m_isOverLapping )
            {
                // 読み込み待機中
                r = m_GetResult(wait);
            }
            else
            {
                // 新規
                r = m_Read(m_work.GetSize(), m_work.Ref());
                if ( r == 0 )
                {
                    r = m_GetResult(wait);
                }
            }
            if ( r != INVALID_SIZE && r != 0 )
            {
                memcpy(_P, m_work.Ref(), m_work.GetSize());
            }
        }
        return r;
    }
 
protected:
 
    virtual bool OnRead(HANDLE hFile, LPVOID _P, size_t size, OVERLAPPED& overLapped)
    {
        DWORD d;
        bool r = !! ::ReadFile(hFile, _P, size, &d, &overLapped);
        return r && (size == d); 
    }
 
private:
 
    size_t m_Read(size_t size, LPVOID _P)
    {
        m_Cancel();
        Zero(m_overLapped);
        if ( m_hEvent == NULL )
        {
            m_hEvent = ::CreateEvent(NULL, FALSE, TRUE, NULL); 
            ::ResetEvent(m_hEvent);
        }
        m_overLapped.hEvent = m_hEvent; 
        DWORD work = ULONG_MAX;
        if ( OnRead(m_hFile, _P, size, m_overLapped) )
        {
            // 成功
            return size;
        }
        else if ( ::GetLastError() == ERROR_IO_PENDING )
        {
            // 非同期読み取り操作の結果をチェックする。
            ::Sleep(0);
            if( ::GetOverlappedResult(m_hFile, &m_overLapped, &work, FALSE) )
            {
                return work;
            }
            else if ( ::GetLastError() == ERROR_IO_INCOMPLETE )
            {
                m_isOverLapping = true;
                return 0;
            }
        }
        return INVALID_SIZE;
    }
    size_t m_GetResult(DWORD wait = 0)
    {
        if ( ! m_isOverLapping )
        {
            return INVALID_SIZE;
        }
        size_t result = INVALID_SIZE;
        DWORD r = 0;
        switch ( ::WaitForSingleObject(m_overLapped.hEvent, wait) )
        {
        case WAIT_OBJECT_0:
            if ( ::GetOverlappedResult(m_hFile, &m_overLapped, &r, FALSE) )
            {
                result = r; // 成功
                m_Cancel();
            }
            break;
        case WAIT_TIMEOUT:
            result = 0;
            break;
        case WAIT_ABANDONED:
        case WAIT_FAILED:
        default:
            m_Cancel();
            break;
        }
        return result;
    }
    void m_Cancel(void)
    {
        if ( m_isOverLapping )
        {
            ::CancelIo(m_hFile);
            m_isOverLapping = false;
        }
    }
    HANDLE          m_hEvent;       
    bool            m_isOverLapping;
    OVERLAPPED      m_overLapped;   
    HANDLE          m_hFile;        
    CWorkMem        m_work;         
    CSyncSection    m_sync;
};
 
 
 
class COverlapIoReader : public COverlapReader
{
    DEFSUPER(COverlapReader);
public:
 
    COverlapIoReader(void) : _super(), m_dwIoControlCode(0)
    {
    }
 
    void SetIoControlCode(DWORD code)
    {
        m_dwIoControlCode = code;
    }
 
protected:
    virtual bool OnRead(HANDLE hFile, LPVOID _P, size_t size, OVERLAPPED& overLapped)
    {
        DWORD dwByteReturn;
        BOOL ret = ::DeviceIoControl(hFile, m_dwIoControlCode, _P, size, _P, size, &dwByteReturn, &overLapped);
        return !! ret;
    }
private:
    DWORD m_dwIoControlCode;        
};
 
 
 
}; // TNB