dbf.cpp

读写DBF文件的库

	if( dbf_handle == NULL || dbf_handle->handle == -1)
		return FALSE;

	return ( dbf_handle->record_buf[0] == '*' );
}

//getfieldvalue 系列函数
char * Dbf::GetFieldValue(const char *field_name, char *field_value,int size, 
						   BOOL bFormat,char * field_type) 
{
	int rec_offset, width;

	if( dbf_handle == NULL || dbf_handle->handle == -1)
		return (NULL) ;

	char * record_buf = dbf_handle->record_buf;
	FIELD_LIST *plist = look_field(field_name);
	if (plist != NULL)
	{
		field_value[0] = 0;
		rec_offset = plist->m_start;
		width = min(FieldLen(plist) + 1, size);
		memcpy(field_value, (char *)(record_buf + rec_offset), width);
		if(width >= 1)
			field_value[width-1] = 0;
		if( field_type != NULL )
			*field_type = plist->field_rec.field_type;
		if(bFormat) formatstr( field_value );
		return field_value;
	}
	return NULL;
}

BOOL  Dbf::GetFieldValue(const char *field_name, long &value)
{
	char buf[24];
	
	if( GetFieldValue((char *)field_name,(char *)buf,sizeof(buf)) != NULL)
	{
		value = atol( buf ) ;
		return TRUE;
	}
	return FALSE;
}

BOOL  Dbf::GetFieldValue(const char *field_name, int &value)
{
	char buf[24];
	
	if( GetFieldValue((char *)field_name,(char *)buf,sizeof(buf)) != NULL)
	{
		value = atoi( buf ) ;
		return TRUE;
	}
	return FALSE;
}

BOOL  Dbf::GetFieldValue(const char *field_name, short &value)
{
	char buf[24];
	
	if( GetFieldValue((char *)field_name,(char *)buf,sizeof(buf)) != NULL)
	{
		value = (short)atoi( buf ) ;
		return TRUE;
	}
	return FALSE;
}

BOOL  Dbf::GetFieldValue(const char *field_name, float &value)
{
	char buf[24];
	
	if( GetFieldValue((char *)field_name,(char *)buf,sizeof(buf)) != NULL)
	{
		value = (float)atof( buf ) ;
		return TRUE;
	}
	return FALSE;
}

BOOL Dbf::GetFieldValue(const char *field_name, double &value)
{
	char buf[24];
	
	if( GetFieldValue((char *)field_name,(char *)buf,sizeof(buf)) != NULL)
	{
		value = atof( buf ) ;
		return TRUE;
	}
	return FALSE;
}

///////////
BOOL  Dbf::AppendBlank( void )
{
    ClearRecBuf();
    return ( Append() );
}


BOOL  Dbf::Append( const char *id_fname/*=NULL*/ )
{
	const char ch = 0x1a;

    if( (dbf_handle == NULL) || 
		(dbf_handle->handle == -1) )
		return FALSE;
	
	if ( lock_dbf_head() == FALSE )
	{                  
		printf( " .. lock fail .. " ) ;  
        return FALSE;
	}
    
    lseek( dbf_handle->handle , 0L , SEEK_SET ) ;
    read(dbf_handle->handle,(char *)&dbf_handle->dbf_head,sizeof(DBF_HEAD));

    if( id_fname )
    {
		long recnum = ReadRecordCount() + 1; //dbf_handle->dbf_head.last_rec + 1; 
		SetFieldValue(id_fname, recnum );
    }
    
    lseek(dbf_handle->handle, (long)dbf_handle->dbf_head.data_offset
		+ (long)dbf_handle->dbf_head.last_rec *
	      (long)dbf_handle->dbf_head.rec_size, SEEK_SET );
    write(dbf_handle->handle, dbf_handle->record_buf, 
		dbf_handle->dbf_head.rec_size );
    write(dbf_handle->handle, &ch, 1);
	_SetDosDate(&dbf_handle->dbf_head);
    lseek(dbf_handle->handle, 1, SEEK_SET);
    write(dbf_handle->handle, dbf_handle->dbf_head.last_update, 3);
    dbf_handle->dbf_head.last_rec++ ;
    write(dbf_handle->handle, (char *)&dbf_handle->dbf_head.last_rec, sizeof(long));
	
    unlock_dbf_head();
    dbf_handle->curr_rec = dbf_handle->dbf_head.last_rec ;

    return ( TRUE ) ;
}

inline BOOL Dbf::_Update(long rec_num /*=0L*/, int size /*=0*/)
{
    int retu = TRUE ;

    if( dbf_handle == NULL || dbf_handle->handle == -1 )
		return ( FALSE ) ;
	
    if( rec_num == 0L )	rec_num = dbf_handle->curr_rec ;
    if (rec_num < 1 || rec_num > dbf_handle->dbf_head.last_rec)
		return FALSE ;

	if(size==0) size = dbf_handle->dbf_head.rec_size;

    char * record_buf =  dbf_handle->record_buf ;
	
    if ( lock )     
    {
        if ( lock_dbf_head () == FALSE )
            return FALSE;
        else if ( lock_dbf_rec( rec_num, 1L ) == FALSE )
		{
			unlock_dbf_head();
			return FALSE;
        }
    }   
	
    if(lseek(dbf_handle->handle, (long) dbf_handle->dbf_head.data_offset
				+ (long)(dbf_handle->dbf_head.rec_size)*(rec_num-1), SEEK_SET ) == -1 )
    {
		retu = FALSE;
		goto error;
    }
	
    if (write(dbf_handle->handle, record_buf, (unsigned)size) != size)
    {
		retu = FALSE;
		goto error;
    }
	
    if( retu == TRUE )
    {
		_SetDosDate(&dbf_handle->dbf_head);
		lseek(dbf_handle->handle, 1, 0);
		write(dbf_handle->handle, dbf_handle->dbf_head.last_update, 3);
    }
	
    dbf_handle->curr_rec = rec_num  ;
error:
    if( lock )
    {
		unlock_dbf_rec( rec_num, 1L );
		unlock_dbf_head();
    }
	
    return retu ;
}

BOOL Dbf::Update( long rec_num )
{
	return _Update(rec_num, 0);
}


/*****************************************************************************/
BOOL  Dbf::SetFieldValue(const char *field_name , const char * field_value)
{
    FIELD_LIST * plist;
	
    if( dbf_handle == NULL || dbf_handle->handle == -1)
        return ( FALSE ) ;

    char * record_buf = dbf_handle->record_buf ;

	plist = look_field(field_name);
	if((field_value!=NULL) && (plist!=NULL))
	{
		int width = FieldLen(plist);
		strncpy(record_buf + plist->m_start, field_value, width);
		return TRUE;
	}
	return FALSE;
}

BOOL Dbf::SetFieldValue(const char *field_name, long  field_value )
{
    if( dbf_handle == NULL || dbf_handle->handle == -1)
        return ( FALSE ) ;

    char * record_buf = dbf_handle->record_buf ;

	FIELD_LIST *plist = look_field(field_name);
	if(plist)
	{
		int width = FieldLen(plist);
		lntoa(field_value, record_buf + plist->m_start, width, 10);
		return TRUE;
	}
	return FALSE;
}

BOOL Dbf::SetFieldValue(const char * field_name , int  field_value)
{
    if( dbf_handle == NULL || dbf_handle->handle == -1)
        return ( FALSE ) ;

    char * record_buf = dbf_handle->record_buf ;

	FIELD_LIST *plist = look_field(field_name);
	if(plist)
	{
		int width = FieldLen(plist);
		intoa(field_value, record_buf + plist->m_start, width, 10);
		return TRUE;
	}
	return FALSE;
}

BOOL Dbf::SetFieldValue(const char * field_name , short field_value )
{
    if( dbf_handle == NULL || dbf_handle->handle == -1)
        return ( FALSE ) ;

    char * record_buf = dbf_handle->record_buf ;

	FIELD_LIST *plist = look_field(field_name);
	if(plist)
	{
		int width = FieldLen(plist);
		intoa(field_value, record_buf + plist->m_start, width, 10);
		return TRUE;
	}
	return FALSE;
}

BOOL Dbf::SetFieldValue(const char * field_name ,  float  field_value )
{ 
	char buf[40] ;
	int  width;
	FIELD_LIST * plist;

	if( dbf_handle == NULL || dbf_handle->handle == -1)
		return ( FALSE ) ;

	char * record_buf = dbf_handle->record_buf ;

	plist = look_field(field_name);
	if(plist)
	{
		width = FieldLen(plist);
		if (plist->field_rec.field_type == 'N')
			snprintf(buf, sizeof(buf), "%*.*f", width,
						plist->field_rec.linfo.N.dec,
						field_value);
		else
			snprintf(buf, sizeof(buf), "%-*f", width, field_value);
		memcpy(record_buf + plist->m_start, buf, width );
		return TRUE;
	}
	return FALSE;
}

BOOL Dbf::SetFieldValue(const char * field_name, double field_value )
{
	char buf[40] ;
	int  width;
	FIELD_LIST * plist;

	if( dbf_handle == NULL || dbf_handle->handle == -1)
		return ( FALSE ) ;

	char * record_buf = dbf_handle->record_buf ;

	plist = look_field(field_name);
	if(plist)
	{
		width = FieldLen(plist);
		if (plist->field_rec.field_type == 'N')
			snprintf(buf, sizeof(buf), "%*.*lf", width,
						plist->field_rec.linfo.N.dec,
						field_value);
		else
			snprintf(buf, sizeof(buf), "%-*lf", width, field_value);
		memcpy(record_buf + plist->m_start, buf, width );
		return TRUE;
	}
	return FALSE;
}

////////////////////////////////////////////////////////////////////////
BOOL Dbf::lock_dbf_rec( long rec, long recnum )
{
	long  offset1, offset2, offset3;
	BOOL  bRet;
	
	offset1 = LOCK_F_OFFSET + (( long )dbf_handle->dbf_head.data_offset) + 
				((long) dbf_handle->dbf_head.rec_size ) * (rec - 1L);
	offset2 = LOCK_C_OFFSET + rec;
	offset3 = LOCK_CDX_TABLE_OFFSET - rec;
	
	long elapsed_time;
	time_t   start, finish;
	time( &start );
	bRet = FALSE;
    
    do{
		if( LockFile( offset1,( ( long )dbf_handle->dbf_head.rec_size ) * recnum ) == TRUE )
		{
			if( ( bRet = LockFile( offset2, rec * 1L ) ) != TRUE )
				UnlockFile( offset1, ( (long ) dbf_handle->dbf_head.rec_size ) * recnum );      
			else if( ( bRet = LockFile( offset3, rec * 1L ) ) != TRUE )
			{
				UnlockFile( offset2, rec * 1L );
				UnlockFile( offset1,( (long ) dbf_handle->dbf_head.rec_size ) * recnum );       
			}   
			
		}
		time( &finish );
		elapsed_time = (long)difftime( finish, start );
	}while( elapsed_time <= WAIT_TIME && bRet == FALSE );
	
	return bRet;
} 

BOOL Dbf::unlock_dbf_rec( long rec, long recnum )
{
	BOOL bRet1, bRet2, bRet3;
	long offset1, offset2, offset3;
	
	
	offset1 = LOCK_F_OFFSET + (( long )dbf_handle->dbf_head.data_offset) + 
		( (long) dbf_handle->dbf_head.rec_size ) * (rec - 1L);
	offset2 = LOCK_C_OFFSET + rec;
	offset3 = LOCK_CDX_TABLE_OFFSET - rec;
	
	bRet1 = UnlockFile( offset1,( ( long )dbf_handle->dbf_head.rec_size ) * recnum ); 
	bRet2 = UnlockFile( offset2, rec * 1L );
	bRet3 = UnlockFile( offset3, rec * 1L );
	
	return ( bRet1 == TRUE && bRet2 == TRUE && bRet3 == TRUE ) ? TRUE  : FALSE;
}

BOOL Dbf::lock_dbf_file( void )
{
	BOOL  bRet;
	
	long elapsed_time;
	time_t   start, finish;
	time( &start );
	do{
		bRet = LockFile( LOCK_DBF_BEGIN, LOCK_DBF_LENGTH );
		time( &finish );
		elapsed_time = (long)difftime( finish, start );
	}while ((elapsed_time <= WAIT_TIME) && (bRet == FALSE ));
	return bRet;
}

BOOL Dbf::unlock_dbf_file( void )
{
	return UnlockFile( LOCK_DBF_BEGIN, LOCK_DBF_LENGTH );
}

BOOL Dbf::lock_dbf_head( void )
{
	BOOL  bRet;
	long elapsed_time;
	time_t   start, finish;
	time( &start );
	bRet =  FALSE;
	
	do{
		if( LockFile ( LOCK_F_OFFSET, 1L ) )
		{
			if( ( bRet = LockFile( LOCK_C_OFFSET, 1L ) ) != TRUE ) 
			{
				UnlockFile( LOCK_F_OFFSET, 1L );
			} 
			else if( ( bRet = LockFile( LOCK_CDX_TABLE_OFFSET, 1L ) ) != TRUE )
			{
				UnlockFile( LOCK_C_OFFSET, 1L );
				UnlockFile( LOCK_F_OFFSET, 1L );
			}   
        }
		time( &finish );
		elapsed_time = (long)difftime( finish, start );
	}while( elapsed_time <= WAIT_TIME && bRet == FALSE );
	
	return bRet ;
}

BOOL Dbf::unlock_dbf_head( void )
{
	BOOL bRet3 = UnlockFile( LOCK_CDX_TABLE_OFFSET, 1L );
	BOOL bRet2 = UnlockFile( LOCK_C_OFFSET, 1L );
	BOOL bRet1 = UnlockFile( LOCK_F_OFFSET, 1L );
	
	return ( bRet1 == TRUE && bRet2 == TRUE && bRet3 == TRUE ) ? TRUE : FALSE;
}

BOOL Dbf::LockFile( long offset, long /*rec_size */)
{
    if (lseek(dbf_handle->handle, offset, SEEK_SET ) == -1)
		return FALSE;
    
//    if( locking( dbf_handle->handle, _LK_NBLCK, rec_size ) == 0 )
        return TRUE;
//    else
//        return FALSE;
}

BOOL Dbf::UnlockFile( long offset, long /*rec_size */)
{
    if (lseek(dbf_handle->handle, offset, SEEK_SET ) == -1)
		return FALSE;
    
//	if( locking( dbf_handle->handle, _LK_UNLCK, rec_size ) == 0 )
		return TRUE;
//    else
//		return FALSE;
}  

//////////////////////////////////////////////////////////////////////
void Dbf::AddField(FIELD_REC &field_rec,const char *fieldname,
				   char fieldtype,ushort len,uchar dec)
{
	if((fieldname==NULL) || (fieldname[0]==0))
	{
		field_rec.field_name[0] = 0;
		return ;
	}

	memset(&field_rec, 0, sizeof(FIELD_REC));
	strncpy(field_rec.field_name, fieldname, sizeof(field_rec.field_name));
	field_rec.field_type = fieldtype;
	if(fieldtype == 'N')
	{
		field_rec.linfo.N.len = (uchar)len;
		field_rec.linfo.N.dec = (uchar)dec;
	}
	else field_rec.linfo.wlen = (ushort)len;
}

void  Dbf::SetFieldCName( char * field_name , char * fieldChName )
{
	FIELD_LIST *plist = look_field(field_name);
	if(plist)
	{
		if(plist->cname) delete plist->cname;
		plist->cname = new char [ strlen(fieldChName) + 1];
		strcpy(plist->cname, fieldChName);
	}
}

//private:
inline short Dbf::FieldLen( FIELD_LIST * plist )
{
	return ( plist->field_rec.field_type == 'N') ? 
			 (plist->field_rec.linfo.N.len) : 
			 (plist->field_rec.linfo.wlen);
}

char * Dbf::RecordBuf( void )    // 返回当前记录缓冲指针
{
	if( dbf_handle == NULL || dbf_handle->handle == -1 )
		return ( NULL ) ;
	return ( dbf_handle->record_buf ) ;
}

//取全部字段名称列表。
BOOL Dbf::GetFieldName(char *sa[], int item_size, int item_num)  
{
    FIELD_LIST * flist_ptr;
	int max_fields;
	char *p;

    if( dbf_handle == NULL || dbf_handle->handle == -1)
        return ( FALSE ) ;

	max_fields = min(item_num, MAX_FIELDS);
	for(int i=0; (i<max_fields); i++)
	{
		flist_ptr = dbf_handle->field_list[i];
		if(flist_ptr==NULL) break;
		p = sa[i];
		strncpy(p, flist_ptr->field_rec.field_name, item_size);
		p[item_size-1] = 0;
	}
	return ( TRUE );
}