cXProtocol.h

Go to the documentation of this file.

//
//
#ifndef _INC_cXProtocol_H
#define _INC_cXProtocol_H 0x1E // This is the version stamp for the XProtocol
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Proto/cPingClient.h"
#include "../Scriptable/IScriptableObj.h"
#include "../Scriptable/cScriptableInterface.h"
 
#include "GrayCore/include/cAtom.h"
#include "GrayCore/include/cFile.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cStreamQueue.h"
 
#ifdef USE_DEBUG_LOG
#define USE_XPROTO_LOGFILE              // log to a special file to keep messages isolated from the rest of the logging system
#endif
 
namespace GrayLib
{
#ifdef USE_XPROTO_LOGFILE
        class cLogAppendFile;
        typedef cRefPtr<cLogAppendFile> cLogAppendFilePtr;
#endif
 
        class GRAYLIB_LINK cVariant;
        class GRAYLIB_LINK cScriptableInterfaceDynamic;
        class GRAYLIB_LINK cScriptTagDef;
        class GRAYLIB_LINK cXObject;
        typedef cRefPtr<cXObject> cXObjectPtr;
 
        enum XPROTO_TYPE_
        {
 
#define cXProtocolMsg(a,b,c) XPROTO_##a,
#include "cXProtocolMsg.tbl"
#undef cXProtocolMsg
 
                XPROTO_QTY,
 
                XPROTO_MASK = 0x0F,                     
                XPROTO_Request = 0x10,          
                XPROTO_LastUID = 0x20,          
                XPROTO_NextChunk = 0x20,        
                XPROTO_HashProp = 0x40,         
        };
        typedef BYTE XPROTO_t;  
 
        class GRAYLIB_LINK cXProtocolDataMgr
        {
 
        public:
                cStringF m_sFileRootDir;        
#ifdef USE_XPROTO_LOGFILE
                cLogAppendFilePtr m_pLogFile;   
#endif
 
        public:
                cXProtocolDataMgr();
                virtual ~cXProtocolDataMgr();
 
#ifdef USE_XPROTO_LOGFILE
                void SetLogFile(const FILECHAR_t* pszFilePath);
#endif
 
                virtual cScriptableInterfaceDef* FindInterfaceDef(cXObject* pObj, SCRIPTINTERFACEID_t bInterfaceID);
                virtual cXObjectPtr FindXObj(UID_t uid, SCRIPTINTERFACEID_t bInterfaceID = SCRIPTINTERFACEID_MAX, cScriptableInterfaceDef** ppInterfaceDef = nullptr);
        };
 
        class GRAYLIB_LINK cXProtocolBase
        {
 
        public:
                // General state info.
                static const size_t k_Packet_Size_Max = cStream::k_FILE_BLOCK_SIZE + 16;        // file blocks. Rx buffer must be at least this large.
                cXProtocolDataMgr* const m_pProtocolDataMgr;    
                bool m_bUseHashPropName;        
                cFile m_FileWork;                       
 
        public:
                cXProtocolBase(cXProtocolDataMgr* pProtocolDataMgr);
                virtual ~cXProtocolBase();
 
                cXProtocolDataMgr* get_DataMgr() const
                {
                        return this->m_pProtocolDataMgr;
                }
 
                static cStringA GRAYCALL GetMsgName(XPROTO_t bMsg);
 
                virtual bool isClientSide() const = 0;
                STDMETHOD_(cString, get_Name)() const = 0;
                STDMETHOD_(PLEVEL_TYPE, get_PrivLevel)() const = 0;
 
#ifdef USE_XPROTO_LOGFILE
                cLogProcessor* get_LogFile() const;     // Log internal stuff. Must watch out for feedback.
#endif
 
        };
 
        class GRAYLIB_LINK cXProtocolTx
        {
 
                friend class cXProtocolServerTx;
 
        protected:
                cXProtocolBase& m_rBase;                
                cStreamOutput* m_pStreamTx;             
                XPROTO_t m_bMsgBuilding;                
                bool m_bFileSending;                    
                int m_iMsgNumTx;                                
                UID_t m_uidLastTx;                              
 
        protected:
                void InitTx();
                HRESULT Send_MsgPropName(const ATOMCHAR_t* pszPropName);
 
                cStreamOutput& get_StreamTx() const
                {
                        ASSERT(m_pStreamTx != nullptr);
                        return *m_pStreamTx;
                }
 
        protected:
                cXProtocolTx(cXProtocolBase& rBase, cStreamOutput* pStreamTx);
                virtual ~cXProtocolTx();
 
                bool IsTxMsgBuilding() const
                {
                        // I am building a message or failed to complete a message.
                        return m_bMsgBuilding != XPROTO_NULL;
                }
 
                HRESULT Send_MsgHeader(XPROTO_t bMsg);
                HRESULT Send_MsgHeaderUID(XPROTO_t bMsg, UID_t uid);
                void Send_MsgEnd();
 
                HRESULT Send_Error(HRESULT hResRet, const cVariant& vVal);
 
                HRESULT Send_PropN(UID_t uid, const ATOMCHAR_t* pszPropName, const cVariant& vVal);
                HRESULT Send_PropN(cXObject* pObj, const ATOMCHAR_t* pszPropName, const cVariant& vValRet);
                HRESULT Send_PropN(cXObject* pObj, const cScriptableProp* pProp, const cVariant& vValRet);
 
                HRESULT Request_InvokeN(UID_t uid, const ATOMCHAR_t* pszPropName, const cVariant& vArgs);
                HRESULT Request_InvokeN(UID_t uid, const ATOMCHAR_t* pszPropName);
                HRESULT Request_InvokeN(cXObject* pObj, const ATOMCHAR_t* pszPropName, const cVariant& vArgs);
                HRESULT Request_InvokeN(cXObject* pObj, const ATOMCHAR_t* pszPropName);
                HRESULT Request_InvokeN(cXObject* pObj, const cScriptableMethod* pMethod, const cVariant& vArgs);
 
                HRESULT Send_FileChecked(const FILECHAR_t* pszSrcPath, const FILECHAR_t* pszDestName);
                HRESULT Send_File(const FILECHAR_t* pszSrcPath, const FILECHAR_t* pszDestName, FILE_SIZE_t nOffsetStart, FILE_SIZE_t nSize);
                HRESULT Send_FileNext();
        };
 
        class GRAYLIB_LINK cXProtocolRx
        {
 
        protected:
                cXProtocolBase& m_rBase;                
                cStreamInput* m_pStreamRx;              
                SCRIPTINTERFACEID_t m_bInterfaceIDUnk;  
 
                XPROTO_t m_bMsgReading;                 
                XPROTO_t m_bMsgReadPrev;                
                int m_iMsgNumRx;                                
                UID_t m_uidLastRx;                              
 
        protected:
                cXProtocolRx(cXProtocolBase& rBase, cStreamInput* pStreamRx);
                virtual ~cXProtocolRx();
 
                virtual HRESULT onX_Error(HRESULT hResRet, const cVariant& vVal) = 0;
 
                virtual HRESULT onXSet_Prop(cXObject* pObj, const cScriptableProp* pProp, const cVariant& vVal);
                virtual HRESULT onXReq_Invoke(cXObject* pObj, const cScriptableMethod* pMethod, const cVariant& vArgs, OUT cVariant& vValRet);
 
                // For simple apps that don't truly enumerate the props and methods. just use the names.
                virtual HRESULT onXSet_PropN(UID_t uidLastRx, const ATOMCHAR_t* pszPropName, ATOMCODE_t nPropName, const cVariant& vVal);
                virtual HRESULT onXReq_InvokeN(UID_t uidLastRx, const ATOMCHAR_t* pszMethodName, ATOMCODE_t nMethodName, const cVariant& vArgs);
 
                virtual HRESULT onXSet_File(const FILECHAR_t* pszReqName, size_t dwTotalLen);
 
                void InitRx();
                HRESULT ReadUID();
 
                HRESULT on_Error();
                HRESULT onSet_PropN();
                HRESULT onReq_InvokeN();
                HRESULT onSet_File();
                HRESULT onSet_FileNext();
 
                cStreamInput& get_StreamRx()
                {
                        ASSERT(m_pStreamRx != nullptr);
                        return *m_pStreamRx;
                }
                virtual HRESULT ProcessStreamRxMsg() = 0;
                virtual HRESULT ProcessStreamPacket();
        };
 
};
#endif  // _INC_cXProtocol_H