cdbf.cpp

dbf文件的读写类。它直接对dbf文件进行文件级的操作

		return DBF_FAIL;

	recInfo.rec_data[fld_info[i].offset + 1] = fldValue;
	return DBF_SUCCESS;
}

int CFDBF::FillFldValue(const char *fldName, unsigned int fldValue)
{
	char tmpstr[MAX_FLD_DATALEN+1];
	char fmt[30];
	long i;

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

	sprintf(fmt,"%%%dd",fld_info[i].width);
	sprintf(tmpstr,fmt,(int)fldValue);
	memcpy(recInfo.rec_data+1+fld_info[i].offset, tmpstr, fld_info[i].width);
	return DBF_SUCCESS;
}

int CFDBF::FillFldValue(const char *fldName, long fldValue)
{
	char tmpstr[MAX_FLD_DATALEN+1];
	char fmt[30];
	long i;

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

	sprintf(fmt,"%%%dld",fld_info[i].width);
	sprintf(tmpstr,fmt,fldValue);
	memcpy(recInfo.rec_data+1+fld_info[i].offset, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}
int CFDBF::FillFldValue(const char *fldName, unsigned long fldValue)
{
	char tmpstr[MAX_FLD_DATALEN+1];
	char fmt[30];
	long i;

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

	sprintf(fmt,"%%%dld",(long)fld_info[i].width);
	sprintf(tmpstr,fmt,fldValue);
	memcpy(recInfo.rec_data+1+fld_info[i].offset, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::FillFldValue(const char *fldName, double fldValue)
{
	char tmpstr[MAX_FLD_DATALEN+1];
	char fmt[30];
	long i;

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

	sprintf(fmt,"%%%d.%df",fld_info[i].width,fld_info[i].dec_d);
	sprintf(tmpstr,fmt,fldValue);
	memcpy(recInfo.rec_data+1+fld_info[i].offset, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::MoveLast()
{
	GetRecordNum();
	if (recInfo.rec_num==0)
	{
		strcpy(errMessage,"not exists record");
		return DBF_FAIL;
	}
	m_nCurrOffset=m_nRecBeginOffset+(recInfo.rec_num-1)*recInfo.rec_size;
	m_nCurrRecNo=recInfo.rec_num;
	strcpy(errMessage,"is last record");
	return DBF_SUCCESS;
}

int CFDBF::MoveFirst()
{
	m_nCurrOffset = m_nRecBeginOffset;
	m_nCurrRecNo = 1;
	return DBF_SUCCESS;
}


int CFDBF::MoveNext()
{
    //1、判断是否为空表
	GetRecordNum();
	if (recInfo.rec_num==0)
	{
		strcpy(errMessage,"not exists record");
		return DBF_FAIL;
	}

    //2、判断指针是否超界了
	if (IsEof())
	{
		strcpy(errMessage,"is eof.");
		return DBF_FAIL;
	}


	m_nCurrOffset = m_nRecBeginOffset + (m_nCurrRecNo * recInfo.rec_size);
	m_nCurrRecNo  = m_nCurrRecNo + 1;
	strcpy(errMessage,"ok!");
	return DBF_SUCCESS;
}


int CFDBF::FindRecord(const char *fldName, const char *fldValue)
{
	long fldOffset=0,j,tmpoffset,tmprecordno=1;
        int nRc;

	fldOffset = FindFld(fldName);
	if (fldOffset < 0)
		return DBF_FAIL;

	tmpoffset=m_nRecBeginOffset;//记录开始位置
	GetRecordNum();
	for(j=0;j<(int)recInfo.rec_num;j++)
	{

                m_nCurrOffset=tmpoffset;   // 纪录偏移量 LockRecord要用

		if ((nRc=LockRecord())==DBF_FAIL) //
		{
			return nRc;
		}
                lseek(_dbfhandle, tmpoffset, SEEK_SET);

                 //重大修改，使recInfo.rec_data有数据 ,add by wjf 2002.12.10
                if(read(_dbfhandle, recInfo.rec_data, recInfo.rec_size)!=recInfo.rec_size)
                      return DBF_FAIL;

             if ((nRc = UnlockRecord())==DBF_FAIL)
                      return nRc;



               if (memcmp(recInfo.rec_data+fld_info[fldOffset].offset + 1,fldValue,fld_info[fldOffset].width)==0)
		{
			m_nCurrRecNo=tmprecordno;  //纪录号
			m_nCurrOffset=tmpoffset;   // 纪录偏移量
			strcpy(errMessage,"fount record");
			return DBF_SUCCESS;
		}
		tmprecordno++;
		tmpoffset+=recInfo.rec_size;
	}

	strcpy(errMessage,"don't found record");
	return DBF_FAIL;
}

char *CFDBF::GetErrorMsg()
{
    return errMessage;
}

int CFDBF::GetColNum()
{
    return (recInfo.fld_num);
}

const FIELD_INFO * CFDBF::GetColInfo(int colNo)
{
  if( recInfo.fld_num <= 0 || colNo >= recInfo.fld_num)
    return (const FIELD_INFO *)NULL;
  return &fld_info[colNo];
}

int CFDBF::Zap()
{
	int fp;
    unsigned long tmp_rec_num;

    if (_open == false)
        return DBF_FAIL;

    close(_dbfhandle);

	if((fp = _sopen(m_FileName, O_BINARY | O_RDWR, S_IREAD | S_IWRITE)) == -1)
		return DBF_FAIL;

	//写记录数
	lseek(fp, 4L, SEEK_SET);
    tmp_rec_num = 0L;
	write(fp, &tmp_rec_num, 4);

	chsize(fp, m_nStructSize);

    m_HeadLockType = 'H';

    ModifyFileDate();

    if(errno != 0)
    return DBF_FAIL;
    ReOpen();
	return DBF_SUCCESS;
}

char * CFDBF::GetFileName()
{
    return m_FileName;
}

int CFDBF::ReOpen()
{
    return(Open(m_FileName, m_OpenType, m_LockType));
}

int CFDBF::DeleteRecord(long recNo)
{
    if (recNo < 1L || recNo > GetRecordNum())
        return DBF_FAIL;
    ReadRecord(recNo);
    recInfo.rec_data[0] = '*';
    return(UpdateRecord());
}

int CFDBF::UnDeleteRecord(long recNo)
{
    if (recNo < 1L || recNo > GetRecordNum())
        return DBF_FAIL;
    ReadRecord(recNo);
    recInfo.rec_data[0] = RECORD_BEGIN_FLAG;
    return(UpdateRecord());
}

int CFDBF:: UpdateRecord()
{
 //调用该函数之前必须先调用ReadRecord()、FindRecord()就是
 //为了recInfo.rec_data中有数据,并且定位m_nCurrOffset
 // 修改了recInfo.rec_data（可以用UpdateFldValue）,调用此函数
    int nRc;
    if (m_CurrLockType == _AutoLock)
    {
        if ((nRc = LockRecord())==DBF_FAIL)
            return nRc;

    }

    lseek(_dbfhandle, m_nCurrOffset, SEEK_SET);
    if (write(_dbfhandle, recInfo.rec_data, recInfo.rec_size) != recInfo.rec_size)
        nRc == DBF_FAIL;

    if (m_CurrLockType == _AutoLock)
    {
        if ((nRc = UnlockRecord())==DBF_FAIL)
        {
            return nRc;
        }


    }

    if (nRc == DBF_FAIL)
        return nRc;

    m_HeadLockType = 'H';
    ModifyFileDate();

    return DBF_SUCCESS;

}

int CFDBF::UpdateFldValue(const char *fldName, const char *fldValue)
{
	long i;

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

	memcpy(recInfo.rec_data + fld_info[i].offset+1, fldValue,fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::UpdateFldValue(const char *fldName, int fldValue)
{
	long i;
    char tmpstr[MAX_FLD_DATALEN+1];
    char fmtStr[20];

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

    sprintf(fmtStr, "%%%dd", fld_info[i].width);
    sprintf(tmpstr, fmtStr, fldValue);

	memcpy(recInfo.rec_data + fld_info[i].offset+1, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::UpdateFldValue(const char *fldName, unsigned int fldValue)
{
	long i;
    char tmpstr[MAX_FLD_DATALEN+1];
    char fmtStr[20];

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

    sprintf(fmtStr, "%%%dd", fld_info[i].width);
    sprintf(tmpstr, fmtStr, fldValue);

	memcpy(recInfo.rec_data + fld_info[i].offset+1, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::UpdateFldValue(const char *fldName, long fldValue)
{
	long i;
    char tmpstr[MAX_FLD_DATALEN+1];
    char fmtStr[20];

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

    sprintf(fmtStr, "%%%dld", fld_info[i].width);
    sprintf(tmpstr, fmtStr, fldValue);

	memcpy(recInfo.rec_data + fld_info[i].offset+1, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::UpdateFldValue(const char *fldName, unsigned long fldValue)
{
	long i;
    char tmpstr[MAX_FLD_DATALEN+1];
    char fmtStr[20];

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

    sprintf(fmtStr, "%%%dld", fld_info[i].width);
    sprintf(tmpstr, fmtStr, fldValue);

	memcpy(recInfo.rec_data + fld_info[i].offset+1, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::UpdateFldValue(const char *fldName, double fldValue)
{
	long i;
    char tmpstr[MAX_FLD_DATALEN+1];
    char fmtStr[20];

	i = FindFld(fldName);
	if (i < 0)
		return DBF_FAIL;

    if (fld_info[i].type == 'N' || fld_info[i].type == 'F')
        sprintf(fmtStr, "%%%d.%df", fld_info[i].width, fld_info[i].dec_d);
    else
        sprintf(fmtStr, "%%%d.2f", fld_info[i].width);
    sprintf(tmpstr, fmtStr, fldValue);

	memcpy(recInfo.rec_data + fld_info[i].offset+1, tmpstr, fld_info[i].width);

	return DBF_SUCCESS;
}

int CFDBF::LockFile()
{
    time_t t1, t2;
    int RetCode;

    time(&t1);
    
    do  {
        RetCode = lock(_dbfhandle, BASE_LOCK_OFFSET, LOCK_FILE_LEN);
        //锁定整个文件
        time(&t2);
    }while(difftime(t2, t1) <= 5 && RetCode != 0); // 5 秒 操时

	if(RetCode == 0)
          return DBF_SUCCESS;
	else
        return DBF_FAIL;

}

int CFDBF::UnlockFile()
{
    int RetCode = 0;
    RetCode = unlock(_dbfhandle, BASE_LOCK_OFFSET, LOCK_FILE_LEN);
    //解锁整个文件
    if(RetCode == 0)
     return DBF_SUCCESS;
    else
        return DBF_FAIL;

}

int CFDBF::AddField(const char *fieldName, char type, unsigned short width, unsigned short decWidth)
{
    char tmpstr[12];

    if (m_FieldNum >= 255)
        return DBF_FAIL;

    if (type != 'C' && type != 'N' && type != 'D')
        return DBF_FAIL;

    m_pField[m_FieldNum] = new DBF_FIELD_INFO;

    if (!m_pField)
    {
        ClearFieldInfo();
        return DBF_FAIL;
    }

    sprintf(tmpstr, "%-10s", fieldName);
    memcpy(m_pField[m_FieldNum]->fieldName, tmpstr, 10);
    m_pField[m_FieldNum]->standby = 0;
    m_pField[m_FieldNum]->type = type;
    m_pField[m_FieldNum]->width = width;
    m_pField[m_FieldNum]->decWidth = (char)decWidth;
    memset(m_pField[m_FieldNum]->other, 0, sizeof(m_pField[m_FieldNum]->other));

    m_FieldNum++;

    return DBF_SUCCESS;
}

int CFDBF::Create(const char *fileName)
{
    char tmpstr[20];
    FILE * fp;
    int i;

    if (fileName[0] == 0)
    {
        strcpy(errMessage, "fileName is Null.");
        ClearFieldInfo();
        return DBF_FAIL;
    }

    if (m_FieldNum <= 0 || m_FieldNum > 255)
        return DBF_FAIL;

    if((fp = fopen(fileName, "wb+")) == NULL)
    {
        ClearFieldInfo();
        return DBF_FAIL;
    }

    time_t t;
    struct tm tmlocal;

    t = ::time(&t);
    tmlocal = *(::localtime(&t));

    DBF_HEAD _head;
    _head.fileFlag = 0x03;
	_head.lastDate[0] = (unsigned char)(tmlocal.tm_year % 100);
	_head.lastDate[1] = (unsigned char)(tmlocal.tm_mon + 1);
	_head.lastDate[2] = (unsigned char)tmlocal.tm_mday;
    _head.recNum = 0;
    _head.structSize = (unsigned short)(FILE_HEAD_LEN + 32 * m_FieldNum);
    _head.recSize = 0;

    for(i = 0; i < m_FieldNum; i++)
    {
        _head.recSize += m_pField[i]->width;
    }
    _head.recSize++;

    memset(_head.other, 0, sizeof(_head.other));

    if(fwrite(&_head, sizeof(DBF_HEAD), 1, fp) != 1)
    {
        fclose(fp);
        ClearFieldInfo();
        return DBF_FAIL;
    }

    for (i = 0; i < m_FieldNum; i++)
    {
        if(fwrite(m_pField[i], sizeof(DBF_FIELD_INFO), 1, fp) != 1)
        {
            fclose(fp);
            ClearFieldInfo();
            return DBF_FAIL;
        }
    }

    strcpy(tmpstr, "\x0d");
    fwrite(tmpstr, 1, 1, fp);
    fclose(fp);

    ClearFieldInfo();

    return DBF_SUCCESS;
}

void CFDBF::ClearFieldInfo()
{
    int i;

    for(i = 0; i < m_FieldNum; i++)
        delete m_pField[i];
    m_FieldNum = 0;
}


int CFDBF:: ReplaceRecord(long recNo,char*ReocordMem)
{
   // ReocordMem和纪录的定义一模一样
    int nRc;
    unsigned long tmp_rec_num=0;
    char tmpchr[2];

    if (recNo < 1L)
        return DBF_FAIL;

    if(recNo > GetRecordNum())  //追加一条纪录
    {

      if (LockFile() == DBF_FAIL)
        return ((int)DBF_FAIL);

       GetRecordNum();

       m_nCurrOffset = m_nRecBeginOffset + recInfo.rec_num * recInfo.rec_size;
       lseek(_dbfhandle, m_nCurrOffset + recInfo.rec_size, SEEK_SET); //偏移到文件未

       nRc = write(_dbfhandle, recInfo.rec_data, recInfo.rec_size);//写纪录
       if (nRc != recInfo.rec_size)
        {
         UnlockFile();
         return ((int)DBF_FAIL);
        }

       tmp_rec_num = recInfo.rec_num + 1L;

	//写记录数
       lseek(_dbfhandle, 4L, SEEK_SET);
       nRc = write(_dbfhandle, &tmp_rec_num, 4);
       recInfo.rec_num++; //纪录数增加

       lseek(_dbfhandle, m_nCurrOffset + recInfo.rec_size, SEEK_SET);	//写文件结束符

       tmpchr[0] = FILE_EOF_FLAG;
       nRc = write(_dbfhandle, tmpchr, 1);

       m_HeadLockType = 'F';
       ModifyFileDate();

    if (UnlockFile() == DBF_FAIL)
        return ((int)DBF_FAIL);

     return DBF_SUCCESS;

    }


    //存在的纪录，就替换
   if ((nRc=GoTo(recNo))==DBF_FAIL)  //定位 m_nCurrOffset
		return nRc;

    if (m_CurrLockType == _AutoLock)
    {
        if ((nRc = LockRecord())==DBF_FAIL)
            return nRc;

    }

    lseek(_dbfhandle, m_nCurrOffset, SEEK_SET);
    if (write(_dbfhandle, ReocordMem, recInfo.rec_size) != recInfo.rec_size)//直接写
        nRc == DBF_FAIL;

    if (m_CurrLockType == _AutoLock)
    {
        if ((nRc = UnlockRecord())==DBF_FAIL)
        {
            return nRc;
        }

    }



    if (nRc == DBF_FAIL)
        return nRc;

     m_HeadLockType = 'H';
     ModifyFileDate();

     return DBF_SUCCESS;

}


//功能：取得当前的记录序号
//注意：要使用此函数必须保证已经成功打开DBF文件了
long CFDBF::GetCurrentRecNo(void)
{
    return m_nCurrRecNo;
}

//功能：取得一条记录的大小
//注意：要使用此函数必须保证已经成功打开DBF文件了
int  CFDBF::GetRecordSize(void)
{
    return recInfo.rec_size;
}