////////////////////////////////////////////////////////////////////////
// class TDBF for Dbase or Foxpor Format Files For C++ Builder 4.0
// Written by Xiecg
// Modified 1999/06/02
////////////////////////////////////////////////////////////////////////

#if !defined(__DATABASE_H)
#define __DATABASE_H

const int FIELD_NAME_WIDTH  = 11;

enum errorType
{
    DBF_SUCCESS             =  0,

    DBF_OPEN_FILE_ERROR     = -1,
    DBF_READ_FILE_ERROR     = -2,
    DBF_WRITE_FILE_ERROR    = -3,
    DBF_APPEND_FILE_ERROR   = -5,

    DBF_LOCK_HEAD_ERROR     = -10,
    DBF_LOCK_RECORD_ERROR   = -11,
    DBF_LOCK_FILE_ERROR     = -12,

    DBF_UNLOCK_HEAD_ERROR   = -15,
    DBF_UNLOCK_RECORD_ERROR = -16,
    DBF_UNLOCK_FILE_ERROR   = -17,

    DBF_FIELD_INDEX_ERROR   = -18,
    DBF_FIELD_NAME_ERROR    = -19,

    DBF_RECORD_NUMBER_ERROR = -20,

    DBF_NOT_XBASE_FILE      = -21
};

struct TDBFHead
{
    unsigned char Id;
    unsigned char Year, Month, Day;
    long RecordNumber;
    unsigned short RecordOffset;
    unsigned short RecordWidth;
};

struct TDBFFieldStruct
{
  char Name[FIELD_NAME_WIDTH];
  unsigned char Type;
  unsigned short Offset;
  char Non[2];
  unsigned char Width;
  unsigned char Dec;
  char Tail[14];
};

class TDBFField
{
public:
    TDBFField();
    TDBFField(const char * aName,
              unsigned char aType = 'C',
              unsigned int aWidth = 10,
              unsigned int aDec = 0
             );
    void SetField(const char * aName,
                  unsigned char aType = 'C',
                  unsigned int aWidth = 10,
                  unsigned int aDec = 0
                 );

    char Name[FIELD_NAME_WIDTH];
    char Type;
    unsigned int Offset;
    unsigned int Width;
    unsigned int Dec;
};

class TDBF
{
public:

  TDBF();
  ~TDBF();

  enum DatabaseOpenType
  {
    ExclOpen          = 0x0001,
    ShareOpen         = 0x0002,

    ReadOnly          = 0x0004,
    ReadWrite         = 0x0008,

    AutoReadLock      = 0x0010,
    AutoWriteLock     = 0x0020,
    AutoLock          = 0x0030,

    XbaseLock         = 0x0040,
    ClipperLock       = 0x0080
  };

  enum IndexType
  {
      XbaseIndex = 0x0000,
      ClipperIndex = 0x0001
  };

  enum LockType
  {
      ltNoLock     = 0, // 沒有鎖
      ltRecordLock = 1, // 記錄鎖
      ltFileLock   = 2  // 文件鎖
  };

  void OpenIndex(const char * indexName, int mode = TDBF::XbaseIndex);

  void SetLockTime(unsigned time);

public:

  virtual void Open(const char * filename, int mode = TDBF::ReadOnly | TDBF::ShareOpen);
  virtual void New(const char * filename, TDBFField *, unsigned int);
  virtual void Close();
  virtual void Zap();
  virtual void CopyStructToFile(const char * fileName);
  virtual void CopyToFile(const char * fileName);

  void ReadHead();
  void WriteHead();
  void LockHead();
  void UnlockHead();
  void LockRecord(long rec);
  void UnlockRecord(long rec);
  void LockFile();
  void UnlockFile();

  virtual void ReadRecord(long rec);
  virtual void WriteRecord(long rec);
  virtual void AppendRecord();
  virtual void DeleteRecord(long rec);
  virtual void UndeleteRecord(long rec);

// 第三個參數表示目標串的長度，包括串結束符
  void GetField(unsigned int, char *, unsigned int);
  void GetField(const char *, char *, unsigned int);
  void GetField(const char *, char &);
  void GetField(const char *, signed short &);
  void GetField(const char *, unsigned short &);
  void GetField(const char *, signed int &);
  void GetField(const char *, unsigned int &);
  void GetField(const char *, signed long &);
  void GetField(const char *, unsigned long &);
  void GetField(const char *, double &);

  void SetField(unsigned int, const char *);
  void SetField(const char *, const char *);
  void SetField(const char *, char);
  void SetField(const char *, signed short);
  void SetField(const char *, unsigned short);
  void SetField(const char *, signed int);
  void SetField(const char *, unsigned int);
  void SetField(const char *, signed long);
  void SetField(const char *, unsigned long);
  void SetField(const char *, double);

  int GetErrorCode();
  long GetRecordNumber();
  unsigned int GetRecordWidth();
  unsigned int GetFieldNumber();
  const TDBFField * GetFieldInfo(unsigned int);
  const TDBFField * GetFieldInfo(const char *);
  const char * GetDatabaseName();
  int IsDelete();

  void ClearRecordBuffer();
  const char * GetRecordBuffer();
  void SetRecordBuffer(const char *);

  void ClearError();

  int operator !();
  operator void *();

protected:

  long RecordOffset(long rec);

  int m_fp;
  TDBFHead m_head;
  char * m_databaseName;
  int m_openMode;
  int m_lockWaitTime;
  int m_errorCode;

  char * m_recordBuffer;
  unsigned int m_fieldNumber;
  TDBFField * m_fieldInfo;

private:

    LockType m_lockType;
};

inline long TDBF::GetRecordNumber()
{
  return m_head.RecordNumber;
}

inline unsigned TDBF::GetRecordWidth()
{
  return m_head.RecordWidth;
}

inline unsigned TDBF::GetFieldNumber()
{
  return m_fieldNumber;
}

inline const char * TDBF::GetDatabaseName()
{
  return m_databaseName;
}

inline const char * TDBF::GetRecordBuffer()
{
  return m_recordBuffer;
}

inline long TDBF::RecordOffset(long rec)
{
  return (long) m_head.RecordOffset + (rec - 1L) * (long) m_head.RecordWidth;
}

inline int TDBF::GetErrorCode()
{
  return !(m_errorCode == DBF_SUCCESS);
}

inline int TDBF::operator !()
{
  return GetErrorCode();
}

inline TDBF::operator void *()
{
  return GetErrorCode() ? 0 : this;
}

inline void TDBF::SetLockTime(unsigned time)
{
  m_lockWaitTime = time;
}

#endif