TnbPipe.h

[詳解]

#pragma once
#include "TnbCommunication.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CPipe : public ICommunication, CCopyImpossible
{
    DEFSUPER(ICommunication);
 
public:
 
    CPipe(void) 
        : m_hRead(INVALID_HANDLE_VALUE), m_hWrite(INVALID_HANDLE_VALUE), m_dwPipeBufferSize(0), m_property(_T("Pipe"), TNBVIW_KIND_PIPE)
    {
        m_isActiveClient = false;
    }
 
    virtual ~CPipe(void)
    {
        Close();
    }
 
    void SetPipeBufferSize(DWORD dwSize = 0)
    {
        m_dwPipeBufferSize = dwSize;
    }
 
    virtual const TProperty& GetProperty(void) const
    {
        return m_property;
    }
 
    virtual bool SetReceiveTimeout(DWORD to)
    {
        return false;
    }
 
    void SettingNamedPipe(LPCTSTR lpszPipeName, bool isClient)
    {
        m_pipeName = lpszPipeName;
        m_isModeClient = isClient;
    }
 
    virtual bool Open(void)
    {
        Close();
        //
        if ( m_pipeName.IsEmpty() )
        {
            //-- 名無しパイプオープン
            SECURITY_ATTRIBUTES sa;
            sa.lpSecurityDescriptor = NULL;
            sa.nLength = sizeof(SECURITY_ATTRIBUTES);
            sa.bInheritHandle = TRUE;
            return !! ::CreatePipe(&m_hRead, &m_hWrite, &sa, m_dwPipeBufferSize);
        }
        if ( m_isModeClient )
        {
            //== 名前付きパイプクライアントオープン(ここではオープンしない)
            m_isActiveClient = true;
            m_hRead = INVALID_HANDLE_VALUE;
            m_hWrite = INVALID_HANDLE_VALUE;
            return true;
        }
        //== 名前付きパイプサーバーオープン
        m_hRead = ::CreateNamedPipe(m_pipeName, 
            PIPE_ACCESS_DUPLEX, //オープンモード
            PIPE_TYPE_BYTE | PIPE_WAIT, //パイプモード
            1, //パイプに対する最大インスタンス
            m_dwPipeBufferSize,//出力バッファ
            m_dwPipeBufferSize,//入力バッファ
            0,//タイムアウト
            NULL);
        m_hWrite = INVALID_HANDLE_VALUE;
        return m_hRead != INVALID_HANDLE_VALUE;
    }
 
    virtual void Close(void)
    {
        if ( m_hRead != INVALID_HANDLE_VALUE )
        {
            ::CloseHandle(m_hRead);
            m_hRead = INVALID_HANDLE_VALUE;
        }
        if ( m_hWrite != INVALID_HANDLE_VALUE )
        {
            ::CloseHandle(m_hWrite);
            m_hWrite = INVALID_HANDLE_VALUE;
        }
        m_isActiveClient = false;
    }
 
    virtual bool IsOpened(void) const
    {
        if ( m_isActiveClient )
        {
            return true;
        }
        return m_hRead != INVALID_HANDLE_VALUE;
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        m_OnActiveClient();
        //
        DWORD dwWriten;
        if ( ::WriteFile(GetWriteHandle(), P, down_cast<DWORD>(size), &dwWriten, NULL) )
        {
            return dwWriten;
        }
        return INVALID_SIZE;
    }
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        size_t l = GetReceivingDataSize();
        if ( l == 0 )
        {
            return 0;
        }
        if ( l != INVALID_SIZE )
        {
            if ( size < l )
            {
                l = size;
            }
            DWORD dwReadBytes = 0;
            if ( !! ::ReadFile(m_hRead, _P, down_cast<DWORD>(l), &dwReadBytes, NULL) )
            {
                return dwReadBytes;
            }
            _GetLastError("ReadFile");
        }
        return INVALID_SIZE;
    }
 
    virtual size_t GetReceivingDataSize(void) const
    {
        m_OnActiveClient();
        if ( m_hRead == INVALID_HANDLE_VALUE )
        {
            return INVALID_SIZE;
        }
        //
        DWORD dwAvail;
        if ( ::PeekNamedPipe(m_hRead, NULL, 0, NULL, &dwAvail, NULL) )
        {
            return dwAvail;
        }
        if ( ! m_pipeName.IsEmpty() && m_isModeClient )
        {
            m_hRead = INVALID_HANDLE_VALUE;
        }
        _GetLastError("PeekNamedPipe");
        return INVALID_SIZE;
    }
 
    virtual EState Check(void) const
    {
        m_OnActiveClient();
        return IsConnect() ? CONNECTING : CLOSED;
    }
 
    virtual void Purge(void) 
    {
    }
 
    HANDLE GetReadHandle(void) const
    {
        return m_hRead;
    }
 
    HANDLE GetWriteHandle(void) const
    {
        if ( m_pipeName.IsEmpty() )
        {
            return m_hWrite;
        }
        return m_hRead;
    }
 
private:
    // 名前付きパイプクライアントがアクティブの時の処理
    void m_OnActiveClient(void) const
    {
        if ( m_isActiveClient && ! m_pipeName.IsEmpty() && m_isModeClient )
        {
            if ( m_hRead == INVALID_HANDLE_VALUE )
            {
                // パイプクライアントをオープン
                m_hRead = ::CreateFile(m_pipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
            }
        }
    }
 
    CStr                m_pipeName;         
    bool                m_isModeClient;     
    bool                m_isActiveClient;   
    mutable HANDLE      m_hRead;            
    HANDLE              m_hWrite;           
    DWORD               m_dwPipeBufferSize; 
    TProperty           m_property;         
};
 
 
 
}; // TNB