record.cpp

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

				CString ds=d.DateToCString();
				cmf.Write(LPCTSTR(ds),pattern->at[AttrNo].length-1);
				cmf.Write(&end,sizeof(char));//要写/0 ??????????????????????????//???
				break;
			}
		default:
			break;
			
		}
	}
    cmf.Detach();
	time=CMemory::GetTime();
}

Record &Record::operator =(const Record &rcd)
{
	ASSERT(this!=&rcd);//防止rcd=rcd赋值
	delete []body;//释放原body
    this->ID=rcd.ID;
	this->m_length=rcd.m_length;
	this->pattern=rcd.pattern;//指针
	this->time=rcd.time;
	this->body=new BYTE[this->m_length];
	memcpy(body,rcd.body,this->m_length);

	return *this;
}

BOOL Record::Fit(WORD AttrNo, CString AttrValue)//-1表示出错 
{
    CMemFile cmf;
	if(AttrNo<1||AttrNo>pattern->attr_num)
		return -1;
	cmf.Attach(this->body,this->m_length);
	cmf.Seek(pattern->at[AttrNo].offset,CFile::begin);
	switch(pattern->at[AttrNo].type)
	{
	case INT_TYPE:
		{
			int ival=0;
            int aval=atoi(LPCTSTR(AttrValue));
		    cmf.Read(&ival,sizeof(int));
			cmf.Detach();
			return (ival==aval);
		}
	case FLOAT_TYPE:
		{
			float fval;
			float aval=float( atof(LPCTSTR(AttrValue)) );
			cmf.Read(&fval,sizeof(float));
			cmf.Detach();
			return ( fabs(fval-aval)< 0.00001);
		}
	case CHAR_TYPE:
		{
			char * chval=new char[(pattern->at[AttrNo].length)+1 ];
			cmf.Read(chval,(pattern->at[AttrNo].length)+1 );
			cmf.Detach();
			CString sval(chval);
			delete []chval;
			return  (sval==AttrValue);
		}
	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;
			return (sval==AttrValue);
		}
	case TIME_TYPE:
        {
			CString s;
			char *val=new char[pattern->at[AttrNo].length];
			cmf.Read(val,pattern->at[AttrNo].length);
			cmf.Detach();
			s=CString(val);
			Time tval(s);
			Time aval(AttrValue);
			delete []val;
            return (tval==aval); 
		}
	case DATE_TYPE:
		{
            CString s;
			char *val=new char[pattern->at[AttrNo].length];
			cmf.Read(val,pattern->at[AttrNo].length);
			cmf.Detach();
			s=CString(val);
			Date dval(s);
			Date aval(AttrValue);
			delete []val;
			return (dval==aval);
		}
	}
}
//此处都是未建索引的form
BOOL Record::Fit(CNormalForm &Form)
{
	for(UINT i=0;i<Form.Count;i++)
	{
        if(Form[i].Fit(this)==false)
			return FALSE;
	}
	return TRUE;
}

Record * Record::operator +(const Record &rcd2)
{
    Record *combine=new Record;//ID=0;body=NULL;pattern=NULL;length=0;
    combine->m_length=this->m_length+rcd2.m_length;//以后要改
	combine->body=new BYTE[combine->m_length];
	::memcpy(combine->body,this->body,this->m_length);
    ::memcpy(combine->body+this->m_length,rcd2.body,rcd2.m_length);
	return combine;
}

unsigned short Record::Hash()
{
	WORD i;
	UINT sum=0;
	for(i=0;i<m_length;i++)
	{
		sum+=UINT(body[i]);
	}

	return (sum%HASH);
}

Record * Record::Shadow(BYTE *mask,Relationship *pR1,Relationship *pR2)
{
    UINT pos;
	WORD i;
    Record *shadow=new Record;//ID=0;body=NULL;pattern=NULL;length=0;
	shadow->m_length=m_length;
	shadow->pattern=pattern;////////////////////////////
	shadow->body=new BYTE[m_length];
	::memset(shadow->body,0,m_length);

	WORD AttrCount=0;
	WORD AttrLength=0;
	BYTE *lpShadow=shadow->body,*lpSrc=body;

	if(pR1||pR2)
	    AttrCount=pR1->attr_num+pR2->attr_num;
	else
	{
		pR1=pattern;
		AttrCount=pattern->attr_num;
	}
	for(i=1,pos=1;i<=AttrCount;i++,pos++)
	{
        
		if(pos>=1 && pos<=pR1->attr_num)
		{
		    AttrLength=pR1->at[pos].length;
			if(pR1->at[pos].type==CHAR_TYPE)
				AttrLength++;
			else if(pR1->at[pos].type==VARCHAR_TYPE)
				AttrLength+=2;
			if(mask[i])
			{
				::memcpy(lpShadow,lpSrc,AttrLength);
			}
			lpShadow=lpShadow+AttrLength;
			lpSrc=lpSrc+AttrLength;
		}
		else if(pos>pR1->attr_num)
		{
			AttrLength=pR2->at[pos-pR1->attr_num].length;
			if(pR2->at[pos-pR1->attr_num].type==CHAR_TYPE)
				AttrLength++;
			else if(pR2->at[pos-pR1->attr_num].type==VARCHAR_TYPE)
				AttrLength+=2;
			if(mask[i])
			{
				::memcpy(lpShadow,lpSrc,AttrLength);
			}
			lpShadow=lpShadow+AttrLength;
			lpSrc=lpSrc+AttrLength;
		}
	}
	return shadow;
}

KEY Record::AttrToKey(WORD pos)//不支持UINT
{
    CMemFile cmf;
	KEY k;
	k.type=pattern->at[pos].type;
	if(k.type==VARCHAR_TYPE)
		k.type=CHAR_TYPE;
	
	cmf.Attach(this->body,this->m_length);
	cmf.Seek(pattern->at[pos].offset,CFile::begin);
	
	switch(pattern->at[pos].type)
	{
	case INT_TYPE:
		cmf.Read(&k.VAL.ival,sizeof(int));
		break;
	case FLOAT_TYPE:
		cmf.Read(&k.VAL.fval,sizeof(float));
		break;
	case CHAR_TYPE:
		{
			char * chval=new char[(pattern->at[pos].length)+1 ];
			cmf.Read(chval,(pattern->at[pos].length)+1 );
			if( (pattern->at[pos].length)+1<KEY_LENGTH)
			    ::memcpy(k.VAL.sval,chval,pattern->at[pos].length+1);
			else
				::memcpy(k.VAL.sval,chval,KEY_LENGTH-1);
			delete []chval;
			break;
		}
	case VARCHAR_TYPE:
		{
			BYTE len=0;
            cmf.Read(&len,sizeof(BYTE));
			char *vchval=new char[len];
			cmf.Read(vchval,len);
			if( (len+1)<KEY_LENGTH)
				::memcpy(k.VAL.sval,vchval,len+1);
			else
				::memcpy(k.VAL.sval,vchval,KEY_LENGTH-1);
			delete []vchval;
			break;
		}
	case TIME_TYPE:
		{
			CString s;
			char *val=new char[pattern->at[pos].length];
			cmf.Read(val,pattern->at[pos].length);
			s=CString(val);
			Time time(s);
			k.VAL.tval[0]=time.tag;
	        k.VAL.tval[1]=time.hour;
	        k.VAL.tval[2]=time.minute;
	        k.VAL.tval[3]=time.second;
		    delete []val;
			break;
		}
	case DATE_TYPE:
		{
			CString s;
			char *val=new char[pattern->at[pos].length];
			cmf.Read(val,pattern->at[pos].length);
			s=CString(val);
			Date date(s);
			k.VAL.dval[0]=date.tag;
		    k.VAL.dval[1]=date.year;
	        k.VAL.dval[2]=date.month;
	        k.VAL.dval[3]=date.day;
			delete []val;
			break;
		}
	default:break;
	}
	cmf.Detach();
	return k;
}

void Record::Draw(UINT Count,CListCtrl &List,Relationship *R1,Relationship *R2,BYTE mask[])
{
	WORD i;
    CString s;
	WORD j=0;
	s.Format("%d",Count);
	List.InsertItem(Count,s);
	if(!R1)
	{
		ASSERT(!R2);
		for(i=1;i<=pattern->attr_num;i++)
		{
            if(mask[i]==1)
			{
                s=AttrToString(i);
			    List.SetItemText(Count,j,s);
				j++;
			}
		}
	}
	else
	{
		for(i=1;i<=R1->attr_num+R2->attr_num;i++)
		{
			if(mask[i]==1)
			{
				s=AttrToString(i,R1,R2);
				List.SetItemText(Count,j,s);
				j++;
			}
		}
	}
}


BOOL Record::AddValues(CString *values)
{
    BOOL correct=TRUE;
    CString s;   
	CMemFile cmf;
	cmf.Attach(body,m_length);
	cmf.SeekToBegin();
	
    for(WORD i=1;i<=pattern->attr_num && correct;i++)
	{
		switch(pattern->at[i].type)
		{
			case INT_TYPE:
			{
				int ival=0;
			    correct=CMemory::ATOI(values[i],ival);
			    if(correct)
			        cmf.Write(&ival,sizeof(int));
			    break;
			}
			case FLOAT_TYPE:
			{
				float fval=0;
			    correct=CMemory::ATOF(values[i],fval);
			    if(correct)
			        cmf.Write(&fval,sizeof(float));
			    break;
			}
			case CHAR_TYPE:
			{
				int lp=pattern->at[i].length;//已经不包括'/0'
				int l=values[i].GetLength();
				if(l<lp)//字符串长度不够
					for(int i=0;i<lp-l;i++)
						values[i]+='\0';
				CString s=values[i].Left(lp);
				
				char end='\0';
				cmf.Write(LPCTSTR(s), lp);
				cmf.Write(&end,sizeof(char));//要写/0 ??????????????????????????//???
				break;
			}
			case VARCHAR_TYPE:
			{
				///////////   6abcde!!!!'/0'  //////////////////////////////////////////
				CString s("");
				int lp=pattern->at[i].length;//已经不包括/0
				int l=values[i].GetLength();
				if(l<lp)//字符串长度不够
					for(int i=0;i<lp-l;i++)
						values[i]+='\0';
				s=values[i].Left(lp);
				if(l>lp)
					l=lp;
				BYTE len=l+1;//真正长度+1
				char end='\0';
				cmf.Write(&len,sizeof(BYTE));
				cmf.Write(LPCTSTR(s),lp);
				cmf.Write(&end,sizeof(char));//要写/0 ??????????????????????????//???
				break;
			}
			case DATE_TYPE:
			{
				char end='\0';
				Date d;
				correct=CMemory::ATODate(values[i],d);
				if(correct)
				{
					CString ds=d.DateToCString();
					cmf.Write(LPCTSTR(ds),pattern->at[i].length-1);
					cmf.Write(&end,sizeof(char));//要写/0 ??????????????????????????//???
				}
				break;
			}
			case TIME_TYPE:
			{
				char end='\0';
				Time t;
				correct=CMemory::ATOTime(values[i],t);
				if(correct)
				{
					CString ts=t.TimeToCString();
					cmf.Write(LPCTSTR(ts),pattern->at[i].length-1);
					cmf.Write(&end,sizeof(char));//要写/0 ??????????????????????????//???
				}
				break;
			}
			default:
			{
				//什么都不是
				break;
			}
		}
	}
	cmf.Detach();
    return correct;
}