fx_basic.h

浏览该文件的文档.

//<<<+++OPENSOURCE
//<<<+++OPENSOURCE_LICENSE
//<<<+++OPENSOURCE_BEGIN LIC==FOXIT||LIC==GOOGLE

//<<<+++OPENSOURCE_MUST_BEGIN
#ifndef _FX_BASIC_H_
#define _FX_BASIC_H_

/* System dependant definitions */
#ifndef _FX_SYSTEM_H_
  #include "fx_system.h"
#endif
#ifndef _FX_MEMORY_H_
  #include "fx_memory.h"
#endif
#ifndef _FX_STRING_H_
  #include "fx_string.h"
#endif
#ifndef _FX_STREAM_H_
  #include "fx_stream.h"
#endif
//<<<+++OPENSOURCE_MUST_END

#ifndef _FX_EXCEPTION_H_
  #include "fx_exception.h"
#endif

//*****************************************************************************
//* 缓冲区
//*****************************************************************************
class CFX_BinaryBuf : public CFX_Object
{
 public:
  CFX_BinaryBuf(IFX_Allocator* pAllocator = NULL);

  CFX_BinaryBuf(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
  //<<<+++OPENSOURCE_END

  ~CFX_BinaryBuf();

  void          Clear();

  FX_BOOL          EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step = 0);

  FX_BOOL          AppendBlock(const void* pBuf, FX_STRSIZE size);

  FX_BOOL          AppendFill(FX_BYTE byte, FX_STRSIZE count);

  void          AppendString(FX_BSTR str) { AppendBlock(str.GetPtr(), str.GetLength()); }

  inline FX_BOOL        AppendByte(FX_BYTE byte)
  {
    if (m_AllocSize <= m_DataSize)
    {
      if (!ExpandBuf(100))
        return false;
    }
    m_pBuffer[m_DataSize++] = byte;
    return true;
  }

  FX_BOOL          InsertBlock(FX_STRSIZE pos, const void* pBuf, FX_STRSIZE size);

  void          AttachData(void* pBuf, FX_STRSIZE size);

  FX_BOOL          CopyData(const void* pBuf, FX_STRSIZE size);
  void          TakeOver(CFX_BinaryBuf& other);

  void          Delete(int start_index, int count);

  FX_LPBYTE        GetBuffer() const { return m_pBuffer; }

  FX_STRSIZE        GetSize() const { return m_DataSize; }

  CFX_ByteStringC      GetByteString() const;

  void          GetByteStringL(CFX_ByteStringL &str) const;

  void          DetachBuffer();

  IFX_Allocator*      m_pAllocator;

 protected:
  /* 分配步长。 */
  FX_STRSIZE        m_AllocStep;
  /* 缓冲区指针。 */
  FX_LPBYTE        m_pBuffer;
  /* 缓冲区的字节长度。 */
  FX_STRSIZE        m_DataSize;
  /* 缓冲区分配的字节大小。 */
  FX_STRSIZE        m_AllocSize;
  /*
   * 增加分配的缓冲区，而不是数据大小。
   *
   * @param[in] size    要增加的字节大小。
   */
  FX_BOOL          ExpandBuf(FX_STRSIZE size);
};

class CFX_ByteTextBuf : public CFX_BinaryBuf
{
 public:
  CFX_ByteTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}

  void          operator = (FX_BSTR str);

  void          AppendChar(int ch) { AppendByte((FX_BYTE)ch); }

  CFX_ByteTextBuf&    operator << (int i);

  CFX_ByteTextBuf&    operator << (FX_DWORD i);

  CFX_ByteTextBuf& operator<<(FX_INT64 i);

  CFX_ByteTextBuf&    operator << (double f);

  CFX_ByteTextBuf&    operator << (FX_BSTR lpsz);

  CFX_ByteTextBuf&    operator << (const CFX_ByteTextBuf& buf);

  FX_STRSIZE        GetLength() const { return m_DataSize; }
};

class CFX_WideTextBuf : public CFX_BinaryBuf
{
 public:
  CFX_WideTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}

  void          operator = (FX_LPCWSTR lpsz);

  void          operator = (FX_WSTR str);

  FX_BOOL          AppendChar(FX_WCHAR wch);

  CFX_WideTextBuf&    operator << (int i);

  CFX_WideTextBuf&    operator << (double f);

  CFX_WideTextBuf&    operator << (FX_LPCWSTR lpsz);

  CFX_WideTextBuf&    operator << (FX_WSTR str);

  CFX_WideTextBuf&    operator << (const CFX_WideString &str);

  CFX_WideTextBuf&    operator << (const CFX_WideTextBuf& buf);

  FX_STRSIZE        GetLength() const { return m_DataSize/sizeof(FX_WCHAR); }

  FX_LPWSTR        GetBuffer() const { return (FX_LPWSTR)m_pBuffer; }

  void          Delete(int start_index, int count)
  {
    CFX_BinaryBuf::Delete(start_index * sizeof(FX_WCHAR), count * sizeof(FX_WCHAR));
  }

  CFX_WideStringC      GetWideString() const;

  void          GetWideStringL(CFX_WideStringL& wideText) const;

};

//*****************************************************************************
//* 存档
//*****************************************************************************
class CFX_ArchiveSaver : public CFX_Object
{
 public:
  CFX_ArchiveSaver(IFX_Allocator* pAllocator = NULL) : m_SavingBuf(pAllocator), m_pStream(NULL) {}

  CFX_ArchiveSaver&    operator << (FX_BYTE i);

  CFX_ArchiveSaver&    operator << (FX_BOOL i);

  CFX_ArchiveSaver&    operator << (int i);

  CFX_ArchiveSaver&    operator << (FX_DWORD i);

  CFX_ArchiveSaver&    operator << (FX_INT64 i);

  CFX_ArchiveSaver&    operator << (FX_FLOAT i);

  CFX_ArchiveSaver&    operator << (FX_BSTR bstr);

  CFX_ArchiveSaver&    operator << (FX_LPCSTR bstr);

   CFX_ArchiveSaver&    operator << (const CFX_ByteString& bstr);

  CFX_ArchiveSaver&    operator << (FX_LPCWSTR bstr);

  CFX_ArchiveSaver&    operator << (const CFX_WideString& wstr);

  void          Write(const void* pData, FX_STRSIZE dwSize);

  FX_INTPTR        GetLength() const { return m_SavingBuf.GetSize(); }

  FX_LPCBYTE        GetBuffer() const { return m_SavingBuf.GetBuffer(); }

  void          SetStream(IFX_FileStream* pStream) { m_pStream = pStream; }

 protected:
  /* 保存数据。 */
  CFX_BinaryBuf      m_SavingBuf;
  /* 流数据。 */
  IFX_FileStream*      m_pStream;
};

class CFX_ArchiveLoader : public CFX_Object
{
 public:
  CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize);

  CFX_ArchiveLoader&    operator >> (FX_BYTE& i);

  CFX_ArchiveLoader&    operator >> (FX_BOOL& i);

  CFX_ArchiveLoader&    operator >> (int& i);

  CFX_ArchiveLoader&    operator >> (FX_INT64& i);

  CFX_ArchiveLoader&    operator >> (FX_DWORD& i);

  CFX_ArchiveLoader&    operator >> (FX_FLOAT& i);

  CFX_ArchiveLoader&    operator >> (CFX_ByteString& bstr);

  CFX_ArchiveLoader&    operator >> (CFX_WideString& wstr);

  FX_BOOL          IsEOF();

  FX_BOOL          Read(void* pBuf, FX_DWORD dwSize);

 protected:
  /* 当前加载位置。 */
  FX_DWORD        m_LoadingPos;
  /* 加载缓冲区。 */
  FX_LPCBYTE        m_pLoadingBuf;
  /* 加载缓冲区的字节大小。 */
  FX_DWORD        m_LoadingSize;
};

class IFX_BufferArchive
{
 public:
  IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
  //<<<+++OPENSOURCE_END

  virtual ~IFX_BufferArchive() {}

  virtual void      Clear();

  FX_BOOL          Flush();

  FX_INT32        AppendBlock(const void* pBuf, size_t size);

  FX_INT32        AppendByte(FX_BYTE byte);

  FX_INT32        AppendDWord(FX_DWORD i);

  FX_INT32        AppendInt64(FX_INT64 i);

  FX_INT32        AppendString(FX_BSTR lpsz);

 protected:
  /*
   * @brief 执行工作，当文本缓冲区满时将被调用。
   *
   * @param[in] pBuf  指向二进制缓冲区块的指针。
   * @param[in] size  缓冲区块的字节大小。
   *
   * @return <b>true</b> 表示成功，<b>false</b> 表示失败。
   */
  virtual  FX_BOOL      DoWork(const void* pBuf, size_t size) = 0;

  /* 特殊分配器指针。NULL表示使用默认分配器。 */
  IFX_Allocator*      m_pAllocator;

  /* 缓冲区大小*/
  FX_STRSIZE        m_BufSize;
  /* 缓冲区。 */
  FX_LPBYTE        m_pBuffer;
  /* 当前缓冲区长度。 */
  FX_STRSIZE        m_Length;
};

class CFX_FileBufferArchive : public IFX_BufferArchive, public CFX_Object
{
 public:
  CFX_FileBufferArchive(FX_STRSIZE size = 32768, IFX_Allocator* pAllocator = NULL);

  ~CFX_FileBufferArchive();

  virtual void      Clear();

  FX_BOOL          Flush();

  FX_BOOL          AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = false);

  FX_BOOL          AttachFile(FX_LPCWSTR filename);

  FX_BOOL          AttachFile(FX_LPCSTR filename);

 private:
  /*
   * 执行工作，当文本缓冲区满时将被调用。
   *
   * @param[in] pBuf  指向二进制缓冲区块的指针。
   * @param[in] size  缓冲区块的字节大小。
   *
   * @return <b>true</b> 表示成功，<b>false</b> 表示失败。
   */
  virtual FX_BOOL      DoWork(const void* pBuf, size_t size);

  /* 文件流。 */
  IFX_StreamWrite      *m_pFile;
  /* 是否接管文件。 */
  FX_BOOL          m_bTakeover;
};

struct CFX_CharMap
{
  static CFX_CharMap*    GetDefaultMapper(FX_INT32 codepage = 0);

  CFX_WideString  (*m_GetWideString)(CFX_CharMap* pMap, const CFX_ByteString& bstr);

  CFX_ByteString  (*m_GetByteString)(CFX_CharMap* pMap, const CFX_WideString& wstr);

  FX_INT32    (*m_GetCodePage)();
};

//*****************************************************************************
//* UTF-8
//*****************************************************************************
class CFX_UTF8Decoder
{
 public:
  CFX_UTF8Decoder(IFX_Allocator* pAllocator = NULL) : m_PendingBytes(0),m_PendingChar(0),m_Buffer(pAllocator) { }

  void      Clear();

  void      Input(FX_BYTE byte);

  void      AppendChar(FX_DWORD ch);

  void      ClearStatus() { m_PendingBytes = 0; }

  CFX_WideStringC  GetResult() const { return m_Buffer.GetWideString(); }

  void      GetResult(CFX_WideStringL &result) const {m_Buffer.GetWideStringL(result);}

 protected:
  /* 解码状态。 */
  int        m_PendingBytes;
  /* 缓存值。 */
  FX_DWORD    m_PendingChar;
  /* 输出宽字符文本缓冲区。 */
  CFX_WideTextBuf  m_Buffer;
};

class CFX_UTF8Encoder
{
 public:
  CFX_UTF8Encoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) { m_UTF16First = 0; }

  void      Input(FX_WCHAR unicode);

  void      AppendStr(FX_BSTR str) { m_UTF16First = 0; m_Buffer << str; }

  CFX_ByteStringC  GetResult() const { return m_Buffer.GetByteString(); }

  void      GetResult(CFX_ByteStringL &result) const {m_Buffer.GetByteStringL(result);}

 protected:
  /* 输出字节文本缓冲区。 */
  CFX_ByteTextBuf  m_Buffer;
  /* 编码状态。 */
  FX_DWORD    m_UTF16First;
};

CFX_ByteString FX_UrlEncode(const CFX_WideString& wsUrl);

CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);

CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);

CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);

//*****************************************************************************
//* 数组
//*****************************************************************************
class CFX_BasicArray : public CFX_Object
{
 public:
  IFX_Allocator*  m_pAllocator;

 protected:
  /*
   * @brief 使用指定的单元大小构造。
   *
   * @param[in] unit_size   指定的单元大小。必须大于0且小于2^28。
   * @param[in] pAllocator  此类中使用的分配器。<b>NULL</b> 表示使用默认分配器。
   *                        默认值：<b>NULL</b>。
   */
  CFX_BasicArray(int unit_size, IFX_Allocator* pAllocator = NULL);
  //<<<+++OPENSOURCE_END

  /*
   * @brief 析构函数。
   */
  ~CFX_BasicArray();

  /*
   * @brief 拷贝构造函数。
   *
   * @param[in] other      另一个CFX_BasicArray对象。
   * @param[in] pAllocator 分配器。
   */
  CFX_BasicArray(const CFX_BasicArray& other, IFX_Allocator* pAllocator = NULL);

  /*
   * @brief 赋值运算符。
   *
   * @param[in] other  另一个CFX_BasicArray对象。
   *
   * @return 当前对象本身的引用。
   */
  CFX_BasicArray& operator=(const CFX_BasicArray& other);

  /*
   * @brief 更改分配的大小和增长量。
   *
   * @param[in] nNewSize  期望的新大小（以元素为单位）。
   * @param[in] nGrowBy   期望的增长量（以元素为单位），nGrowBy可以为-1表示增长量不变。
   *
   * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如参数或内存错误）。
   */
  FX_BOOL      SetSize(int nNewSize, int nGrowBy);

  /*
   * @brief 追加基本数组。
   *
   * @param[in] src  输入的基本数组。它必须具有与当前数组相同的单元大小。
   *
   * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如内存错误）。
   */
  FX_BOOL      Append(const CFX_BasicArray& src);

  /*
   * @brief 从基本数组复制。
   *
   * @param[in] src  输入的基本数组。它必须具有与当前数组相同的单元大小。
   *
   * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如内存错误）。
   */
  FX_BOOL      Copy(const CFX_BasicArray& src);

  /*
   * @brief 在指定位置插入空间。
   *
   * @param[in] nIndex  指定基本数组中元素的基于零的索引。
   * @param[in] nCount  指定要插入的元素数量。
   *
   * @return 指向插入空间的字节指针。<b>NULL</b> 表示错误。
   */
  FX_LPBYTE    InsertSpaceAt(int nIndex, int nCount);

  /*
   * @brief 移除若干元素。
   *
   * @param[in] nIndex  指定基本数组中要移除的起始元素的基于零的索引。
   * @param[in] nCount  指定要移除的元素数量。
   *
   * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如参数错误）。
   */
  FX_BOOL      RemoveAt(int nIndex, int nCount);

  /*
   * @brief 在指定位置插入基本数组。
   *
   * @param[in] nStartIndex  指定要插入位置的起始元素的基于零的索引。
   * @param[in] pNewArray    输入的基本数组。它必须具有与当前数组相同的单元大小。
   *
   * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如参数或内存错误）。
   */
  FX_BOOL      InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);

  /*
   * @brief 获取指向元素数据的无类型指针。
   *
   * @param[in] index  指定元素的基于零的索引。
   *
   * @return 指向元素数据的无类型指针。<b>NULL</b> 表示错误。
   */
  const void*    GetDataPtr(int index) const;

 protected:
  /* 实际的数据数组 */
  FX_LPBYTE    m_pData;
  /*  元素数量（upperBound - 1） */
  int        m_nSize;
  /* 最大分配数量 */
  int        m_nMaxSize;
  /* 增长量。 */
  int        m_nGrowBy;
  /* 一个单元的字节数。 */
  int        m_nUnitSize;
};

template<class TYPE>
class CFX_ArrayTemplate : public CFX_BasicArray
{
 public:
  enum ErrorType{
    invalidArraySize,

    memoryAllocationError,

    indexOutOfRange
  };

  CFX_ArrayTemplate(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(TYPE), pAllocator) {}
  //<<<+++OPENSOURCE_END

  CFX_ArrayTemplate(const CFX_ArrayTemplate& other, IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(other, pAllocator) {}

  void FX_Error(ErrorType error,FX_INT32 badIndex=0) const
  {
    const char *errorMsg[] = {
      "Invalid array size",
      "Memory allocation error",
      "Invalid index:"
    };

    fprintf(stderr, "%s\n", errorMsg[error]);
    if(error == indexOutOfRange)
      fprintf(stderr, "%i\n", badIndex);
    abort();
  }

    int GetSize() const { return m_nSize; }

    int GetUpperBound() const { return m_nSize-1; }

    FX_BOOL SetSize(int nNewSize, int nGrowBy = -1)
  {
    return CFX_BasicArray::SetSize(nNewSize, nGrowBy);
  }

     void RemoveAll() { SetSize(0, -1); }

     const TYPE  GetAt(int nIndex) const {
        if (nIndex < 0 || nIndex >= m_nSize)
        //return (const TYPE&)(*(volatile const TYPE*)NULL);
        //为了避免崩溃，我们输入索引。（原因不明）
          FX_Error(indexOutOfRange, nIndex);
        return ((const TYPE*)m_pData)[nIndex];
     }

  FX_BOOL    SetAt(int nIndex, TYPE newElement) {
    if (nIndex < 0 || nIndex >= m_nSize) return false;
    ((TYPE*)m_pData)[nIndex] = newElement;
    return true;
  }

  TYPE&    ElementAt(int nIndex)
  {
    if (nIndex < 0 || nIndex >= m_nSize)
      //return *(TYPE*)NULL;
      //为了避免崩溃，我们输入索引。（原因不明）
      FX_Error(indexOutOfRange, nIndex);
    return ((TYPE*)m_pData)[nIndex];
  }

  const TYPE*  GetData() const { return (const TYPE*)m_pData; }

  TYPE*    GetData() { return (TYPE*)m_pData; }

  FX_BOOL    SetAtGrow(int nIndex, TYPE newElement)
  {
    if (nIndex < 0) return false;
    if (nIndex >= m_nSize)
      if (!SetSize(nIndex+1, -1)) return false;
    ((TYPE*)m_pData)[nIndex] = newElement;
    return true;
  }

  FX_BOOL    Add(TYPE newElement)
  {
    if (m_nSize < m_nMaxSize)
      m_nSize ++;
    else
      if (!SetSize(m_nSize+1, -1)) return false;
    ((TYPE*)m_pData)[m_nSize-1] = newElement;
    return true;
  }
    
  FX_BOOL    Append(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Append(src); }

  FX_BOOL    Copy(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Copy(src); }

  TYPE*    GetDataPtr(int index) { return (TYPE*)CFX_BasicArray::GetDataPtr(index); }

  TYPE*    AddSpace() { return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1); }

  TYPE*    InsertSpaceAt(int nIndex, int nCount) { return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount); }
    
  CFX_ArrayTemplate& operator=(const CFX_ArrayTemplate& src) { CFX_BasicArray::operator=(src); return *this; }

  const TYPE  operator[](int nIndex) const
  {
    if (nIndex < 0 || nIndex >= m_nSize)
      //合并自google trunk r2049，作者：Johnson，日期：2012.12.07
      *(volatile char*)0 = '\0';
    return ((const TYPE*)m_pData)[nIndex];
  }

  TYPE&    operator[](int nIndex)
  {
    if (nIndex < 0 || nIndex >= m_nSize)
      //合并自google trunk r2049，作者：Johnson，日期：2012.12.07
      *(volatile char*)0 = '\0';
    return ((TYPE*)m_pData)[nIndex];
  }

  FX_BOOL    InsertAt(int nIndex, TYPE newElement, int nCount = 1)
  {
    if (!InsertSpaceAt(nIndex, nCount)) return false;
    while (nCount--)
      ((TYPE*)m_pData)[nIndex++] = newElement;
    return true;
  }

  FX_BOOL    RemoveAt(int nIndex, int nCount = 1) { return CFX_BasicArray::RemoveAt(nIndex, nCount); }
  
  FX_BOOL    InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) { return CFX_BasicArray::InsertAt(nStartIndex, pNewArray); }
  int      Find(const TYPE& data, int iStart = 0) const
  {
    if (iStart < 0) return -1;
    for (; iStart < (int)m_nSize; iStart ++)
      if (((TYPE*)m_pData)[iStart] == data) return iStart;
    return -1;
  }
};

typedef CFX_ArrayTemplate<FX_BYTE>    CFX_ByteArray;
typedef CFX_ArrayTemplate<FX_WORD>    CFX_WordArray;
typedef CFX_ArrayTemplate<FX_DWORD>    CFX_DWordArray;
typedef CFX_ArrayTemplate<void*>    CFX_PtrArray;
typedef CFX_ArrayTemplate<FX_FILESIZE>  CFX_FileSizeArray;
typedef CFX_ArrayTemplate<FX_FLOAT>    CFX_FloatArray;
typedef CFX_ArrayTemplate<FX_INT32>    CFX_Int32Array;
typedef CFX_ArrayTemplate<FX_WCHAR>    CFX_WCHARArray;

template <class ObjectClass>
class CFX_ObjectArray : public CFX_BasicArray
{
 public:
  CFX_ObjectArray(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(ObjectClass), pAllocator) {}

  ~CFX_ObjectArray() { RemoveAll(); }

  CFX_ObjectArray(const CFX_ObjectArray& other, IFX_Allocator* pAllocator = NULL)
    : CFX_BasicArray(sizeof(ObjectClass), pAllocator)
  {
    Copy(other);
  }

  CFX_ObjectArray& operator=(const CFX_ObjectArray& other)
  {
    Copy(other);
    return *this;
  }

  void      Add(const ObjectClass& data)
  {
      #ifndef _FX_NOPLACEMENTNEW_
        new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
      #else
        ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
      #endif

  }

  ObjectClass&  Add()
  {
      #ifndef _FX_NOPLACEMENTNEW_
        return *(ObjectClass*) new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
      #else
        return *(ObjectClass*) ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
      #endif
  }

  void*      AddSpace()
  {
    return InsertSpaceAt(m_nSize, 1);
  }

  FX_INT32    Append(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
  {
    if (nCount == 0) return 0;
    FX_INT32 nSize = src.GetSize();
    if (!nSize) return 0;
    FXSYS_assert(nStart > -1 && nStart < nSize);
    if (nCount < 0) nCount = nSize;
    if (nStart + nCount > nSize) nCount = nSize - nStart;
    if (nCount < 1) return 0;
    nSize = m_nSize;
    InsertSpaceAt(m_nSize, nCount);
    ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);
    nSize = nStart + nCount;
    for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
    {
      #ifndef _FX_NOPLACEMENTNEW_
        new ((void*)pStartObj) ObjectClass(src[i]);
      #else
        ::new ((void*)pStartObj) ObjectClass(src[i]);
      #endif

    }
    return nCount;
  }

  FX_INT32    Copy(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
  {
    if (this == &src) return 0;
    RemoveAll();
    if (nCount == 0) return 0;
    FX_INT32 nSize = src.GetSize();
    if (!nSize) return 0;
    FXSYS_assert(nStart > -1 && nStart < nSize);
    if (nCount < 0) nCount = nSize;
    if (nStart + nCount > nSize) nCount = nSize - nStart;
    if (nCount < 1) return 0;
    nSize = nStart + nCount;
    SetSize(nCount, -1);
    ObjectClass* pStartObj = (ObjectClass*)m_pData;
    for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
    {
      #ifndef _FX_NOPLACEMENTNEW_
        new ((void*)pStartObj) ObjectClass(src[i]);
      #else
        ::new ((void*)pStartObj) ObjectClass(src[i]);
      #endif

    }
    return nCount;
  }

  int        GetSize() const {return m_nSize;}

  ObjectClass&  operator[] (int index) const
  {
    FXSYS_assert(index < m_nSize);
    return *(ObjectClass*)CFX_BasicArray::GetDataPtr(index);
  }

  ObjectClass*  GetDataPtr(int index) const {return (ObjectClass*)CFX_BasicArray::GetDataPtr(index);}

  void      RemoveAt(int index)
  {
    FXSYS_assert(index < m_nSize);
    ((ObjectClass*)GetDataPtr(index))->~ObjectClass();
    CFX_BasicArray::RemoveAt(index, 1);
  }

  void      RemoveAll()
  {
    for (int i = 0; i < m_nSize; i ++)
      ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
    CFX_BasicArray::SetSize(0, -1);
  }
};

typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;
typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;

template <class TYPE>
class CFX_Stack : CFX_Object
{
 public:
  CFX_Stack() {}

  FX_BOOL      Empty() const
  {
    return m_Container.GetSize() == 0;
  }

  int        Size() const
  {
    return m_Container.GetSize();
  }

  TYPE&      Top()
  {
    return m_Container[Size() - 1];
  }

  void      Pop()
  {
    m_Container.RemoveAt(Size() - 1);
  }

  void      Push(const TYPE& val)
  {
    m_Container.Add(val);
  }

  void  Clear()
  {
    m_Container.RemoveAll();
  }
 private:
  CFX_ArrayTemplate<TYPE>    m_Container;
};

template <class TYPE>
class CFX_ObjectStack : CFX_Object
{
 public:
  CFX_ObjectStack() {}

  FX_BOOL      Empty() const
  {
    return m_Container.GetSize() == 0;
  }

  int        Size() const
  {
    return m_Container.GetSize();
  }

  TYPE&      Top()
  {
    return m_Container[Size() - 1];
  }

  void      Pop()
  {
    m_Container.RemoveAt(Size() - 1);
  }

  void      Push(const TYPE& val)
  {
    m_Container.Add(val);
  }

 private:
  CFX_ObjectArray<TYPE>    m_Container;
};

template <>
class CFX_Stack<CFX_ByteString> : CFX_Object
{
 public:
  CFX_Stack() {}

  FX_BOOL      Empty() const
  {
    return m_Container.GetSize() == 0;
  }

  int        Size() const
  {
    return m_Container.GetSize();
  }

  CFX_ByteString&      Top()
  {
    return m_Container[Size() - 1];
  }

  void      Pop()
  {
    m_Container.RemoveAt(Size() - 1);
  }

  void Push(const CFX_ByteString& val)
  {
    m_Container.Add(val);
  }

 private:
  CFX_ObjectArray<CFX_ByteString>    m_Container;
};

class CFX_BaseSegmentedArray : public CFX_Object
{
 public:
  CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8, IFX_Allocator* pAllocator = NULL);

  ~CFX_BaseSegmentedArray();

  void  SetUnitSize(int unit_size, int segment_units, int index_size = 8);

  void*  Add();

  void*  GetAt(int index) const;

  void  RemoveAll();

  void  Delete(int index, int count = 1);

  int    GetSize() const { return m_DataSize; }

  int    GetSegmentSize() const { return m_SegmentSize; }

  int    GetUnitSize() const { return m_UnitSize; }

  void*  Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;

  IFX_Allocator*  m_pAllocator;
 private:
  /* 单元大小 */
  int        m_UnitSize;
  /* 每段中的单元数。 */
  short      m_SegmentSize;
  /* 数组中的索引级别数。 */
  FX_BYTE      m_IndexSize;
  /* 索引树中的当前级别。 */
  FX_BYTE      m_IndexDepth;
  /* 数组中的当前单元数。 */
  int        m_DataSize;
  /* 指向段或索引的索引，如果只有一个段则直接指向该段。 */
  void*      m_pIndex;

  void**  GetIndex(int seg_index) const;
  void*  IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
  void*  IterateSegment(FX_LPCBYTE pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
};

template <class ElementType>
class CFX_SegmentedArray : public CFX_BaseSegmentedArray
{
 public:
  CFX_SegmentedArray(int segment_units, int index_size = 8, IFX_Allocator* pAllocator = NULL)
    : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size, pAllocator)
  {}
  //<<<+++OPENSOURCE_END

  void  Add(ElementType data)
  {
    *(ElementType*)CFX_BaseSegmentedArray::Add() = data;
  }

  ElementType& operator [] (int index)
  {
    return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);
  }
};

template <class DataType, int FixedSize>
class CFX_FixedBufGrow : public CFX_Object
{
 public:
  CFX_FixedBufGrow(IFX_Allocator* pAllocator = NULL)
    : m_pAllocator(pAllocator)
    , m_pData(NULL)
  {
    FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
  }

  CFX_FixedBufGrow(int data_size, IFX_Allocator* pAllocator = NULL)
    : m_pAllocator(pAllocator)
    , m_pData(NULL)
  {
    if (data_size > FixedSize)
      m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
    else
      FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
  }
  //<<<+++OPENSOURCE_END

  void SetDataSize(int data_size) {
    if (m_pData)
      FX_Allocator_Free(m_pAllocator, m_pData);
    m_pData = NULL;
    if (data_size > FixedSize)
      m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
    else {
      FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
    }
  }

  ~CFX_FixedBufGrow() { if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData); }

  operator DataType*() { return m_pData ? m_pData : m_Data; }

 private:
  IFX_Allocator*  m_pAllocator;

  DataType    m_Data[FixedSize];
  DataType*    m_pData;
};

template <class DataType>
class CFX_TempBuf
{
 public:
  CFX_TempBuf(int size, IFX_Allocator* pAllocator = NULL) : m_pAllocator(pAllocator)
  {
    m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, size);
  }

  ~CFX_TempBuf()
   {
      if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData);
   }
  //<<<+++OPENSOURCE_END

  DataType&  operator[](int i) { FXSYS_assert(m_pData != NULL); return m_pData[i]; }
  operator DataType*() const { return m_pData; }

 private:
  IFX_Allocator*  m_pAllocator;

  DataType*    m_pData;
};

//*****************************************************************************
//* 映射
//*****************************************************************************

class CFX_MapPtrToPtr : public CFX_Object
{
 protected:
  struct CAssoc
  {
    CAssoc* pNext;
    void* key;
    void* value;
  };

 public:
  CFX_MapPtrToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
  //<<<+++OPENSOURCE_END

  ~CFX_MapPtrToPtr();

  int GetCount() const { return m_nCount; }

  FX_BOOL IsEmpty() const { return m_nCount == 0; }

  FX_BOOL Lookup(void* key, void*& rValue) const;

  void* GetValueAt(void* key) const;

  void*& operator[](void* key);

  void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }

  FX_BOOL RemoveKey(void* key);

  void RemoveAll();

  FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }

  void GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const;

  FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }

  void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);

 protected:
  /* 特殊分配器指针。NULL表示使用默认分配器。 */
  IFX_Allocator*  m_pAllocator;

  /* 哈希表。 */
  CAssoc** m_pHashTable;
  /* 哈希表的大小。 */
  FX_DWORD m_nHashTableSize;
  /* 映射中键值对的数量。 */
  int m_nCount;
  /* 内部释放的关联列表。 */
  CAssoc* m_pFreeList;
  /* 内部块列表。 */
  struct CFX_Plex* m_pBlocks;
  /* 每个块中关联的大小。 */
  int m_nBlockSize;

  /*
   * 用于用户提供的哈希键的例程。
   *
   * @note 可重写：特殊非虚拟（有关详细信息，请参阅映射实现）。
   *
   * @param[in] key    用于生成哈希键的键。
   * @return 哈希值。
   */
  FX_DWORD HashKey(void* key) const;

  /*
   * 分配新的关联。
   *
   * @return 指向新分配关联的指针。
   */
  CAssoc* NewAssoc();
  /*
   * 释放关联。
   *
   * @param[in] pAssoc  指向关联的指针。
   */
  void FreeAssoc(CAssoc* pAssoc);
  /*
   * @brief 通过键检索关联。
   *
   * @param[in] key    输入键。
   * @param[out] hash  计算的哈希值。
   *
   * @return 当前关联对象。
   */
  CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
  /*
   * @brief 通过位置检索当前关联。
   *
   * @param[in, out] rNextPosition  输入一个位置，并接收下一个关联位置。
   *
   * @return 当前关联对象。
   */
  CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
  /*
   * @brief 将哈希表大小扩展为之前的2倍。
   *
   * @details 最大哈希表大小为10000。
   *
   * @return <b>true</b>表示成功，<b>false</b>表示失败。
   */
  FX_BOOL ExpandHashTable();
 private:
        CFX_MapPtrToPtr(const CFX_MapPtrToPtr &) FX_EQDELETE;
        CFX_MapPtrToPtr &operator=(const CFX_MapPtrToPtr &) FX_EQDELETE;
};

template <class KeyType, class ValueType>
class CFX_MapPtrTemplate : public CFX_MapPtrToPtr
{
 public:
  CFX_MapPtrTemplate(IFX_Allocator* pAllocator = NULL) : CFX_MapPtrToPtr(10, pAllocator) {}

  FX_BOOL  Lookup(KeyType key, ValueType& rValue) const
  {
    FX_LPVOID pValue = NULL;
    if (!CFX_MapPtrToPtr::Lookup((void*)(FX_UINTPTR)key, pValue))
      return false;
    rValue = (ValueType)(FX_UINTPTR)pValue;
    return true;
  }

  ValueType& operator[](KeyType key) { return (ValueType&)CFX_MapPtrToPtr::operator []((void*)(FX_UINTPTR)key); }

  void SetAt(KeyType key, ValueType newValue) { CFX_MapPtrToPtr::SetAt((void*)(FX_UINTPTR)key, (void*)(FX_UINTPTR)newValue); }

  FX_BOOL  RemoveKey(KeyType key) { return CFX_MapPtrToPtr::RemoveKey((void*)(FX_UINTPTR)key); }

  void GetNextAssoc(FX_POSITION& rNextPosition, KeyType& rKey, ValueType& rValue) const
  {
    void* pKey = NULL; void* pValue = NULL;
    CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
    rKey = (KeyType)(FX_UINTPTR)pKey; rValue = (ValueType)(FX_UINTPTR)pValue;
  }
 private:
        CFX_MapPtrTemplate(const CFX_MapPtrTemplate &) FX_EQDELETE;
        CFX_MapPtrTemplate &operator=(const CFX_MapPtrTemplate &) FX_EQDELETE;
};

class CFX_CMapDWordToDWord : public CFX_Object
{
 public:
  CFX_CMapDWordToDWord(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) {}

  FX_BOOL      Lookup(FX_DWORD key, FX_DWORD& value) const;

  void      SetAt(FX_DWORD key, FX_DWORD value);

  void      EstimateSize(FX_DWORD size, FX_DWORD grow_by);

  FX_POSITION    GetStartPosition() const;

  void      GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;

  void      RemoveAll() { m_Buffer.Clear(); }

 protected:
  CFX_BinaryBuf  m_Buffer;
 private:
  CFX_CMapDWordToDWord(const CFX_CMapDWordToDWord &) FX_EQDELETE;
  CFX_CMapDWordToDWord &operator=(const CFX_CMapDWordToDWord &) FX_EQDELETE;
};

class CFX_MapByteStringToPtr : public CFX_Object
{
 protected:
  struct CAssoc
  {
    CAssoc* pNext;

    FX_DWORD nHashValue;
    CFX_ByteString key;
    void* value;
  };

 public:
  CFX_MapByteStringToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);

  int GetCount() const { return m_nCount; }

  FX_BOOL IsEmpty() const { return m_nCount == 0; }

  FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;

  void*& operator[](FX_BSTR key);

  void SetAt(FX_BSTR key, void* newValue) { (*this)[key] = newValue; }

  FX_BOOL RemoveKey(FX_BSTR key);

  void RemoveAll();

  FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }

  void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;

  FX_LPVOID    GetNextValue(FX_POSITION& rNextPosition) const;

  FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }

  void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);

  FX_DWORD HashKey(FX_BSTR key) const;

 protected:
  /* 特殊分配器指针。NULL表示使用默认分配器。 */
  IFX_Allocator*  m_pAllocator;

  /* 哈希表。 */
  CAssoc** m_pHashTable;
  /* 哈希表的大小。 */
  FX_DWORD m_nHashTableSize;
  /* 映射中键值对的数量。 */
  int m_nCount;
  /* 内部释放的关联列表。 */
  CAssoc* m_pFreeList;
  /* 内部块列表。 */
  struct CFX_Plex* m_pBlocks;
  /* 每个块中关联的大小。 */
  int m_nBlockSize;

  /*
   * @brief 分配新的关联。
   *
   * @return 指向新分配关联的指针。
   */
  CAssoc* NewAssoc();
  /*
   * @brief 释放关联。
   *
   * @param[in] pAssoc  指向关联的指针。
   *
   * @return 无。
   */
  void FreeAssoc(CAssoc* pAssoc);
  /*
   * @brief 通过键检索关联。
   *
   * @param[in] key    输入键。
   * @param[out] hash  计算的哈希值。
   *
   * @return 关联对象。
   */
  CAssoc* GetAssocAt(FX_BSTR key, FX_DWORD& hash) const;
  /*
   * @brief 通过位置检索当前关联。
   *
   * @param[in] rNextPosition  当前位置。
   *
   * @return 关联对象。
   */
  CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
  /*
   * @brief 将哈希表大小扩展为之前的2倍。
   *
   * @details 最大哈希表大小为10000。
   *
   * @return <b>true</b>表示成功，<b>false</b>表示失败。
   */
  FX_BOOL ExpendHashTable();

 public:
  ~CFX_MapByteStringToPtr();
};

class CFX_CMapByteStringToPtr : public CFX_Object
{
 public:
  CFX_CMapByteStringToPtr(IFX_Allocator* pAllocator = NULL);
  //<<<+++OPENSOURCE_END

  ~CFX_CMapByteStringToPtr();

  void      RemoveAll();

  FX_POSITION    GetStartPosition() const;

  void      GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;

  FX_LPVOID    GetNextValue(FX_POSITION& rNextPosition) const;

  FX_BOOL      Lookup(FX_BSTR key, void*& rValue) const;

  void      SetAt(FX_BSTR key, void* value);

  void      RemoveKey(FX_BSTR key);

  int        GetCount() const;

  void      AddValue(FX_BSTR key, void* pValue);

 protected:
  /* 存储键和值的链式缓冲区。 */
  CFX_BaseSegmentedArray      m_Buffer;
};

//              列表

class CFX_PtrList : public CFX_Object
{
 protected:
  struct CNode
  {
    CNode* pNext;
    CNode* pPrev;
    void* data;
  };

 public:
  CFX_PtrList(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
  //<<<+++OPENSOURCE_END

  FX_POSITION GetHeadPosition() const { return (FX_POSITION)m_pNodeHead; }

  FX_POSITION GetTailPosition() const { return (FX_POSITION)m_pNodeTail; }

  void*  GetNext(FX_POSITION& rPosition) const
  {
    CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pNext; return pNode->data;
  }

  void*  GetPrev(FX_POSITION& rPosition) const
  {
    CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pPrev; return pNode->data;
  }

  FX_POSITION  GetNextPosition(FX_POSITION pos) const { return ((CNode*)pos)->pNext; }

  FX_POSITION  GetPrevPosition(FX_POSITION pos) const { return ((CNode*)pos)->pPrev; }

  void*  GetAt(FX_POSITION rPosition) const
  {
    CNode* pNode = (CNode*)rPosition; return pNode ? pNode->data : NULL;
  }

  int    GetCount() const { return m_nCount; }

  FX_POSITION  AddTail(void* newElement);

  FX_POSITION AddHead(void* newElement);

  void  SetAt(FX_POSITION pos, void* newElement)
  {
    CNode* pNode = (CNode*)pos; pNode->data = newElement;
  }

  FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);

  FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL ) const;

  FX_POSITION FindIndex(int index) const;

  void  RemoveAt(FX_POSITION pos);

  void  RemoveAll();

 protected:
  /* 特殊分配器指针。<b>NULL</b>表示使用默认分配器。 */
  IFX_Allocator*  m_pAllocator;

  /* 指向头部的指针。 */
  CNode* m_pNodeHead;
  /* 指向尾部的指针。 */
  CNode* m_pNodeTail;
  /* 列表中节点的数量。 */
  int m_nCount;
  /* 内部释放的节点列表。 */
  CNode* m_pNodeFree;
  /* 内部块列表。 */
  struct CFX_Plex* m_pBlocks;
  /* 每个块中节点的大小。 */
  int m_nBlockSize;

  /*
   * 分配新节点。
   *
   * @param[in] pPrev    指向前一个节点的指针。
   * @param[in] pNext    指向下一个节点的指针。
   *
   * @return 指向新节点的指针。
   */
  CNode* NewNode(CNode* pPrev, CNode* pNext);
  /*
   * 释放节点。
   *
   * @param[in] pNode    节点指针。
   */
  void FreeNode(CNode* pNode);

 public:
  ~CFX_PtrList();
};

//*****************************************************************************
//* 实用工具
//*****************************************************************************

typedef void (*PD_CALLBACK_FREEDATA)(FX_LPVOID pData);

struct FX_PRIVATEDATA
{
  void          FreeData();

  FX_LPVOID        m_pModuleId;

  FX_LPVOID        m_pData;

  PD_CALLBACK_FREEDATA  m_pCallback;

  FX_BOOL          m_bSelfDestruct;
};

class CFX_PrivateData
{
 public:
  CFX_PrivateData(IFX_Allocator* pAllocator = NULL) : m_DataList(pAllocator) {}

  ~CFX_PrivateData();

  void          ClearAll();

  void          SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback);

  void          SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject* pObj);

  FX_LPVOID        GetPrivateData(FX_LPVOID module_id);

  FX_BOOL          LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const
  {
    if (!module_id) return false;
    FX_DWORD nCount = m_DataList.GetSize();
    for (FX_DWORD n = 0; n < nCount; n++) {
      if (m_DataList[n].m_pModuleId == module_id) {
        pData = m_DataList[n].m_pData;
        return true;
      }
    }
    return false;
  }

  FX_BOOL          RemovePrivateData(FX_LPVOID module_id);

 protected:
  /* 私有数据数组。 */
  CFX_ArrayTemplate<FX_PRIVATEDATA>  m_DataList;
  /*
   * 添加私有数据。如果不存在则添加，否则修改。
   *
   * @param[in] module_id      模块id。
   * @param[in] pData          私有数据。
   * @param[in] callback       用于释放提供的私有数据的回调函数。
   * @param[in] bSelfDestruct  私有数据是否实际上是CFX_DestructObject派生对象。
   *
   * @return 无。
   */
  void          AddData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);
};

class CFX_BitStream : public CFX_Object
{
 public:
  void        Init(FX_LPCBYTE pData, FX_DWORD dwSize);

  FX_DWORD      GetBits(FX_DWORD nBits);

  void        ByteAlign();

  FX_BOOL        IsEOF() const { return m_BitPos >= m_BitSize; }

  void        SkipBits(FX_DWORD nBits) { m_BitPos += nBits; }

  void        Rewind() { m_BitPos = 0; }

 protected:
  /* 位位置（从零开始）。 */
  FX_DWORD      m_BitPos;
  /* 内存块中的总位数。 */
  FX_DWORD      m_BitSize;
  /* 位流缓冲区。 */
  FX_LPCBYTE      m_pData;
};

class CFX_BitWriter : public CFX_Object
{
 public:
  CFX_BitWriter(CFX_BinaryBuf* pBinBuf) :m_pBinBuf(pBinBuf), m_BitPos(0), m_BytePos(0) {}

  void WriteBits(FX_INT64 value, FX_INT32 nBits);

  void ByteAlign();

  int GetCurBytePos() { return m_BytePos; }

 protected:
  /* 动态二进制缓冲区。 */
  CFX_BinaryBuf * m_pBinBuf;
  /* 位位置（从零开始）。 */
  int m_BitPos;
  /* 字节位置（从零开始）。 */
  int m_BytePos;
};

template <class ObjClass> class CFX_CountRef : public CFX_Object
{
 public:
  typedef CFX_CountRef<ObjClass> Ref;

  class CountedObj : public ObjClass
  {
 public:
    CountedObj():m_RefCount(0) {}

    CountedObj(const CountedObj& src) : ObjClass(src) ,m_RefCount(0){}

    int      m_RefCount;
  };

  CFX_CountRef()
  {
    m_pObject = NULL;
  }

  CFX_CountRef(const Ref& ref)
  {
    m_pObject = ref.m_pObject;
    if (m_pObject) m_pObject->m_RefCount ++;
  }

  ~CFX_CountRef()
  {
    if (!m_pObject) return;
    m_pObject->m_RefCount --;
    if (m_pObject->m_RefCount <= 0) {
      delete m_pObject;
      m_pObject = NULL;
    }
  }

  ObjClass*      New()
  {
    if (m_pObject) {
      m_pObject->m_RefCount --;
      if (m_pObject->m_RefCount <= 0)
        delete m_pObject;
      m_pObject = NULL;
    }
    m_pObject = FX_NEW CountedObj;
    if (!m_pObject) return NULL;
    m_pObject->m_RefCount = 1;
    return m_pObject;
  }

  void        operator = (const Ref& ref)
  {
    if (ref.m_pObject)
      ref.m_pObject->m_RefCount ++;
    if (m_pObject) {
      m_pObject->m_RefCount --;
      if (m_pObject->m_RefCount <= 0)
        delete m_pObject;
    }
    m_pObject = ref.m_pObject;
  }

  void        operator = (void* p)
  {
    FXSYS_assert(p == 0);
    if (m_pObject == NULL) return;
    m_pObject->m_RefCount --;
    if (m_pObject->m_RefCount <= 0)
      delete m_pObject;
    m_pObject = NULL;
  }

        const ObjClass* GetObjectF() const
        {
                return m_pObject;
        }
        operator      const ObjClass*() const
        {
                return m_pObject;
        }

  FX_BOOL        IsNull() const
  {
    return m_pObject == NULL;
  }
  FX_BOOL        NotNull() const
  {
    return m_pObject != NULL;
  }

  ObjClass*      GetModify()
  {
    if (m_pObject == NULL) {
      m_pObject = FX_NEW CountedObj;
      if (m_pObject)
        m_pObject->m_RefCount = 1;
    } else if (m_pObject->m_RefCount > 1) {
      m_pObject->m_RefCount --;
      CountedObj* pOldObject = m_pObject;
      m_pObject = NULL;
      m_pObject = FX_NEW CountedObj(*pOldObject);
      if (m_pObject)
        m_pObject->m_RefCount = 1;
    }
    return m_pObject;
  }

  void        SetNull()
  {
    if (m_pObject == NULL) return;
    m_pObject->m_RefCount --;
    if (m_pObject->m_RefCount <= 0)
      delete m_pObject;
    m_pObject = NULL;
  }

  FX_BOOL        operator == (const Ref& ref) const
  {
    return m_pObject == ref.m_pObject;
  }

  int          RefCount() const
  {
    return m_pObject ? m_pObject->m_RefCount : 0;
  }

  void        Incref()
  {
    if (m_pObject == NULL) return;
    m_pObject->m_RefCount++;
  }

  void        Decref()
  {
    if (m_pObject == NULL) return;
    m_pObject->m_RefCount--;
    if (m_pObject->m_RefCount <= 0) {
      delete m_pObject;
      m_pObject = NULL;
    }
  }

 protected:
  /* 引用计数对象内部。 */
  CountedObj*      m_pObject;
};

class IFX_Pause
{
 public:
  virtual ~IFX_Pause() {}

  virtual FX_BOOL  NeedToPauseNow() = 0;
};

class CFX_DataFilter : public CFX_Object
{
 public:
  virtual ~CFX_DataFilter();

  void      SetDestFilter(CFX_DataFilter* pFilter);

  FX_BOOL      IsEOF() const { return m_bEOF; }

  FX_FILESIZE    GetSrcPos() const { return m_SrcPos; }

  void      FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf);

  void      FilterFinish(CFX_BinaryBuf& dest_buf);

  FX_BOOL      IsExhaustBuffer() const { return m_bExhaustBuffer; }

  FX_BOOL      NeedNewSrc();

  FX_BOOL      Abort() const { return m_bAbort; }

  FX_BOOL      AbortAll();

  void      ResetStatistics();

 protected:
  /* 构造函数。 */
  CFX_DataFilter();

  virtual void  v_FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf) = 0;
  virtual void  v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;
  virtual void  v_ResetStatistics() {};
  void      ReportEOF(FX_FILESIZE left_input);

  /* 源流中的当前位置。 */
  FX_FILESIZE    m_SrcPos;

  /* 存储FilterIn函数的输出数据。*/
  CFX_BinaryBuf  m_FilterInBuffer;

  /* 指示此过滤器是否中止过滤器处理。例如，RunLenFilter遇到错误的输入数据。 */
  FX_BOOL      m_bAbort;
  /* 指示是否遇到EOF。 */
  FX_BOOL m_bEOF;
  /* 指示此过滤器是否耗尽输入缓冲区。 */
  FX_BOOL m_bExhaustBuffer;
  /* 过滤器链。 */
  CFX_DataFilter* m_pDestFilter;
};

template<typename T>
class CFX_AutoRestorer {
 public:
  explicit CFX_AutoRestorer(T* location) {
    m_Location = location;
    m_OldValue = *location;
  }

  ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
 private:
  T* m_Location;
  T m_OldValue;
};

template <class T>
class CFX_SmartPointer
{
 public:
  CFX_SmartPointer(T *pObj) : m_pObj(pObj) {}

  ~CFX_SmartPointer() {m_pObj->Release();}

  T*    Get(void)  {return m_pObj;}

  T&    operator *(void)  {return *m_pObj;}

  T*    operator ->(void)  {return m_pObj;}

 protected:
  T *m_pObj;
};

#define FX_DATALIST_LENGTH  1024

template<size_t unit>
class CFX_SortListArray : public CFX_Object
{
 protected:
  struct DataList {
    FX_INT32  start;
    FX_INT32  count;
    FX_LPBYTE  data;
    DataList()
    {
      start = count = 0;
      data = NULL;
    }
  };

 public:
  CFX_SortListArray(IFX_Allocator* pAllocator = NULL) : m_CurList(0), m_DataLists(pAllocator) {}

  ~CFX_SortListArray()
  {
    Clear();
  }

  void      Clear()
  {
    IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;

    for (FX_INT32 i = m_DataLists.GetUpperBound(); i >= 0; i--){
      DataList list = m_DataLists.ElementAt(i);
      if (list.data) FX_Allocator_Free(pAllocator, list.data);
    }
    m_DataLists.RemoveAll();
    m_CurList = 0;
  }

  void      Append(FX_INT32 nStart, FX_INT32 nCount)
  {
    if (nStart < 0) return;

    IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;

    while (nCount > 0){
      FX_INT32 temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
      DataList list;

      list.data = FX_Allocator_Alloc(pAllocator, FX_BYTE, temp_count * unit);
      if (!list.data) break;
      FXSYS_memset32(list.data, 0, temp_count * unit);
      list.start = nStart;
      list.count = temp_count;

      FX_BOOL ret = Append(list);
      if(ret)
      {
        nCount -= temp_count;
        nStart += temp_count;
      }
      else
      {
        if (list.data) FX_Allocator_Free(pAllocator, list.data);
        return;
      }
    }
  }

  FX_LPBYTE    GetAt(FX_INT32 nIndex)
  {
    if (nIndex < 0) return NULL;
    if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) return NULL;
    DataList *pCurList = m_DataLists.GetDataPtr(m_CurList);
    if (!pCurList || nIndex < pCurList->start || nIndex >= pCurList->start + pCurList->count){
      pCurList = NULL;
      FX_INT32 iStart = 0;
      FX_INT32 iEnd = m_DataLists.GetUpperBound();
      while (iStart <= iEnd){
        FX_INT32 iMid = (iStart + iEnd) / 2;
        DataList* list = m_DataLists.GetDataPtr(iMid);
        if (nIndex < list->start)
          iEnd = iMid - 1;
        else if (nIndex >= list->start + list->count)
          iStart = iMid + 1;
        else {
          pCurList = list;
          m_CurList = iMid;
          break;
        }
      }
    }
    return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
  }

 protected:
  FX_BOOL      Append(const DataList& list)
  {
    FX_INT32 iStart = 0;
    FX_INT32 iEnd = m_DataLists.GetUpperBound();
    FX_INT32 iFind = 0;
    while (iStart <= iEnd) {
      FX_INT32 iMid = (iStart + iEnd) / 2;
      DataList* cur_list = m_DataLists.GetDataPtr(iMid);
      if (list.start == cur_list->start){
        return false; // 列表重叠，无操作
      } else if (list.start < cur_list->start + cur_list->count)
        iEnd = iMid - 1;
      else{
        if (iMid == iEnd){
          iFind = iMid + 1;
          break;
        }
        DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);
        if (list.start == next_list->start){
          return false; // 列表重叠，无操作
        } else if (list.start < next_list->start){
          iFind = iMid + 1;
          break;
        } else {
          iStart = iMid + 1;
        }
      }
    }
    m_DataLists.InsertAt(iFind, list);
    return true;
  }

  FX_INT32    m_CurList;
  CFX_ArrayTemplate<DataList>  m_DataLists;
};

template<typename T1, typename T2>
class CFX_ListArrayTemplate : public CFX_Object
{
 public:
  void      Clear()
  {
    m_Data.Clear();
  }

  void      Add(FX_INT32 nStart, FX_INT32 nCount)
  {
    m_Data.Append(nStart, nCount);
  }

  T2& operator [] (FX_INT32 nIndex)
  {
    FX_LPBYTE data = m_Data.GetAt(nIndex);
    FXSYS_assert(data != NULL);

    return (T2&)(*(volatile T2*)data);
  }

  T2* GetPtrAt(FX_INT32 nIndex)
  {
    return (T2*)m_Data.GetAt(nIndex);
  }
 protected:
  T1      m_Data;
};

typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>, FX_FILESIZE>  CFX_FileSizeListArray;
typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_DWORD)>, FX_DWORD>    CFX_DWordListArray;

typedef enum {
    Ready,
    ToBeContinued,
    Found,
    NotFound,
    Failed,
    Done
} FX_ProgressiveStatus;

#define ProgressiveStatus  FX_ProgressiveStatus

#ifdef _FX_NO_NAMESPACE_
//<<<+++OPENSOURCE_BEGIN LIC==FOXIT
#define FX_NAMESPACE_DECLARE(namespace, type)       type
//<<<+++OPENSOURCE_END
#else
//<<<+++OPENSOURCE_BEGIN LIC==GOOGLE
#define FX_NAMESPACE_DECLARE(namespace, type)       namespace::type
//<<<+++OPENSOURCE_END
#endif

class IFX_Unknown
{
 public:
  virtual FX_DWORD  Release() = 0;

  virtual FX_DWORD  AddRef() = 0;

 protected:
  virtual ~IFX_Unknown() {}
};

#define FX_IsOdd(a)  ((a) & 1)

//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#endif // _FX_BASIC_H_
//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_END