cProtocol.h

Go to the documentation of this file.

//
//
#ifndef _INC_cProtocol_H
#define _INC_cProtocol_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/IUnkObject.h"
#include "GrayCore/include/cRefPtr.h"
#include "GrayCore/include/cIUnkPtr.h"
#include "GrayCore/include/StrArg.h"
 
namespace GrayLib
{
        struct GRAYLIB_LINK IProtocolFactory;
 
        class GRAYLIB_LINK cProtocolStream : public IUnkObject
        {
 
        public:
                IProtocolFactory* const m_pProtocolFactory;     
                IUnkObject* const m_pServerConnection;          
                HASHCODE_t const m_nHashCode;           
 
        protected:
                cStreamInput* m_pStreamInp;             
                cStreamOutput* m_pStreamOut;    
 
                cString m_sName;                                
 
        public:
                cProtocolStream(IProtocolFactory* pProtocolFactory, IUnkObject* pServerConnection, cStreamInput* pStreamInp, cStreamOutput* pStreamOut);
                virtual ~cProtocolStream();
 
                HASHCODE_t get_HashCode() const noexcept
                {
                        return m_nHashCode;
                }
                STDMETHOD_(HASHCODE_t, get_HashCodeX)() const noexcept override
                {
                        return get_HashCode();
                }
                STDMETHOD_(cString, get_Name)() const override
                {
                        return m_sName;
                }
                STDMETHOD_(cStringA, get_SymName)() const override
                {
                        return StrArg<char>(get_HashCode(), (RADIX_t)0x10);
                }
 
                bool isConnected() const
                {
                        return(m_pStreamOut != nullptr);
                }
                cStreamInput* get_StreamInp() const
                {
                        return m_pStreamInp;
                }
                cStreamOutput* get_StreamOut() const
                {
                        return m_pStreamOut;
                }
                virtual size_t get_ProtocolMaxMessageSize() const;
 
                virtual HRESULT DisposeThis()
                {
                        if (m_pStreamOut != nullptr)
                        {
                                m_pStreamInp = nullptr;
                                m_pStreamOut = nullptr;
                        }
                        ASSERT(!isConnected());
                        return S_OK;
                }
                virtual HRESULT OnTickStream()
                {
                        if (m_pStreamOut == nullptr)
                        {
                                // The protocol terminated itself. isConnected()
                                return HRESULT_WIN32_C(WSAECONNABORTED);
                        }
                        return S_OK;
                }
 
                virtual HRESULT ProcessStreamPacket() // = 0;
                {
                        ASSERT(m_pStreamInp != nullptr);
                        ASSERT(false);  // should not get here.
                        return HRESULT_WIN32_C(ERROR_WRITE_FAULT);
                }
        };
 
        typedef cIUnkPtr<cProtocolStream> cProtocolStreamPtr;
 
        struct GRAYLIB_LINK IProtocolFactory
        {
 
        public:
                virtual ~IProtocolFactory()
                {}
                virtual const char* get_ProtocolName() const = 0;
                virtual size_t get_ProtocolMaxMessageSize() const
                {
                        return 8 * 1024;
                }
                virtual HRESULT TestProtocol(const BYTE* pszPrefixData, size_t iPrefixLen) const = 0;
                virtual cProtocolStreamPtr CreateProtocolStream(IUnkObject* pServerConnection, cStreamInput* pStreamInp, cStreamOutput* pStreamOut) = 0;
        };
 
        class GRAYLIB_LINK cProtocolFactories
        {
        protected:
                cArrayPtr<IProtocolFactory> m_aProtocols;                       
        public:
                bool AddProtocol(IProtocolFactory* pProtocolFactory);
                HRESULT TestProtocol(const BYTE* pPrefixData, size_t iPrefixLen, OUT IProtocolFactory*& rpProtocolFactory) const;
        };
};
 
#endif