tdbf.cpp

一个与银行通讯的测试程序

    if(m_openMode & XbaseLock)
	{
		lseek(m_fp, offset, SEEK_SET);
        result = _locking(m_fp, LK_UNLCK, (long) m_head.RecordWidth);
	}
    else
	{
		lseek(m_fp, offset, SEEK_SET);
        result = _locking(m_fp, LK_UNLCK, 1L);
	}

    if(result != 0)
        m_errorCode = DBF_UNLOCK_RECORD_ERROR;
}

void TDBF::LockHead()
{
    long offset;
    time_t t1, t2;
    int result;

    m_errorCode = DBF_SUCCESS;

    if(m_openMode & XbaseLock)
        offset = XBASE_LOCK_OFFSET + 1L;
    else
        offset = CLIPPER_LOCK_OFFSET + 1L;

    time(&t1);
    do
    {
       lseek(m_fp, offset, SEEK_SET);
       result = _locking(m_fp, LK_NBLCK, 1L);
       time(&t2);
    } while(difftime(t2, t1) <= m_lockWaitTime && result != 0);

    if(result != 0)
      m_errorCode = DBF_UNLOCK_HEAD_ERROR;
}

void TDBF::UnlockHead()
{
    long offset;
    int result;

    m_errorCode = DBF_SUCCESS;

    if(m_openMode & XbaseLock)
        offset = XBASE_LOCK_OFFSET + 1L;
    else
        offset = CLIPPER_LOCK_OFFSET + 1L;

    lseek(m_fp, offset, SEEK_SET);
    result = _locking(m_fp, LK_UNLCK, 1L);

    if(result != 0)
        m_errorCode = DBF_UNLOCK_HEAD_ERROR;
}

void TDBF::LockFile()
{
    time_t t1, t2;
    int result = -1;

    m_errorCode = DBF_SUCCESS;

    if(m_openMode & ExclOpen)
      return;

    time(&t1);
    do
    {
        lseek(m_fp, XBASE_LOCK_OFFSET, SEEK_SET);
        result = _locking(m_fp, LK_NBLCK, LOCK_FILE_LEN);
        time(&t2);
    } while(difftime(t2, t1) <= m_lockWaitTime && result != 0);

    if(result != 0)
        m_errorCode = DBF_LOCK_FILE_ERROR;
    else
        m_lockType = ltFileLock;
}

void TDBF::UnlockFile()
{
    int result;

    m_errorCode = DBF_SUCCESS;

    if(m_openMode & ExclOpen)
      return;

    lseek(m_fp, XBASE_LOCK_OFFSET, SEEK_SET);
    result = _locking(m_fp, LK_UNLCK, LOCK_FILE_LEN);

    m_lockType = ltNoLock;

    if(result != 0)
        m_errorCode = DBF_UNLOCK_FILE_ERROR;
}

void TDBF::GetField(unsigned int index, char * data, unsigned int len)
{
    m_errorCode = DBF_SUCCESS;

    if(index >= m_fieldNumber)
    {
        m_errorCode = DBF_FIELD_INDEX_ERROR;
        return;
    }

    if(len <= 0)
        len = m_fieldInfo[index].Width;
    else
        len = min(len - 1, m_fieldInfo[index].Width);
    memcpy(data, m_recordBuffer + m_fieldInfo[index].Offset, len);
    data[len] = 0;
}

void TDBF::GetField(const char * name, char * data, unsigned int len)
{
    unsigned int index;

    for(index = 0; index < m_fieldNumber; index ++)
    {
        if(stricmp(name, m_fieldInfo[index].Name) == 0)
            break;
    }

    GetField(index, data, len);
}

void TDBF::GetField(const char * name, char & data)
{
    char buffer[256];

    GetField(name, buffer, 2);

    if(m_errorCode == DBF_SUCCESS)
        data = *buffer;
}

void TDBF::GetField(const char * name, signed short & data)
{
    char buffer[256];

    GetField(name, buffer, sizeof(buffer));

    if(m_errorCode == DBF_SUCCESS)
        data = (signed short) atol(buffer);
}

void TDBF::GetField(const char * name, unsigned short & data)
{
    char buffer[256];

    GetField(name, buffer, sizeof(buffer));

    if(m_errorCode == DBF_SUCCESS)
        data = (unsigned short) atol(buffer);
}

void TDBF::GetField(const char * name, unsigned int & data)
{
    char buffer[256];

    GetField(name, buffer, sizeof(buffer));

    if(m_errorCode == DBF_SUCCESS)
        data = (unsigned int) atol(buffer);
}

void TDBF::GetField(const char * name, signed long & data)
{
    char buffer[256];

    GetField(name, buffer, sizeof(buffer));

    if(m_errorCode == DBF_SUCCESS)
        data = atol(buffer);
}

void TDBF::GetField(const char * name, unsigned long & data)
{
    char buffer[256], *endptr;

    GetField(name, buffer, sizeof(buffer));

    if(m_errorCode == DBF_SUCCESS)
        data = strtoul(buffer, &endptr, 10);
}

void TDBF::GetField(const char * name, double & data)
{
    char buffer[256], *endptr;

    GetField(name, buffer, sizeof(buffer));

    if(m_errorCode == DBF_SUCCESS)
        data = strtod(buffer, &endptr);
}

void TDBF::SetField(unsigned int index, const char * data)
{
    char formatString[20];
    char buffer[255];
    int len;

    m_errorCode = DBF_SUCCESS;

    if(m_fieldNumber <= 0 || index >= m_fieldNumber)
    {
        m_errorCode = DBF_FIELD_INDEX_ERROR;
        return;
    }

    memset(m_recordBuffer + m_fieldInfo[index].Offset, ' ', m_fieldInfo[index].Width);

    if(m_fieldInfo[index].Type == 'N' || m_fieldInfo[index].Type == 'F')
    {
        sprintf(formatString, "%%.%df", m_fieldInfo[index].Dec);
        sprintf(buffer, formatString, atof(data));
        len = min(m_fieldInfo[index].Width, strlen(buffer));
        memcpy(m_recordBuffer + m_fieldInfo[index].Offset + m_fieldInfo[index].Width - len, buffer, len);
    }
    else
    {
        memcpy(m_recordBuffer + m_fieldInfo[index].Offset, data, min(m_fieldInfo[index].Width, strlen(data)));
    }
}

void TDBF::SetField(const char * name, const char * data)
{
    unsigned int index;

    for(index = 0; index < m_fieldNumber; index ++)
    {
        if(stricmp(name, m_fieldInfo[index].Name) == 0)
          break;
    }

    SetField(index, data);
}

void TDBF::SetField(const char * name, char data)
{
    char buffer[256];

    buffer[0] = data;
    buffer[1] = 0;

    SetField(name, buffer);
}

void TDBF::SetField(const char * name, signed int data)
{
    char buffer[256];

    itoa(data, buffer, 10);
    SetField(name, buffer);
}

void TDBF::SetField(const char * name, unsigned int data)
{
    char buffer[256];

    ltoa(data, buffer, 10);
    SetField(name, buffer);
}

void TDBF::SetField(const char * name, signed short data)
{
    char buffer[256];

    itoa(data, buffer, 10);
    SetField(name, buffer);
}

void TDBF::SetField(const char * name, unsigned short data)
{
    char buffer[256];

    ltoa(data, buffer, 10);
    SetField(name, buffer);
}

void TDBF::SetField(const char * name, signed long data)
{
    char buffer[256];

    ltoa(data, buffer, 10);
    SetField(name, buffer);
}

void TDBF::SetField(const char * name, unsigned long data)
{
    char buffer[256];

    ultoa(data, buffer, 10);
    SetField(name, buffer);
}

void TDBF::SetField(const char * name, double data)
{
    char buffer[256], formatString[10];
    unsigned int index;

    for(index = 0; index < m_fieldNumber; index ++)
    {
        if(stricmp(name, m_fieldInfo[index].Name) == 0)
            break;
    }

    if(index >= m_fieldNumber)
    {
        m_errorCode = DBF_FIELD_INDEX_ERROR;
        return;
    }

    sprintf(formatString, "%%.%df", m_fieldInfo[index].Dec);
    sprintf(buffer, formatString, data);
    SetField(index, buffer);
}

void TDBF::CopyStructToFile(const char * fileName)
{
//  m_errorCode = newDatabase(m_fieldInfo, fileName);
}

void TDBF::CopyToFile(const char * fileName)
{
/*
  TDBF * temp;
  long rec;

  m_errorCode = newDatabase(m_fieldInfo, fileName);
  if(m_errorCode != DBF_SUCCESS)
    return;

  temp = new TDBF(fileName, exclOpen | ReadWrite);
  for(rec = 1L; rec <= m_head.RecordNumber; rec ++) {
    ReadRecord(rec);
    temp->WriteRecordBuffer(ReadRecordBuffer());
    temp->appendRecord();
  }
  delete temp;
*/
}

void TDBF::Zap()
{
    if((m_openMode & ExclOpen) == 0 || (m_openMode & ReadWrite) == 0)
    {
        m_errorCode = DBF_OPEN_FILE_ERROR;
        return;
    }

    time_t t;
    struct tm * tmlocal;
    t = ::time(&t);
    tmlocal = ::localtime(&t);

    m_head.Id = 0x03;
    m_head.Year = (unsigned char)((tmlocal->tm_year  + 1900) % 100);
    m_head.Month = (unsigned char)(tmlocal->tm_mon + 1);
    m_head.Day = (unsigned char)(tmlocal->tm_mday);

    m_head.RecordNumber = 0L;

    ::chsize(m_fp, m_head.RecordOffset);
    ::lseek(m_fp, 0L, SEEK_SET);
    ::write(m_fp, (void *)&m_head, sizeof(m_head));
}

void TDBF::New(const char * fileName, TDBFField * fieldInfo, unsigned int fieldNumber)
{
    int fp_temp;
    TDBFFieldStruct * tempField;

    m_errorCode = DBF_SUCCESS;

    if((fp_temp = open(fileName, O_CREAT | O_TRUNC | O_BINARY | O_RDWR, S_IREAD | S_IWRITE)) == -1)
    {
        m_errorCode = DBF_OPEN_FILE_ERROR;
        return;
    }

    int minSize = HEAD_LEN + fieldNumber * FIELD_LEN + 1;
    char * h = new char[minSize];

    memset((void *)h, 0, minSize);
    TDBFHead * tempHead = (TDBFHead *) h;

    time_t t;
    struct tm * tmlocal;
    t = ::time(&t);
    tmlocal = ::localtime(&t);

    tempHead->Id = 0x03;
    tempHead->Year = (unsigned char)((tmlocal->tm_year  + 1900) % 100);
    tempHead->Month = (unsigned char)(tmlocal->tm_mon + 1);
    tempHead->Day = (unsigned char)(tmlocal->tm_mday);
    
    tempHead->RecordNumber = 0L;
    tempHead->RecordOffset = (unsigned short)minSize;
    tempHead->RecordWidth = 1;

    for(unsigned int i = 0; i < fieldNumber; i ++)  {
      tempField = (TDBFFieldStruct *) (h + HEAD_LEN + i * FIELD_LEN);
      strncpy(tempField->Name, fieldInfo[i].Name, sizeof(tempField->Name));
      tempField->Type = fieldInfo[i].Type;
      tempField->Width = (unsigned char)(fieldInfo[i].Width);
      tempField->Dec = (unsigned char)(fieldInfo[i].Dec);
      tempField->Offset += tempHead->RecordWidth;
      tempHead->RecordWidth += (unsigned short)(fieldInfo[i].Width);
    }

    h[minSize - 1] = '\x0D';

    if(::write(fp_temp, (void *) h, minSize) != minSize)
        m_errorCode = DBF_WRITE_FILE_ERROR;

    close(fp_temp);
    delete h;

    if(m_errorCode == DBF_SUCCESS)
        Open(fileName, ExclOpen | ReadWrite);
}

void TDBF::ClearRecordBuffer()
{
    memset(m_recordBuffer, ' ', m_head.RecordWidth);
}

void TDBF::SetRecordBuffer(const char * buffer)
{
    memcpy(m_recordBuffer, buffer, min(m_head.RecordWidth, (unsigned short)strlen(buffer)));
}

void TDBF::ClearError()
{
    m_errorCode = DBF_SUCCESS;
}

const TDBFField * TDBF::GetFieldInfo(unsigned int index)
{
    if(index >= m_fieldNumber)
        return (const TDBFField * )NULL;
    else
        return &m_fieldInfo[index];
}

const TDBFField * TDBF::GetFieldInfo(const char * name)
{
    unsigned int index;

    for(index = 0; index < m_fieldNumber; index ++)
    {
        if(stricmp(name, m_fieldInfo[index].Name) == 0)
            break;
    }

    return GetFieldInfo(index);
}