univar.h

一个多线程

#ifndef __UniVar_h__
#define __UniVar_h__

#define VALIDATE(classname) \
static BOOL classname::IsValid ( classname * p ){ \
		if(!p)return FALSE; \
		try{ \
			if(p!=p->m_pThis) return FALSE; \
		}catch(...){ \
			return FALSE; \
		}; \
		return TRUE; \
	}; \

#define THREAD_STATUS_WAIT		1//start and wait for signal
#define THREAD_STATUS_WORK		2// work 
#define THREAD_STATUS_ERROR		3//error:exception occur

#define WORD_LEFTSMLBRACKET		0x10//left (
#define WORD_RIGHTSMLBRACKET	0x11//right )

#define ITOSTRING_STRING "%ld"
#define FTOSTRING_STRING "%.10f"
#define XTOSTRING_STRING "0x%08lx"

#define WORD_ADD		0x10f
#define WORD_SUB		0x110
#define	WORD_MUL		0x111
#define WORD_DEV		0x112
#define WORD_BIG		0x113
#define WORD_SML		0x114
#define WORD_EQUE		0x115
#define WORD_SAM		0x116
#define WORD_BGE		0x117
#define WORD_SME		0x118
#define WORD_AND		0x119
#define WORD_OR			0x11a
#define WORD_NOT		0x11b
#define WORD_OPS		0x11c
#define WORD_BAND		0x11d
#define WORD_BOR		0x11e
#define WORD_XOR		0x11f
#define	WORD_MOD		0x120
#define WORD_WHY		0x121
#define WORD_NEQ		0x122

struct HEAPHANDLE{
	void * pBuffer;
	HANDLE handle;
};

union UniValue{
	int iv;
	float fv;
	DWORD pv;
	char * cv;
	BYTE * bv;
	DWORD hv;
	double dv;
	LONGLONG llv;
	HEAPHANDLE heap;
};

#define DATA_TYPE_INT		0
#define DATA_TYPE_FLOAT		1
#define DATA_TYPE_DWORD		2
#define DATA_TYPE_STRING	3
#define DATA_TYPE_HANDLE	4
#define DATA_TYPE_OPERATOR	5

#define DATA_TYPE_MAX		10

struct PARAMEMTER;

class AFX_EXT_CLASS UniVar{
private:
public:
	DWORD dwCheckL;
	WORD it;
	BYTE  inout,
		btmust;
	UniValue uv;

	inline BOOL IsString(){return (it==DATA_TYPE_STRING);};
	inline BOOL bIsOperator(){return (it==DATA_TYPE_OPERATOR);};
	UniVar(){memset(this,0,sizeof(UniVar));};
	~UniVar(){ClearData();};
	inline void ClearData();
	static HANDLE m_hCreate;
	static int m_iHeapBlock;
	static UniVar m_InValidValue;
	static char * NewBlock(int);
	static BOOL DeleteBlock(void *);

	void UniDelete();
	void Uninew(int size,int ite);
	UniVar(UniVar * ptv);
	UniVar(int i,UniVar & tv);
	inline int GetDataLength(){return dwCheckL;};
	inline void SetDataLength(DWORD len){dwCheckL=len;};
	static BOOL ValidVar(UniVar * p);
	
	UniVar(UniVar & tv);
	UniVar(UniVar &tv,int btm,int io);
	UniVar(int itp,int ilenp,UniVar & tv);
	void SetData(int itp,int ilenp,UniVar & tv);
	UniVar(int iv){memset(this,0,sizeof(UniVar));it=DATA_TYPE_INT;uv.iv=iv;};
	UniVar(char * s);
	UniVar(LPCTSTR s);
	UniVar(CString & s);
	UniVar(void * p,int i);
	UniVar(float f){memset(this,0,sizeof(UniVar));it=DATA_TYPE_FLOAT;uv.dv=(double)f;};
	UniVar(double f){memset(this,0,sizeof(UniVar));it=DATA_TYPE_FLOAT;uv.dv=f;};
	UniVar(DWORD pv,int ict){memset(this,0,sizeof(UniVar));uv.pv=pv;it=ict;ASSERT(it!=DATA_TYPE_STRING&&it!=DATA_TYPE_HANDLE);};
	UniVar(DWORD pv){memset(this,0,sizeof(UniVar));it=DATA_TYPE_DWORD;uv.pv=pv;};
	const int operator =(const UniVar & tv);

	UniVar(UniValue & ouv,int oit)
	{
		memset(this,0,sizeof(UniVar));
		SetValue(ouv,oit);
	};

	const UniVar & operator =(int i){
		ClearData();
		btmust=0;
		inout=0;
		it=DATA_TYPE_INT;
		uv.iv=i;
		return *this;
	};

	const UniVar & operator =(float i){
		ClearData();
		btmust=0;
		inout=0;
		it=DATA_TYPE_FLOAT;
		uv.dv=(double)i;
		return *this;
	};

	const UniVar & operator =(double i){
		ClearData();
		btmust=0;
		inout=0;
		it=DATA_TYPE_FLOAT;
		uv.dv=(double)i;
		return *this;
	};

	const UniVar & operator =(char * s){
		ClearData();
		if(s){
			int len=strlen(s)+1;
			Uninew(len,DATA_TYPE_STRING);
			if(uv.bv)memcpy(uv.bv,s,len);
		}
		else {
			Uninew(1,DATA_TYPE_STRING);
			if(uv.bv)uv.cv[0]='\0';
		}
		return *this;
	};

	const UniVar & operator =(DWORD i){
		ClearData();
		btmust=0;
		inout=0;
		it=DATA_TYPE_DWORD;
		uv.hv=i;
		return *this;
	};

	inline void SetValue(DWORD i,int l){*this=UniVar(i,l);};
	inline void SetValue(int i){*this=UniVar(i);};
	inline void SetValue(char * i){*this=UniVar(i);};
	inline void SetValue(float i){*this=UniVar(i);};
	inline void SetValue(double i){*this=UniVar(i);};
	void SetValue(void * p,int i);
	void SetValue(UniValue & ouv,int oit){
		switch(oit){
		case DATA_TYPE_INT:*this=UniVar(ouv.iv);break;
		case DATA_TYPE_FLOAT:*this=UniVar(ouv.dv);break;
		case DATA_TYPE_DWORD:*this=UniVar(ouv.pv);break;
		case DATA_TYPE_STRING:*this=UniVar(ouv.cv);break;
		default:*this=(0);break;
		};
	};
	void Convert(int oit);
	inline int GetType(){return it;};
	void SetData(UniVar & tv);
	void SetData(int i,UniVar & tv);
	enum BLOCKOPRATOR{insertblock,deleteblock,substblock,copyblock,univarpt};
	void BlockSet(BLOCKOPRATOR iFlag,UniVar & tv,int iFirst=0,int iLen=-1,int iReset=-1);
	bool UniVar::Getbyte(int idx,UniVar & tv);
	void SetData(PARAMEMTER * pm,UniVar & tv);
	UniVar(PARAMEMTER * pm,UniVar & tv);
	inline int ToI(){
		switch(it){
		case DATA_TYPE_INT: return uv.iv;
		case DATA_TYPE_FLOAT: *this=(int)(uv.dv);return uv.iv;
		case DATA_TYPE_DWORD: *this=(int)(uv.pv);return uv.iv;
		case DATA_TYPE_STRING: *this=(int)(atoi(uv.cv));return uv.iv;
		case DATA_TYPE_HANDLE: 
		default : *this=(0);return uv.iv;
		};
	};
	inline double ToF(){
		switch(it){
		case DATA_TYPE_INT: *this=(double)(uv.iv);return uv.dv;
		case DATA_TYPE_FLOAT: return uv.dv;
		case DATA_TYPE_DWORD: *this=(double)(uv.pv);return uv.dv;
		case DATA_TYPE_STRING: *this=(double)(atof(uv.cv));return uv.dv;
		case DATA_TYPE_HANDLE: 
		default : *this=(double)(0.0f);return uv.dv;
		};
	};
	inline DWORD ToDW(){
		switch(it){
		case DATA_TYPE_INT: *this=(DWORD)(uv.iv);return uv.pv;
		case DATA_TYPE_FLOAT: *this=(DWORD)(uv.dv);return uv.pv;
		case DATA_TYPE_DWORD: return uv.pv;
		case DATA_TYPE_STRING: *this=(DWORD)(atoi(uv.cv));return uv.pv;
		case DATA_TYPE_HANDLE: 
		default : *this=(DWORD)(0);return uv.pv;
		};
	};
	LPSTR ToA(char * szCHString=NULL);
	BOOL IsSame(UniVar & u);
	inline BOOL IsSame(UniVar * pu);
	inline BOOL IsTrue(){
		if(it==DATA_TYPE_FLOAT)return (uv.dv!=0.0f);
		else return (uv.iv!=0);
	};

	inline BOOL IsEmpty(){return !(uv.iv&&(dwCheckL>1)&&(it==DATA_TYPE_STRING||it==DATA_TYPE_HANDLE));};
	operator UniValue(){return uv;}
	operator BOOL(){return uv.iv;};
	operator short(){return (short)uv.iv;};
	operator char(){return (char)uv.iv;};
	operator WORD(){return (WORD)uv.pv;};
	operator DWORD(){
		if(it==DATA_TYPE_FLOAT)return (DWORD)uv.dv;
		else return uv.pv;
	};
	operator double(){
		if(it==DATA_TYPE_FLOAT)return uv.dv;
		else return(double)uv.iv;
	};
	operator float(){
		if(it==DATA_TYPE_FLOAT)return (float)uv.dv;
		else return(float)uv.iv;
	};
	operator LPSTR(){
		if(it<=DATA_TYPE_HANDLE)return uv.cv;
		else return NULL;
	};
	operator LPVOID(){
		if(it<=DATA_TYPE_HANDLE)return (void *)uv.cv;
		else return NULL;
	};
	void GetFullValue(UniVar & u)
	{
		ClearData();
		memcpy(this,&u,sizeof(UniVar));
		memset(&u,0,sizeof(UniVar));
	};
	void SetFullValue(UniVar & u)
	{
		u.ClearData();
		memcpy(&u,this,sizeof(UniVar));
		memset(this,0,sizeof(UniVar));
	};

	UniVar operator !(){
		UniVar tv;
		if(it==DATA_TYPE_INT)tv=(!uv.iv);
		else if(it==DATA_TYPE_FLOAT)tv=(!uv.dv);
		else if(it==DATA_TYPE_DWORD)tv=(!uv.pv);
		else if(it==DATA_TYPE_STRING)tv=(!uv.cv);
		else tv=(0);
		return tv;
	};
	UniVar operator -(){
		UniVar tv;
		if(it==DATA_TYPE_INT)tv=(-uv.iv);
		else if(it==DATA_TYPE_FLOAT)tv=(-uv.dv);
		else tv=(0);
		return tv;
	};
	UniVar operator ~(){
		UniVar tv;
		if(it==DATA_TYPE_INT)tv=(~uv.iv);
		else if(it==DATA_TYPE_DWORD)tv=(~uv.pv);
		else tv=(0);
		return tv;
	};
	friend void TVtrimleft(UniVar & tv){
		CString cs=tv.uv.cv;
		cs.TrimLeft();
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVtrimright(UniVar & tv){
		CString cs=tv.uv.cv;
		cs.TrimRight();
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVmakeupper(UniVar & tv){
		CString cs=tv.uv.cv;
		cs.MakeUpper();
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVmakelower(UniVar & tv){
		CString cs=tv.uv.cv;
		cs.MakeLower();
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVreplace(UniVar & tv,char * s,char * t,int & i){
		CString cs=tv.uv.cv;
		i=cs.Replace(s,t);
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVinsert(UniVar & tv,int i,char * s){
		CString cs=tv.uv.cv;
		cs.Insert(i,s);
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVmid(UniVar & tv,int i,int j){
		CString cs=tv.uv.cv;
		cs.Mid(i,j);
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVleft(UniVar & tv,int i){
		CString cs=tv.uv.cv;
		cs.Left(i);
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVright(UniVar & tv,int i){
		CString cs=tv.uv.cv;
		cs.Right(i);
		tv=((LPSTR)(LPCTSTR)cs);
	}
	friend void TVfind(UniVar & tv,int & i,char * s){
		CString cs=tv.uv.cv;
		i=cs.Find(s,i);
		tv=((LPSTR)(LPCTSTR)cs);
	}

	friend BOOL AFX_EXT_DATA bPrior(DWORD d1,DWORD d2);

	friend UniVar AFX_EXT_DATA iCalculate(DWORD dwOp,const UniVar & tv3,const UniVar & tv4);

	friend UniVar AFX_EXT_DATA Calculate(const UniVar & tv3,const UniVar & tv4,int iFlag);
	friend UniVar AFX_EXT_DATA operator +(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator -(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator *(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator /(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator %(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator ^(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator |(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator &(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator &&(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator ||(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator >(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator >=(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator ==(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator !=(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator <=(const UniVar & tv1,const UniVar & tv2);
	friend UniVar AFX_EXT_DATA operator <(const UniVar & tv1,const UniVar & tv2);
};

struct PARAMEMTER{
	UniVar tv;
	LPSTR lpstrPreFix;
};

#define InValidVar UniVar::m_InValidValue
#define uvLastParam InValidVar
#endif