condition.cpp

有计算机图形学、图像处理、dbms、sniffer、中游俄罗斯外挂、othello、遗传算法、舌苔分析等程序。

// Condition.cpp: implementation of the CCondition class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Database.h"
#include "Condition.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CCondition::CCondition()
{
	next=NULL;
    AttrNo1=AttrNo2=0;
	sflag=xflag=0;
	con=rels=0;
}

CCondition::~CCondition()
{

}

CCondition::CCondition(Relationship *R1,Relationship *R2,
  CString  A1,CString A2,BOOL sf,BOOL xf,CString svalue,CString xvalue,BYTE con)
  :sflag(sf),xflag(xf)
{
	this->con=con;
	next=NULL;
	AttrNo1=AttrNo2=0;
	AttrNo1=R1->AttrNameToAttrNo(A1);
	if(A2!="")
	    AttrNo2=R2->AttrNameToAttrNo(A2);
	switch(R1->at[AttrNo1].type)
	{
	case INT_TYPE:
		{
			if(svalue=="")
				skey=KEY(MAX_VALUE);
			else
			    skey=KEY(0,atoi(LPCTSTR(svalue)));
			if(xvalue=="")
			    xkey=KEY(MIN_VALUE);
			else
				xkey=KEY(0,atoi(LPCTSTR(xvalue)));
			break;
		}
	case FLOAT_TYPE:
		{
		    if(svalue=="")
				skey=KEY(MAX_VALUE);
			else
			    skey=KEY(0,float(atof(LPCTSTR(svalue))));
			if(xvalue=="")
			    xkey=KEY(MIN_VALUE);
			else
				xkey=KEY(0,float(atof(LPCTSTR(xvalue))));
			break;
		}
	case  CHAR_TYPE:
	case VARCHAR_TYPE:
		{
			if(svalue=="")
				skey=KEY(MAX_VALUE);
			else
			    skey=KEY(0,svalue);
			if(xvalue=="")
			    xkey=KEY(MIN_VALUE);
			else
				xkey=KEY(0,xvalue);
			break;
		}
	case TIME_TYPE:
		{
			if(svalue=="")
				skey=KEY(MAX_VALUE);
			else
			    skey=KEY(0,Time(svalue));
			if(xvalue=="")
			    xkey=KEY(MIN_VALUE);
			else
				xkey=KEY(0,Time(xvalue));
			break;
		}
	case DATE_TYPE:
		{
			if(svalue=="")
				skey=KEY(MAX_VALUE);
			else
			    skey=KEY(0,Date(svalue));
			if(xvalue=="")
			    xkey=KEY(MIN_VALUE);
			else
				xkey=KEY(0,Date(xvalue));
			break;
		}
	}
}

BOOL CCondition::Fit(Record *rcd)
{
    bool xfit=false;
	bool sfit=false;
   	bool fit=false;
	bool Continue=true;

	Relationship *pattern=rcd->pattern;
	CMemFile cmf;
	cmf.Attach(rcd->body,rcd->m_length);
	cmf.Seek(pattern->at[AttrNo1].offset,CFile::begin);

	switch(pattern->at[AttrNo1].type)
	{
	case INT_TYPE:
		{
			int sum=0;
			int ival1=0,ival2=0;
			cmf.Read(&ival1,sizeof(int));
			sum=ival1;
			if(AttrNo2!=0)
			{
				cmf.Seek(pattern->at[AttrNo2].offset,CFile::begin);
				cmf.Read(&ival2,sizeof(int));
                Continue=Judge(sum,fit,ival1,ival2);
			}
			cmf.Detach();
			if(Continue)
			{
				if(xkey.type==MIN_VALUE 
					|| (sum>xkey.VAL.ival && (xflag!=2) )
					|| (sum==xkey.VAL.ival && (xflag!=0) ))
					xfit=true;
				if(skey.type==MAX_VALUE
					|| (sum<skey.VAL.ival && (sflag!=2) )
					|| (sum==skey.VAL.ival && (sflag!=0) ))
					sfit=true;
			}
			return (fit || (xfit&&sfit) ); 
		}
    case FLOAT_TYPE:
		{
			float sum=0;
			float fval1=0,fval2=0;
			cmf.Read(&fval1,sizeof(float));
			sum=fval1;
			if(AttrNo2!=0)
			{
				cmf.Seek(pattern->at[AttrNo2].offset,CFile::begin);
				cmf.Read(&fval2,sizeof(float));
				Continue=Judge(sum,fit,fval1,fval2);
			}
			cmf.Detach();
			if(Continue)
			{
				if(xkey.type==MIN_VALUE 
					|| (sum>xkey.VAL.fval && (xflag!=2) )
					|| (fabs(sum-xkey.VAL.fval)<0.00001 && (xflag!=0) ))
					xfit=true;
				if(skey.type==MAX_VALUE 
					|| (sum<skey.VAL.fval && (sflag!=2) )
					|| (fabs(sum-skey.VAL.fval)<0.00001 && (sflag!=0) ))
					sfit=true;
			}
			return (fit || (xfit&&sfit) ); 
		}
	case CHAR_TYPE:
		{
			char * chval=new char[(pattern->at[AttrNo1].length)+1 ];
			cmf.Read(chval,(pattern->at[AttrNo1].length)+1 );
			cmf.Detach();
			CString sval(chval);
			delete []chval;
			if(xflag!=2)
			    return  (sval.Find(LPCTSTR(xkey.VAL.sval))!=-1);//!!!!!!!!!!!!!!!!!!!!!
		    else
                return (sval.Left(KEY_LENGTH-1)==CString(xkey.VAL.sval));
		}
	case VARCHAR_TYPE:
		{
            BYTE len;
            cmf.Read(&len,sizeof(BYTE));
			char *vchval=new char[len];
			cmf.Read(vchval,len);
			cmf.Detach();
			CString sval(vchval);
			delete []vchval;
			if(xflag!=2)
			    return  (sval.Find(LPCTSTR(xkey.VAL.sval))!=-1);//!!!!!!!!!!!!!!!!!!!!!
		    else
                return (sval.Left(KEY_LENGTH-1)==CString(xkey.VAL.sval));
		}
    case TIME_TYPE:
		{
            CString s;
			char *val=new char[pattern->at[AttrNo1].length];
			cmf.Read(val,pattern->at[AttrNo1].length);
			cmf.Detach();
			s=CString(val);
			Time tval(s);
			KEY tkey(0,tval);
			delete []val;
            if(xkey.type==MIN_VALUE 
				|| (tkey>xkey && (xflag!=2) )
				|| (tkey==xkey && (xflag!=0) ))
				xfit=true;
			if(skey.type==MAX_VALUE 
				|| (tkey<skey && (sflag!=2) )
				|| (tkey==skey && (sflag!=0) ))
				sfit=true;
			
			return (xfit&&sfit); 
		}
	case DATE_TYPE:
		{
            CString s;
			char *val=new char[pattern->at[AttrNo1].length];
			cmf.Read(val,pattern->at[AttrNo1].length);
			cmf.Detach();
			s=CString(val);
			Date dval(s);
			KEY dkey(0,dval);
			delete []val;
            if(xkey.type==MIN_VALUE 
				|| (dkey>xkey && (xflag!=2) )
				|| (dkey==xkey && (xflag!=0) ))
				xfit=true;
			if(skey.type==MAX_VALUE
				|| (dkey<skey && (sflag!=2) )
				|| (dkey==skey && (sflag!=0) ))
				sfit=true;
			
			return (xfit&&sfit); 
		}
	}
}
	
bool CCondition::Judge(int &sum, bool &fit,const int ival1,const int ival2)
{
	bool Continue=false;
    switch(con)
	{
	case ADD:
		sum+=ival2;
		Continue=true;
		break;
	case MINUS:
		sum-=ival2;
		Continue=true;
		break;
	case LE:
        fit=(ival1<=ival2);
		break;
	case GE:
		fit=(ival1>=ival2);
		break;
	case L:
		fit=(ival1<ival2);
		break;
	case G:
		fit=(ival1>ival2);
		break;
	case E:
		fit=(ival1==ival2);
		break;
	default:
		ASSERT(0);
		break;
	}
	return Continue;
}
bool CCondition::Judge(float &sum,bool &fit,const float fval1,const float fval2)
{
	bool Continue=false;
    switch(con)
	{
	case ADD:
		sum+=fval2;
		Continue=true;
		break;
	case MINUS:
		sum-=fval2;
		Continue=true;
		break;
	case LE:
        fit=(fval1<=fval2);
		break;
	case GE:
		fit=(fval1>=fval2);
		break;
	case L:
		fit=(fval1<fval2);
		break;
	case G:
		fit=(fval1>fval2);
		break;
	case E:
		fit=(float(fabs(fval1-fval2))<0.00001);
		break;
	default:
		ASSERT(0);
		break;
	}
	return Continue;
}

CCondition & CCondition::operator =(const CCondition &condition)
{
    ASSERT(this!=&condition);//防止自赋值
	AttrNo1=condition.AttrNo1;
	AttrNo2=condition.AttrNo2;
	con=condition.con;
	next=NULL;
	rels=condition.rels;
    sflag=condition.sflag;
	skey=condition.skey;
	xflag=condition.xflag;
	xkey=condition.xkey;
	return *this;
}

CCondition::CCondition(const CCondition &condition)
{
	ASSERT(this!=&condition);//防止自赋值
    AttrNo1=condition.AttrNo1;
	AttrNo2=condition.AttrNo2;
	con=condition.con;
	next=NULL;
	rels=condition.rels;
    sflag=condition.sflag;
	skey=condition.skey;
	xflag=condition.xflag;
	xkey=condition.xkey;
}