key.cpp

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

// KEY.cpp: implementation of the KEY class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Database.h"
#include "KEY.h"

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

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

KEY::KEY()
{
	//9.13
    plus=type=0;
    ::memset(VAL.sval,0,KEY_LENGTH);
}

KEY & KEY::operator =(KEY k1)
{
	plus=k1.plus;
	type=k1.type;
	
	VAL=k1.VAL;
	
	return *this;
}
bool KEY::operator ==(KEY k1)
{
	ASSERT(k1.type==MIN_VALUE||k1.type==MAX_VALUE||type==k1.type
		||type==MIN_VALUE||type==MAX_VALUE);
	
	if(type==MIN_VALUE ||type==MAX_VALUE||k1.type==MIN_VALUE||k1.type==MAX_VALUE)
		return false;
	switch(type)
	{
	case INT_TYPE:
		return (VAL.ival==k1.VAL.ival);
	case UINT_TYPE:
		return (VAL.uival==k1.VAL.uival);
	case FLOAT_TYPE:
		{
			if(fabs(double(VAL.fval-k1.VAL.fval))<0.00001)
				return true;
			else 
				return false;
		}
	case CHAR_TYPE:
		return !strcmp(VAL.sval,k1.VAL.sval);
	case TIME_TYPE:
        return (VAL.tval[0]==k1.VAL.tval[0]
			&&VAL.tval[1]==k1.VAL.tval[1]
			&&VAL.tval[2]==k1.VAL.tval[2]
			&&VAL.tval[3]==k1.VAL.tval[3]);
	case DATE_TYPE:
		return (VAL.dval[0]==k1.VAL.dval[0]
			&&VAL.dval[1]==k1.VAL.dval[1]
			&&VAL.dval[2]==k1.VAL.dval[2]
			&&VAL.dval[3]==k1.VAL.dval[3]);
	default:
		return false;
	}
}
bool KEY::operator !=(KEY k1)
{
    ASSERT(k1.type==MIN_VALUE||k1.type==MAX_VALUE||type==k1.type
		||type==MIN_VALUE||type==MAX_VALUE);
	return !(this->operator ==(k1));
}
bool KEY::operator >(KEY k1)
{
	ASSERT(k1.type==MIN_VALUE||k1.type==MAX_VALUE||type==k1.type
		||type==MIN_VALUE||type==MAX_VALUE);

	
	if(type==MIN_VALUE || k1.type==MAX_VALUE)
		return false;
	if(type==MAX_VALUE || k1.type==MIN_VALUE)
		return true;
    switch(type)
	{
	case INT_TYPE:
        return (VAL.ival>k1.VAL.ival);
	case UINT_TYPE:
		return (VAL.uival>k1.VAL.uival);
	case FLOAT_TYPE:
		return (fabs(double(VAL.fval-k1.VAL.fval))>0.00001
			&&VAL.fval>k1.VAL.fval);
	case CHAR_TYPE:
		return (strcmp(VAL.sval,k1.VAL.sval)>0);
	case TIME_TYPE:
        return (VAL.tval[1]>k1.VAL.tval[1]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]>k1.VAL.tval[2]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]==k1.VAL.tval[2]
			  &&VAL.tval[3]>k1.VAL.tval[3]);

	case DATE_TYPE:
		return (VAL.dval[1]>k1.VAL.dval[1]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]>k1.VAL.dval[2]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]==k1.VAL.dval[2]
			  &&VAL.dval[3]>k1.VAL.dval[3]);
	default:
		break;
	}
	
}
bool KEY::operator <(KEY k1)
{
    ASSERT(k1.type==MIN_VALUE||k1.type==MAX_VALUE||type==k1.type
		||type==MIN_VALUE||type==MAX_VALUE);

	if(type==MIN_VALUE || k1.type==MAX_VALUE)
		return true;
	if(type==MAX_VALUE || k1.type==MIN_VALUE)
		return false;
    switch(type)
	{
	case INT_TYPE:
	    return (VAL.ival<k1.VAL.ival);
	case UINT_TYPE:
		return (VAL.uival<k1.VAL.uival);
	case FLOAT_TYPE:
		return (fabs(double(VAL.fval-k1.VAL.fval))>0.00001
			&&VAL.fval<k1.VAL.fval);
	case CHAR_TYPE:
		return (strcmp(VAL.sval,k1.VAL.sval)<0);
	case TIME_TYPE:
        return (VAL.tval[1]<k1.VAL.tval[1]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]<k1.VAL.tval[2]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]==k1.VAL.tval[2]
			  &&VAL.tval[3]<k1.VAL.tval[3]);

	case DATE_TYPE:
		return (VAL.dval[1]<k1.VAL.dval[1]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]<k1.VAL.dval[2]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]==k1.VAL.dval[2]
			  &&VAL.dval[3]<k1.VAL.dval[3]);
	default:
		return false;
	}
	
}
bool KEY::operator >=(KEY k1)
{
    ASSERT(k1.type==MIN_VALUE||k1.type==MAX_VALUE||type==k1.type
		||type==MIN_VALUE||type==MAX_VALUE);

	if(type==MIN_VALUE || k1.type==MAX_VALUE)
		return false;
	if(type==MAX_VALUE || k1.type==MIN_VALUE)
		return true;
    switch(type)
	{
	case INT_TYPE:
	    return (VAL.ival>=k1.VAL.ival);
	case UINT_TYPE:
		return (VAL.uival>=k1.VAL.uival);
	case FLOAT_TYPE:
		return (VAL.fval>k1.VAL.fval||fabs(double(VAL.fval-k1.VAL.fval))<0.000001);
	case CHAR_TYPE:
		return (strcmp(VAL.sval,k1.VAL.sval)>=0);
	case TIME_TYPE:
        return !(VAL.tval[1]<k1.VAL.tval[1]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]<k1.VAL.tval[2]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]==k1.VAL.tval[2]
			  &&VAL.tval[3]<k1.VAL.tval[3]);

	case DATE_TYPE:
		return !(VAL.dval[1]<k1.VAL.dval[1]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]<k1.VAL.dval[2]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]==k1.VAL.dval[2]
			  &&VAL.dval[3]<k1.VAL.dval[3]);
	default:
		return false;
	}	
	
}
bool KEY::operator <=(KEY k1)
{
	ASSERT(k1.type==MIN_VALUE||k1.type==MAX_VALUE||type==k1.type
		||type==MIN_VALUE||type==MAX_VALUE);

	if(type==MIN_VALUE || k1.type==MAX_VALUE)
		return true;
	if(type==MAX_VALUE || k1.type==MIN_VALUE)
		return false;
    switch(type)
	{
	case INT_TYPE:
	    return (VAL.ival<=k1.VAL.ival);
	case UINT_TYPE:
		return (VAL.uival<=k1.VAL.uival);
	case FLOAT_TYPE:
		return (VAL.fval<k1.VAL.fval||fabs(double(VAL.fval-k1.VAL.fval))<0.000001);
	case CHAR_TYPE:
		return (strcmp(VAL.sval,k1.VAL.sval)<=0);
	case TIME_TYPE:
        return !(VAL.tval[1]>k1.VAL.tval[1]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]>k1.VAL.tval[2]
			||VAL.tval[1]==k1.VAL.tval[1]&&VAL.tval[2]==k1.VAL.tval[2]
			  &&VAL.tval[3]>k1.VAL.tval[3]);

	case DATE_TYPE:
		return !(VAL.dval[1]>k1.VAL.dval[1]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]>k1.VAL.dval[2]
			||VAL.dval[1]==k1.VAL.dval[1]&&VAL.dval[2]==k1.VAL.dval[2]
			  &&VAL.dval[3]>k1.VAL.dval[3]);
	default:
		return false;
	}	
	
}

KEY::~KEY()
{

}
KEY::KEY(BYTE p,unsigned int uival):plus(p)
{
	type=UINT_TYPE;
	VAL.uival=uival;
}
KEY::KEY(BYTE p, int ival):plus(p)
{
    type=INT_TYPE;
    VAL.ival=ival;
}

KEY::KEY(BYTE p, float fval):plus(p)
{
    type=FLOAT_TYPE;
	VAL.fval=fval;
}

KEY::KEY(BYTE p, CString s):plus(p)//CHAR_TYPE和VARCHAR_TYPE都对应CHAR_TYPE键
{
	memset(&VAL,0,KEY_LENGTH);
	type=CHAR_TYPE;
    strcpy(VAL.sval,LPCTSTR(s.Left(KEY_LENGTH-1)));//??????????????????????????????
	//CString s2=s.Left(8);
}

KEY::KEY(BYTE p, Time time):plus(p)
{
    type=TIME_TYPE;
	VAL.tval[0]=time.tag;
	VAL.tval[1]=time.hour;
	VAL.tval[2]=time.minute;
	VAL.tval[3]=time.second;
}

KEY::KEY(BYTE p, Date date):plus(p)
{
    type=DATE_TYPE;
	VAL.dval[0]=date.tag;
	VAL.dval[1]=date.year;
	VAL.dval[2]=date.month;
	VAL.dval[3]=date.day;
}

KEY::KEY(BYTE t)
{
    type=t;
	if(type==MAX_VALUE||type==MIN_VALUE)
	{
		plus=0;
		VAL.ival=0;
	}
}

KEY::KEY(const KEY &k)
{
    plus=k.plus;
	type=k.type;
	VAL=k.VAL;

}

KEY::KEY(ANY value)//不支持UINT
{
    plus=0;
	this->type=value.type;
	if(value.type==VARCHAR_TYPE)
		this->type=CHAR_TYPE;
	switch(value.type)
	{
	case INT_TYPE:
		VAL.ival=value.ival;
		break;
	case FLOAT_TYPE:
		VAL.fval=value.fval;
		break;
	case CHAR_TYPE:
	case VARCHAR_TYPE:
		{
            memset(&VAL,0,KEY_LENGTH);
	        strcpy(VAL.sval,LPCTSTR(value.pcval->Left(KEY_LENGTH-1)));//??????????????????????????????
			break;
	        //CString s2=s1.Left(8);
		}
	case TIME_TYPE:
        VAL.tval[0]=value.ptval->tag;
	    VAL.tval[1]=value.ptval->hour;
	    VAL.tval[2]=value.ptval->minute;
	    VAL.tval[3]=value.ptval->second;
		break;
	case DATE_TYPE:
		VAL.dval[0]=value.pdval->tag;
		VAL.dval[1]=value.pdval->year;
	    VAL.dval[2]=value.pdval->month;
	    VAL.dval[3]=value.pdval->day;
		break;
	}
}

/*KEY::KEY(BYTE p, MultiVal *mv):plus(p)
{
    type=MULTI_TYPE;
    VAL.mval=mv;
}*/