cSharedMemory.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSharedMemory_H
#define _INC_cSharedMemory_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cSingleton.h"
#include "GrayCore/include/cOSProcess.h"
#include "GrayCore/include/cInterlockedVal.h"
#include "GrayCore/include/cThreadLock.h"
 
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSharedMemory);
 
#pragma pack(1)
        struct GRAYLIB_LINK cSharedMemory  
        {
 
                PROCESSID_t m_nMasterId;                                        
                cInterlockedVal<PROCESSID_t> m_LockId;          
                PROCESSID_t m_nDestId;                                          
                size_t m_nLength;                                                       
                BYTE m_Data[1];                                                         
 
                UNITTEST_FRIEND(cSharedMemory);
        };
#pragma pack()  // end packing.
 
 
        class GRAYLIB_LINK cSharedContext : public cSingleton<cSharedContext>
        {
 
        public:
                static const GChar_t* const k_pszMutexName;             
 
                const PROCESSID_t m_Id;                         
                cSharedMemory* m_pMem;                          
                cThreadLockMutex m_Mutex;                       
 
        public:
                cSharedContext();
                virtual ~cSharedContext();
 
                bool isLockedByMe() const noexcept
                {
                        if (m_pMem == nullptr)
                                return false;
                        return (m_pMem->m_LockId.get_Value() == m_Id);                          
                }
        };
 
        class GRAYLIB_LINK cSharedAccess
        {
 
        public:
                cSharedContext& m_c;
                bool m_bLockedByMe;
 
        public:
                cSharedAccess();
                ~cSharedAccess();
 
                HRESULT ReadWrite(cHeapBlock& reader, const cMemBlock& writer, TIMESYSD_t nWaitTime=0);
        };
 
        class GRAYLIB_LINK cSharedMaster : public cSharedAccess
        {
                // Only the master uses this class.
                // stack based. Locks shared memory for my use.
 
        public:
                HRESULT ReadWrite(cHeapBlock& reader, PROCESSID_t nDestId, const cMemBlock& writer, TIMESYSD_t nWaitTime = 0);
        };
}
#endif