www.pudn.com > DSPSample.rar > DSP.h

// DSP.h: interface for the DSP class. 
////////////////////////////////////////////////////////////////////// 
 
#ifndef _DSP_CLASS 
#define _DSP_CLASS 
 
#include  
#include  
#include  
#include  
 
#ifndef AFX_EXT_CLASS 
#define AFX_EXT_CLASS 
#endif 
 
#include "StdAfx.h" 
 
#ifdef UNIX_SYSTEM_ 
	#define TRUE			1 
	#define	FALSE			0 
 
	#ifndef BOOL 
		typedef BYTE			BOOL; 
	#endif 
	#ifndef DWORD 
		typedef unsigned long	DWORD; 
	#endif 
	#ifndef BYTE 
		typedef unsigned char	BYTE; 
	#endif 
	#ifndef SOCKET 
		typedef int				SOCKET; 
	#endif 
#endif 
 
#define SECT_MAX_SIZE	0xFFF			//分段传送时段的最大尺寸 
 
class AFX_EXT_CLASS DSPACT; 
 
//在所有的DSPACT派生类的头文件中必需包含的宏定义 
#define SELF_SERIALIZE(classid,className,base_className) \ 
	public: \ 
		virtual char* GetClassID()		{return classid;} \ 
		virtual bool  IsKindOf(char* lpClassName){return (::strcmp(className,lpClassName)==0);}\ 
	protected: \ 
		virtual BYTE  GetClassLevel()	{return (base_className::GetClassLevel()+1);} \ 
 
//返回DSPPACT派生类对象的函数的指针 
#define DSPGETOBJFUNC(varN)		DSPACT* (*varN)(const std::string& strID)		 
#define CASTDSPGETOBJFUNC		DSPACT* (*)(const std::string& strID)		 
 
//缓冲区分段接收函数的指针 
#define DSPSECTRECV(varN)		bool (*varN)(const char* const lpBuff,int nBuffLen,bool bLast) 
#define CASTDSPSECTRECV			bool (*)(const char* const lpBuff,int nBuffLen,bool bLast) 
 
//缓冲区分段传送函数的指针 
#define DSPSECTSEND(varN)		bool (*varN)(char** const lpBuff,int& nBuffLen,bool& bContinue) 
#define CASTDSPSECTSEND			bool (*)(char** const lpBuff,int& nBuffLen,bool& bContinue) 
 
//压缩函数的指针 
#define	DSPCOMPRESSFUNC(varN)	bool (*varN)(char** const lpBuff,int& nBuffLen) 
#define	CASTDSPCOMPRESSFUNC		bool (*)(char** const lpBuff,int& nBuffLen) 
 
//解压缩函数的指针 
#define DSPUNCOMPRESSFUNC(varN)	bool (*varN)(char** const lpBuff,int& nBuffLen,bool bStart) 
#define CASTDSPUNCOMPRESSFUNC	bool (*)(char** const lpBuff,int& nBuffLen,bool bStart) 
	 
 
class AFX_EXT_CLASS DSP   
{ 
public: 
	struct AFX_EXT_CLASS _DSPPACKET; 
private: 
	DSP(){}; 
	~DSP(){}; 
	friend struct _DSPPACKET; 
	struct _DSPHEADER; 
	struct _DSPATTRHEADER; 
	struct _DSPVALUEHEADER; 
	struct _DSPACTREG; 
	static std::deque<_DSPACTREG*>	dqActReg; 
 
	static inline DSP::_DSPACTREG*	FindClassID(const std::string& strID); 
	static inline DSPACT*			GetDSPObject(std::string& strID,DWORD& dwData); 
	static inline WORD				CheckSumAttr(const char *lpHead,const char *lpTail); 
 
public: 
	enum _DSPERRTYPE 
	{ 
		ERR_RECV_HEADER			=10000, 
		ERR_FIND_HEADER, 
		ERR_RECV_ATTRHEADER, 
		ERR_VERIFY_ATTRHEADER, 
		ERR_RECV_CLASSID, 
		ERR_NOTGET_DSPACT, 
		ERR_RECV_ATTRSIZE, 
		ERR_SET_ATTR_BUFF, 
		ERR_UNCOMPRESS, 
		ERR_RECV_ATTR_SECT, 
		ERR_RECV_ATTRVALUE, 
		ERR_RECV_PACKETCRC, 
		ERR_RECV_PACKET_CRC, 
		ERR_RECV_NAME, 
 
		ERR_SEND_HEADER			=11000, 
		ERR_SEND_ATTRHEADER, 
		ERR_SEND_CLASSID, 
		ERR_SERIALIZE_ATTR, 
		ERR_SEND_ATTR_SECT, 
		ERR_SEND_ATTRSIZE, 
		ERR_SEND_ATTRVALUE, 
		ERR_SEND_PACKETCRC, 
		ERR_SEND_NAME, 
		ERR_COMPRESS, 
	}; 
 
	struct AFX_EXT_CLASS _DSPERROR 
	{ 
		BYTE			byClassLevel;			//类深度 
		DWORD			dwAttrNo;				//属性个数编号 
		int				nErrorNo;				//错误代码 
		std::string		strErrDetail;			//错误描述 
	}; 
 
	struct AFX_EXT_CLASS _DSPPACKET 
	{ 
		//DSP包结构 
		timeval			Timeout;				//接收Socket时的超时时间 
		DWORD			dwData;					//在注册类时指定的该类的附加数据 
		bool&			bKeepRun;				//是否继续运行，通过这个布尔变量，可以随时中止序列化或反序列化过程 
		 
	private: 
		_DSPERROR		LastError;				//保存最近一个错误的描述 
		char			chData1[6]; 
		char			chData2[2]; 
		char			chBuff[sizeof(DWORD)];	//保存临时数据的缓冲区 
		char*			lpAttrBuff;				//接收属性的缓冲区的首地址 
		std::string		strClassID;				//保存ClassID的值 
		DWORD			dwAttrSize;				//当前接收缓冲区的长度 
		WORD			wPacketCRC;				//包的总的CRC 
		bool			bAttrRecvComplete;		//属性是否已经接收完成 
		bool			bCompressAttr;			//属性是否被压缩 
		DSPACT*			pDspAct;				//保存转换成对象后的基类对象的指针 
 
		inline bool		FindHeader(); 
		inline bool		Recv(SOCKET sock,char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL); 
		inline bool		Recv(ifstream& ifs,char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL); 
		inline bool		Send(SOCKET sock,const char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL); 
		inline bool		Send(ofstream& ofs,const char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL); 
		inline bool		Recv(char** const lpUDPBuff,int& nUDPSize,char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL); 
		inline bool		Send(char** const lpUDPBuff,int& nUDPSize,const char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL); 
 
		inline DSPACT*	ReadError(_DSPERRTYPE errNo,BYTE classLevel,BYTE attrNo,DSPACT* pAct); 
		inline bool		WriteError(_DSPERRTYPE errNo,BYTE classLevel,BYTE attrNo); 
		inline bool		WriteObject(char** const lpUDPBuff,int& nUDPBuffLen,DSPACT& act); 
		inline DSPACT*	ReadObjectFromIfs(ifstream& ifs,DSPACT* pAct); 
		inline DSPACT*	ReadObjectFromTCP(SOCKET sock,DSPACT* pAct); 
		inline DSPACT*	ReadObjectFromUDP(char** lpUDPBuff,int& nUDPBuffLen,DSPACT* pAct); 
		inline DSPACT*	ReadObject(char** lpUDPBuff,int& nUDPBuffLen,DSPACT* pAct); 
 
		inline bool		Serialize(SOCKET sock,const char* lpName,BYTE byNameLen,const char* lpValue,WORD usValueLen,bool bSendValueLen); 
		inline bool		Serialize(ofstream& ofs,const char* lpName,BYTE byNameLen,const char* lpValue,WORD usValueLen,bool bSendValueLen); 
 
	public: 
		_DSPPACKET(bool& bRun):bKeepRun(bRun),dwAttrSize(0){Timeout.tv_sec=10;Timeout.tv_usec=0;}; 
		inline void	Empty() 
		{ 
			pDspAct		=NULL;	 
			dwAttrSize	=0; 
			wPacketCRC	=0; 
		}; 
		inline	_DSPERROR* const GetLastError(){return &LastError;}; 
 
		void	SetParameter(bool bCompress=false,bool bVerifyCRC=true,BYTE byInitType=0); 
		bool	IsVerifyCrc(); 
		bool	IsCompress(); 
		DSPACT*	ReadObject(char* lpUDPBuff,int nUDPBuffLen,DSPACT* pAct=NULL); 
		DSPACT*	ReadObject(SOCKET sock,DSPACT* pAct=NULL); 
		DSPACT*	ReadObject(ifstream& ifs,DSPACT* pAct=NULL); 
		bool	Read(char& attr); 
		bool	Read(BYTE& attr); 
		bool	Read(short& attr); 
		bool	Read(WORD& attr); 
		bool	Read(int& attr); 
		bool	Read(DWORD& attr); 
		bool	Read(bool& attr); 
		bool	Read(std::string& attr,DWORD dwLen); 
		bool	Read(char* const pAttr,DWORD dwLen); 
		bool	Read(DSPACT& attr); 
 
 inline	bool	WriteObject(SOCKET sock,sockaddr_in& to,char* const lpUDPBuff,int nUDPBuffLen,DSPACT& act); 
		bool	WriteObject(SOCKET sock,sockaddr_in& to,int nUDPSize,DSPACT& act); 
		bool	WriteObject(SOCKET sock,DSPACT& act); 
		bool	WriteObject(ofstream& ofs,DSPACT& act); 
		void	Write(int attr); 
		void	Write(DWORD attr); 
		void	Write(bool attr); 
		void	Write(const std::string& attr); 
		void	Write(char* const pAttr,DWORD dwLen,BOOL bLast=TRUE); 
		void	Write(DSPACT& attr,bool bCompress=false,bool bVerifyCRC=true,BYTE byInitType=0); 
		 
		#ifndef	UNIX_SYSTEM_ 
			void	Write(const CString& attr); 
			bool	Read(CString& attr,DWORD dwLen); 
			bool	Serialize(const CString& strValue,const char* lpName=NULL,BYTE nNameLen=0); 
			bool	UnSerialize(CString& strValue); 
		#endif 
 
		void	SerializeStart(ofstream& ofs,DSPCOMPRESSFUNC(pFun)=NULL); 
		bool	Serialize(int nValue,const char* lpName=NULL,BYTE nNameLen=0); 
		bool	Serialize(BYTE byValue,const char* lpName=NULL,BYTE nNameLen=0); 
		bool	Serialize(bool bValue,const char* lpName=NULL,BYTE nNameLen=0); 
		bool	Serialize(std::string& strValue,const char* lpName=NULL,BYTE nNameLen=0); 
		bool	Serialize(char* lpBuff,int nBuffLen,const char* lpName=NULL,BYTE nNameLen=0,DSPSECTSEND(pFunc)=NULL); 
		bool	Serialize(DSPACT& act,const char* lpName=NULL,BYTE nNameLen=0); 
		bool	SerializeEnd(); 
		bool	UnSerializeStart(ifstream& ifs,DSPUNCOMPRESSFUNC(pFun)=NULL); 
 inline	BYTE	IsKinkOf(std::string& strName); 
 inline	bool	UnSerialize(DWORD& value,int& nValueLen); 
		bool	UnSerialize(int& nValue); 
		bool	UnSerialize(DWORD& dwValue); 
		bool	UnSerialize(short& sValue); 
		bool	UnSerialize(WORD& wValue); 
		bool	UnSerialize(char& cValue); 
		bool	UnSerialize(BYTE& byValue); 
		bool	UnSerialize(std::string& strValue); 
		bool	UnSerialize(char* pValue,int* nValueLen); 
	}; 
 
	static bool		RegisterAct(const char* classID,DSPGETOBJFUNC(dspActFun),DWORD dwData=0); 
	static SOCKET	ConnectTo(const char *lpSrvName,int nSrvPort,bool bInternet=true,int nRetryCount=5); 
	static SOCKET	GetUDPSocket(int nListenPort=-1,bool bInternet=true); 
	static SOCKET	GetTCPSocket(int nListenPort=-1,bool bInternet=true); 
	static bool		GetAddrByName(const char *lpName,WORD port,sockaddr_in& addr); 
	static void		GetAddrByIP(const char *lpIP,WORD port,sockaddr_in& addr,bool bInternet=true); 
	static int		WaitRecvUDP(SOCKET sock,char *lpUDPBuff,int nUDPBuffLen,struct sockaddr_in& from,int nTimeoutSec=30); 
	static DWORD	GetFileSize(const char* lpFilename); 
	static DWORD	CreateNullFile(const char* lpFilename,int nSize,bool bAppend=true); 
	static void		SafeRelease(); 
 
	static inline BOOL	OpenIfstreamForRead(ifstream& ifs,const char* const lpFileName,int nMode=0,int nShareMode=filebuf::openprot) 
	{	ifs.open(lpFileName,ios::in|ios::binary|ios::nocreate|nMode,nShareMode); 
		return ifs.is_open(); 
	}; 
 
	static inline BOOL	OpenOfstreamForWrite(ofstream& ofs,const char* const lpFileName,int nMode=0,int nShareMode=filebuf::sh_write||filebuf::sh_read) 
	{	ofs.open(lpFileName,ios::out|ios::binary|nMode,nShareMode); 
		return ofs.is_open(); 
	}; 
}; 
 
 
class AFX_EXT_CLASS DSPACT   
{ 
public: 
	DSPACT(){}; 
	virtual ~DSPACT(){}; 
	virtual char *	GetClassID()=0; 
	virtual bool	IsKindOf(char* lpClassName)=0; 
 
protected: 
	friend	struct	DSP::_DSPPACKET; 
	virtual void	Init(BYTE byType){}; 
	virtual BYTE	GetClassLevel(){ return 0;	}; 
	virtual bool	AttrSectRecv(BYTE byClassLevels,BYTE byAttrNo,const char* const lpBuff,DWORD dwLen,bool bLast); 
	virtual bool	AttrSectSend(BYTE byClassLevels,BYTE byAttrNo,char** const lpBuff,DWORD& dwLen,bool& bContinue); 
	virtual bool	Serialize(BYTE byClassLevels,BYTE byAttrNo,DSP::_DSPPACKET &dsp); 
	virtual bool	UnSerialize(BYTE byClassLevels,BYTE byAttrNo,DSP::_DSPPACKET &dsp,DWORD dwLen); 
	virtual bool	Compress(char** const lpBuff,DWORD& dwLen); 
	virtual bool	UnCompress(char** const lpBuff,DWORD dwLen,char* lpUnBuff,WORD& wUnLen,bool bStart); 
}; 
 
#endif