cMailslot.h

Go to the documentation of this file.

//
 
#ifndef _INC_cMailslot_H
#define _INC_cMailslot_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
 
#if !defined(UNDER_CE)
#include "../WinAPI/cOverlappedIO.h"
#include "GrayCore/include/cOSHandle.h"
#include "GrayCore/include/cHeap.h"
#include "GrayCore/include/cFilePath.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/cStream.h"
 
#ifdef __linux__
#include <mqueue.h>
struct _SECURITY_ATTRIBUTES;
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cMailslot);
 
        class GRAYLIB_LINK cMailslot
        {
 
        public:
                static const FILECHAR_t* k_pszServerDefault;    // _GT(".")
 
        protected:
                cStringF                m_sMailslotPath;        
#ifdef _WIN32
                cOSHandle               m_hMailSlot;
                cOverlappedIO   m_overlapped;
#else
                mqd_t m_q;      
#endif
 
        protected:
                cMailslot();
                virtual ~cMailslot();
 
                virtual HRESULT Connect(const FILECHAR_t* pszSlotName, const FILECHAR_t* pszServerName = nullptr, _SECURITY_ATTRIBUTES* pSa = nullptr) = 0;
 
                static StrLen_t GRAYCALL MakeMailslotPath(OUT FILECHAR_t* pszPath, const FILECHAR_t* pszSlotName, const FILECHAR_t* pszServerName = nullptr);
                static cStringF GRAYCALL MakeMailslotPath(const FILECHAR_t* pszSlotName, const FILECHAR_t* pszServerName = nullptr);
 
        public:
                virtual void Disconnect();
 
                cStringF get_MailslotPath() const
                {
                        return m_sMailslotPath;
                }
 
                bool isOpen() const
                {
#ifdef _WIN32
                        return m_hMailSlot.isValidHandle();
#else
                        return m_q != ((mqd_t)-1);
#endif
                }
 
                UNITTEST2_PREDEF(cMailslot);
        };
 
        class GRAYLIB_LINK cMailslotReader : public cMailslot, public cStreamInput
        {
 
        public:
                size_t m_nMaxMessageSize;       
                TIMESYSD_t m_nReadTimeout;      
 
        public:
                cMailslotReader();
                virtual ~cMailslotReader();
 
                virtual HRESULT Connect(const FILECHAR_t* pszSlotname, const FILECHAR_t* szServer = nullptr, _SECURITY_ATTRIBUTES* pSa = nullptr) override;
 
                virtual HRESULT ReadX(void* pbData, size_t nLengthMax) override;
                HRESULT ReadX(cHeapBlock& buffer, size_t nReasonableLengthMax = 0x1000);
 
                UINT GetMessageCount(size_t* pnNextMessageLength = nullptr);
                bool put_ReadTimeout(TIMESYSD_t nReadTimeout);
        };
 
        class GRAYLIB_LINK cMailslotWriter : public cMailslot, public cStreamOutput
        {
        public:
                cMailslotWriter();
                virtual ~cMailslotWriter();
 
                HRESULT WriteMailslot(const void* pbData, size_t nDataSize, TIMESYSD_t nTimeWait);
 
                HRESULT ConnectSA(cStringF sMailslotPath, _SECURITY_ATTRIBUTES* pSa);
 
                virtual HRESULT Connect(const FILECHAR_t* pszSlot, const FILECHAR_t* szServer = nullptr, _SECURITY_ATTRIBUTES* pSa = nullptr) override;
                virtual HRESULT WriteX(const void* pbData, size_t nDataSize) override
                {
                        return WriteMailslot(pbData, nDataSize, cTimeSys::k_INF);
                }
 
                HRESULT ConnectWrite(const FILECHAR_t* pszSlot, const FILECHAR_t* pszServer, const void* pbData, size_t nDataSize, TIMESYSD_t nTimeWait = 0)
                {
                        HRESULT hRes = Connect(pszSlot, pszServer);
                        if (FAILED(hRes))
                        {
                                return hRes;
                        }
                        return WriteMailslot(pbData, nDataSize, nTimeWait);
                }
        };
};
#endif // UNDER_CE
#endif // _INC_cMailslot_H