TnbSharedMemory.h

[詳解]

#pragma once
#include "TnbDef.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CSharedMemoryManager : CCopyImpossible
{
//protected:
    HANDLE  m_hFileMap;         
    LPVOID  m_lpvMapAdds;       
    bool    m_boCanClose;       
public:
 
    explicit CSharedMemoryManager(bool boCanClose = false)
    {
        m_lpvMapAdds = NULL;
        m_hFileMap = NULL;
        m_boCanClose = boCanClose;
    }
 
    virtual ~CSharedMemoryManager(void)
    {
        if ( m_boCanClose )
        {
            Close();
        }
        else
        {
            if ( m_lpvMapAdds != NULL )
            {
                ::UnmapViewOfFile(m_lpvMapAdds);
            }
        }
    };
 
    bool HasMemory(void)
    {
        return Get() != NULL;
    }
 
    LPVOID Get(void)
    {
        if ( m_lpvMapAdds != NULL )
        {
            // このクラスの共有メモリはすでにオープンしている
            return m_lpvMapAdds;
        }
        return NULL;
    }
 
    int Open(LPCTSTR lpszMemName, UINT uMemSize)
    {
        if ( m_lpvMapAdds != NULL )
        {
            // このクラスの共有メモリはすでにオープンしている
            Close();
        }
        // 共有メモリハンドルオープン
        m_hFileMap = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, uMemSize, lpszMemName);
        if ( m_hFileMap != NULL )
        {
            // 共有メモリオープン成功！
            DWORD dwError = ::GetLastError();
            //　マッピングする。
            m_lpvMapAdds = ::MapViewOfFile(m_hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
            if ( m_lpvMapAdds != NULL )
            {
                return (dwError == ERROR_ALREADY_EXISTS) ? 1/*既存*/ : 0/*新規*/;
            }
            // マッピング失敗
            _GetLastError("MapViewOfFile");
            ::CloseHandle(m_hFileMap);      // ハンドルを閉じなくては
            m_lpvMapAdds = NULL;
        }
        else
        {
            // 共有メモリオープン失敗
            _GetLastError("CreateFileMapping");
            m_lpvMapAdds = NULL;
        }
        return -1;
    }
 
    bool Close(void)
    {
        if ( m_lpvMapAdds == NULL )
        {
            // 開いていなかった（未使用だった）
            return true;
        }
        if ( ! ::UnmapViewOfFile(m_lpvMapAdds) )
        {
            //アンマップド失敗
            return false;
        }
        m_lpvMapAdds = NULL;
        if ( m_hFileMap != 0 )  //念のためチェック
        {
            if ( ! ::CloseHandle(m_hFileMap) )
            {
                //ハンドルがクローズできなかった           
                return false;
            }
        }
        return true;
    }
};
 
 
 
template<typename TYP>
class CSharedStructT : CCopyImpossible
{
    CSharedMemoryManager m_cSharedMem;  
    TYP*    m_pType;                    
    bool    m_boCanClose;               
 
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual void OnAction(TYP* P) = 0;
    };
 
    explicit CSharedStructT(bool boCanClose = true) : m_cSharedMem(boCanClose)
    {
        m_boCanClose = boCanClose;
        m_pType = NULL;
    }
 
    virtual ~CSharedStructT(void)
    {
        Close();
    }
 
    bool HasMemory(void) const
    {
        return m_pType != NULL;
    }
 
    operator TYP*(void)
    {
        return m_pType;
    }
 
    operator const TYP*(void) const
    {
        return m_pType;
    }
 
    TYP* operator->(void)
    {
        return m_pType;
    }
 
    const TYP* operator->(void) const
    {
        return m_pType;
    }
 
    bool Open(LPCTSTR lpMemName = NULL, IListener* piListener = NULL)
    {
        int iRc = m_cSharedMem.Open(lpMemName, sizeof(LONG) * 2 + sizeof(TYP));
        if ( iRc < 0 )
        {
            return false;
        }
        LONG* P = static_cast<LONG*>(m_cSharedMem.Get());
        m_pType = reinterpret_cast<TYP*>(&P[2]);
        if ( iRc == 0 )
        {
            //==新規
            if ( piListener != NULL )
            {
                piListener->OnAction(m_pType);
            }
            P[1]++; //参照カウンタ
            P[0] = 1;   //初期化済み
        }
        else
        {
            //==既存
            while ( P[0] != 1 )
            {
                ::Sleep(1); 
            }
            P[1]++; //参照カウンタ
        }
        return true;
    }
 
    void Close(IListener* piListener = NULL)
    {
        LONG* P = static_cast<LONG*>(m_cSharedMem.Get());
        if ( P == NULL ){ return; }
        while ( true )
        {
            while ( P[0] != 1 )
            {
                ::Sleep(1); 
            }
            if ( ::InterlockedDecrement(&P[0]) == 0 )
            {
                break;
            }
        }
        if ( ::InterlockedDecrement(&P[1]) <= 0 )
        {
            //最後の一つ
            if ( piListener != NULL )
            {
                piListener->OnAction(m_pType);
            }
            if ( ! m_boCanClose )
            {
                //閉じない、だからカウンタは１のままに
                P[1] = 1;
            }
            P[0] = 1;
            if ( m_boCanClose )
            {
                //閉じる
                m_cSharedMem.Close();
            }
        }
        else
        {
            P[0] = 1;
            m_cSharedMem.Close();
        }
        m_pType = NULL;
    }
};
 
 
 
}; // TNB